* LANGUAGES: Follow spelling conventions.
* rtl.def: Likewise.
* sbitmap.c: Likewise.
* sched-int.h: Likewise.
* sched-rgn.c: Likewise.
* sibcall.c: Likewise.
* simplify-rtx.c: Likewise.
* ssa.c: Likewise.
* stab.def: Likewise.
* stmt.c: Likewise.
* stor-layout.c: Likewise.
* target.h: Likewise.
* timevar.c: Likewise.
* toplev.c: Likewise.
* tree-dump.c: Likewise.
* tree-inline.c: Likewise.
* tree.c: Likewise.
* tree.def: Likewise.
* tree.h: Likewise.
* unroll.c: Likewise.
* varasm.c: Likewise.
* vmsdbgout.c: Likewise.
* treelang/treelang.texi: Likewise.
* treelang/treetree.c: Likewise.
From-SVN: r57587
+2002-09-27 Kazu Hirata <kazu@cs.umass.edu>
+
+ * LANGUAGES: Follow spelling conventions.
+ * rtl.def: Likewise.
+ * sbitmap.c: Likewise.
+ * sched-int.h: Likewise.
+ * sched-rgn.c: Likewise.
+ * sibcall.c: Likewise.
+ * simplify-rtx.c: Likewise.
+ * ssa.c: Likewise.
+ * stab.def: Likewise.
+ * stmt.c: Likewise.
+ * stor-layout.c: Likewise.
+ * target.h: Likewise.
+ * timevar.c: Likewise.
+ * toplev.c: Likewise.
+ * tree-dump.c: Likewise.
+ * tree-inline.c: Likewise.
+ * tree.c: Likewise.
+ * tree.def: Likewise.
+ * tree.h: Likewise.
+ * unroll.c: Likewise.
+ * varasm.c: Likewise.
+ * vmsdbgout.c: Likewise.
+ * treelang/treelang.texi: Likewise.
+ * treelang/treetree.c: Likewise.
+
2002-09-27 Kazu Hirata <kazu@cs.umass.edu>
* config/h8300/h8300.c (compute_saved_regs): Use a macro
from the input stream, and to push them back into the input stream respectively.
The third argument is a pointer to a null terminate string which is the first
word after #pragma. The expression supplied by HANDLE_PRAGMA should return
- non-zero if it parsed and implemented the pragma. Otherwise it should return
+ nonzero if it parsed and implemented the pragma. Otherwise it should return
zero, and leave the input stream as it was before the expression was evaluated.
A new back-end definable macro has been added: INSERT_ATTRIBUTES. This macro
/* General conditional. The first operand is a vector composed of pairs of
expressions. The first element of each pair is evaluated, in turn.
The value of the conditional is the second expression of the first pair
- whose first expression evaluates non-zero. If none of the expressions is
+ whose first expression evaluates nonzero. If none of the expressions is
true, the second operand will be used as the value of the conditional.
This should be replaced with use of IF_THEN_ELSE. */
}
/* Set DST to be (A and B).
- Return non-zero if any change is made. */
+ Return nonzero if any change is made. */
bool
sbitmap_a_and_b_cg (dst, a, b)
}
/* Set DST to be (A xor B)).
- Return non-zero if any change is made. */
+ Return nonzero if any change is made. */
bool
sbitmap_a_xor_b_cg (dst, a, b)
}
/* Set DST to be (A or B)).
- Return non-zero if any change is made. */
+ Return nonzero if any change is made. */
bool
sbitmap_a_or_b_cg (dst, a, b)
*dstp++ = *ap++ | *bp++;
}
-/* Return non-zero if A is a subset of B. */
+/* Return nonzero if A is a subset of B. */
bool
sbitmap_a_subset_b_p (a, b)
}
/* Set DST to be (A or (B and C)).
- Return non-zero if any change is made. */
+ Return nonzero if any change is made. */
bool
sbitmap_a_or_b_and_c_cg (dst, a, b, c)
}
/* Set DST to be (A and (B or C)).
- Return non-zero if any change is made. */
+ Return nonzero if any change is made. */
bool
sbitmap_a_and_b_or_c_cg (dst, a, b, c)
int clobbers_length;
} *reg_last;
- /* Element N is set for each register that has any non-zero element
+ /* Element N is set for each register that has any nonzero element
in reg_last[N].{uses,sets,clobbers}. */
regset_head reg_last_in_use;
};
first so that we can verify that live_at_start didn't change. Then
do all other blocks. */
/* ??? There is an outside possibility that update_life_info, or more
- to the point propagate_block, could get called with non-zero flags
+ to the point propagate_block, could get called with nonzero flags
more than once for one basic block. This would be kinda bad if it
were to happen, since REG_INFO would be accumulated twice for the
block, and we'd have twice the REG_DEAD notes.
/* Examine a CALL_PLACEHOLDER pattern and determine where the call's
return value is located. P_HARD_RETURN receives the hard register
that the function used; P_SOFT_RETURN receives the pseudo register
- that the sequence used. Return non-zero if the values were located. */
+ that the sequence used. Return nonzero if the values were located. */
static int
identify_call_return_value (cp, p_hard_return, p_soft_return)
{
case PLUS:
/* Maybe simplify x + 0 to x. The two expressions are equivalent
- when x is NaN, infinite, or finite and non-zero. They aren't
+ when x is NaN, infinite, or finite and nonzero. They aren't
when x is -0 and the rounding mode is not towards -infinity,
since (-0) + 0 is then 0. */
if (!HONOR_SIGNED_ZEROS (mode) && trueop1 == CONST0_RTX (mode))
return CONST0_RTX (mode);
/* Change subtraction from zero into negation. (0 - x) is the
- same as -x when x is NaN, infinite, or finite and non-zero.
+ same as -x when x is NaN, infinite, or finite and nonzero.
But if the mode has signed zeros, and does not round towards
-infinity, then 0 - 0 is 0, not -0. */
if (!HONOR_SIGNED_ZEROS (mode) && trueop0 == CONST0_RTX (mode))
the same hard register in the same machine mode are in the same
class. */
-/* If conservative_reg_partition is non-zero, use a conservative
+/* If conservative_reg_partition is nonzero, use a conservative
register partitioning algorithm (which leaves more regs after
emerging from SSA) instead of the coalescing one. This is being
left in for a limited time only, as a debugging tool until the
}
/* Given the SET of a phi node, remove the alternative for predecessor
- block C. Return non-zero on success, or zero if no alternative is
+ block C. Return nonzero on success, or zero if no alternative is
found for C. */
int
and C is the ith predecessor of B,
then T0 and Ti must be equivalent.
- Return non-zero iff any such cases were found for which the two
+ Return nonzero iff any such cases were found for which the two
regs were not already in the same class. */
static int
destination, the regno of the phi argument corresponding to BB,
and DATA.
- If FN ever returns non-zero, stops immediately and returns this
+ If FN ever returns nonzero, stops immediately and returns this
value. Otherwise, returns zero. */
int
__define_stab (N_BROWS, 0x48, "BROWS")
/* GNU Modula-2 definition module dependency. Value is the modification time
- of the definition file. Other is non-zero if it is imported with the
+ of the definition file. Other is nonzero if it is imported with the
GNU M2 keyword %INITIALIZE. Perhaps N_M2C can be used if there
are enough empty fields? */
__define_stab(N_DEFD, 0x4a, "DEFD")
return (cfun->stmt == NULL || loop_stack == NULL);
}
-/* Return non-zero if we should preserve sub-expressions as separate
+/* Return nonzero if we should preserve sub-expressions as separate
pseudos. We never do so if we aren't optimizing. We always do so
if -fexpensive-optimizations.
pop_temp_slots ();
}
-/* Given a pointer to a BLOCK node return non-zero if (and only if) the node
+/* Given a pointer to a BLOCK node return nonzero if (and only if) the node
in question represents the outermost pair of curly braces (i.e. the "body
block") of a function or method.
This is sometimes used to avoid a cleanup associated with
a value that is being returned out of the scope.
- If IN_FIXUP is non-zero, we are generating this cleanup for a fixup
+ If IN_FIXUP is nonzero, we are generating this cleanup for a fixup
goto and handle protection regions specially in that case.
If REACHABLE, we emit code, otherwise just inform the exception handling
The value is measured in bits. */
unsigned int maximum_field_alignment;
-/* If non-zero, the alignment of a bitstring or (power-)set value, in bits.
+/* If nonzero, the alignment of a bitstring or (power-)set value, in bits.
May be overridden by front-ends. */
unsigned int set_alignment = 0;
return chain;
}
-/* Return non-zero if EXPR is present on the pending sizes list. */
+/* Return nonzero if EXPR is present on the pending sizes list. */
int
is_pending_size (expr)
affect the alignment of a record; even a zero-sized field
can do this. The alignment should be to the alignment of
the type, except that for zero-size bitfields this only
- applies if there was an immediately prior, non-zero-size
+ applies if there was an immediately prior, nonzero-size
bitfield. (That's the way it is, experimentally.) */
if (! integer_zerop (DECL_SIZE (field))
? ! DECL_PACKED (field)
void (* eh_frame_section) PARAMS ((void));
/* Select and switch to a section for EXP. It may be a DECL or a
- constant for which TREE_CST_RTL is valid. RELOC is non-zero if
+ constant for which TREE_CST_RTL is valid. RELOC is nonzero if
runtime relocations must be applied; bit 1 will be set if the
runtime relocations require non-local name resolution. ALIGN is
the required alignment of the data. */
/* See timevar.h for an explanation of timing variables. */
-/* This macro evaluates to non-zero if timing variables are enabled. */
+/* This macro evaluates to nonzero if timing variables are enabled. */
#define TIMEVAR_ENABLE (time_report)
/* A timing variable. */
int optimize = 0;
/* Nonzero means optimize for size. -Os.
- The only valid values are zero and non-zero. When optimize_size is
- non-zero, optimize defaults to 2, but certain individual code
+ The only valid values are zero and nonzero. When optimize_size is
+ nonzero, optimize defaults to 2, but certain individual code
bloating optimizations are disabled. */
int optimize_size = 0;
/* Do any final processing required for the declarations in VEC, of
which there are LEN. We write out inline functions and variables
that have been deferred until this point, but which are required.
- Returns non-zero if anything was put out. */
+ Returns nonzero if anything was put out. */
int
wrapup_global_declarations (vec, len)
minimal options processing. Outputting diagnostics is OK, but GC
and identifier hashtables etc. are not initialized yet.
- Return non-zero to suppress compiler back end initialization. */
+ Return nonzero to suppress compiler back end initialization. */
static void
parse_options_and_default_flags (argc, argv)
int argc;
expand_dummy_function_end ();
}
\f
-/* Language-dependent initialization. Returns non-zero on success. */
+/* Language-dependent initialization. Returns nonzero on success. */
static int
lang_dependent_init (name)
const char *name;
fprintf (di->stream, "\n");
}
-/* Return non-zero if FLAG has been specified for the dump, and NODE
+/* Return nonzero if FLAG has been specified for the dump, and NODE
is not the root node of the dump. */
int dump_flag (di, flag, node)
return stream;
}
-/* Returns non-zero if tree dump PHASE is enabled. */
+/* Returns nonzero if tree dump PHASE is enabled. */
int
dump_enabled_p (phase)
fclose (stream);
}
-/* Parse ARG as a dump switch. Return non-zero if it is, and store the
+/* Parse ARG as a dump switch. Return nonzero if it is, and store the
relevant details in the dump_files array. */
int
return NULL_TREE;
}
-/* Returns non-zero if a function can be inlined as a tree. */
+/* Returns nonzero if a function can be inlined as a tree. */
int
tree_inlinable_function_p (fn)
return inlinable_function_p (fn, NULL);
}
-/* Returns non-zero if FN is a function that can be inlined into the
+/* Returns nonzero if FN is a function that can be inlined into the
inlining context ID_. If ID_ is NULL, check whether the function
can be inlined at all. */
return false;
}
-/* Return non-zero if IDENT is a valid name for attribute ATTR,
+/* Return nonzero if IDENT is a valid name for attribute ATTR,
or zero if not.
We try both `text' and `__text__', ATTR may be either one. */
could either point to another BLOCK node or it could point to a
FUNCTION_DECL node (e.g. in the case of a block representing the
outermost scope of a particular inlining of a function).
- BLOCK_ABSTRACT is non-zero if the block represents an abstract
+ BLOCK_ABSTRACT is nonzero if the block represents an abstract
instance of a block (i.e. one which is nested within an abstract
instance of an inline function).
- TREE_ASM_WRITTEN is non-zero if the block was actually referenced
+ TREE_ASM_WRITTEN is nonzero if the block was actually referenced
in the generated assembly. */
DEFTREECODE (BLOCK, "block", 'b', 0)
\f
holds a line number. In some cases these can be the location of
a reference, if no definition has been seen.
- DECL_ABSTRACT is non-zero if the decl represents an abstract instance
+ DECL_ABSTRACT is nonzero if the decl represents an abstract instance
of a decl (i.e. one which is nested within an abstract instance of a
inline function. */
extern const char tree_code_type[];
#define TREE_CODE_CLASS(CODE) tree_code_type[(int) (CODE)]
-/* Returns non-zero iff CLASS is the tree-code class of an
+/* Returns nonzero iff CLASS is the tree-code class of an
expression. */
#define IS_EXPR_CODE_CLASS(CLASS) \
as DECL_NAME. It is an IDENTIFIER_NODE. */
#define DECL_ASSEMBLER_NAME(NODE) decl_assembler_name (NODE)
-/* Returns non-zero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
+/* Returns nonzero if the DECL_ASSEMBLER_NAME for NODE has been set. If zero,
the NODE might still have a DECL_ASSEMBLER_NAME -- it just hasn't been set
yet. */
#define DECL_ASSEMBLER_NAME_SET_P(NODE) \
: (make_decl_rtl (NODE, NULL), (NODE)->decl.rtl))
/* Set the DECL_RTL for NODE to RTL. */
#define SET_DECL_RTL(NODE, RTL) (DECL_CHECK (NODE)->decl.rtl = (RTL))
-/* Returns non-zero if the DECL_RTL for NODE has already been set. */
+/* Returns nonzero if the DECL_RTL for NODE has already been set. */
#define DECL_RTL_SET_P(NODE) (DECL_CHECK (NODE)->decl.rtl != NULL)
/* Copy the RTL from NODE1 to NODE2. If the RTL was not set for
NODE1, it will not be set for NODE2; this is a lazy copy. */
/* In a FIELD_DECL, indicates this field should be bit-packed. */
#define DECL_PACKED(NODE) (FIELD_DECL_CHECK (NODE)->decl.regdecl_flag)
-/* In a FUNCTION_DECL with a non-zero DECL_CONTEXT, indicates that a
+/* In a FUNCTION_DECL with a nonzero DECL_CONTEXT, indicates that a
static chain is not needed. */
#define DECL_NO_STATIC_CHAIN(NODE) \
(FUNCTION_DECL_CHECK (NODE)->decl.regdecl_flag)
extern int valid_machine_attribute PARAMS ((tree, tree, tree, tree));
-/* Given a tree node and a string, return non-zero if the tree node is
+/* Given a tree node and a string, return nonzero if the tree node is
a valid attribute name for the string. */
extern int is_attribute_p PARAMS ((const char *, tree));
/* If nonzero, an upper limit on alignment of structure fields, in bits. */
extern unsigned int maximum_field_alignment;
-/* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */
+/* If nonzero, the alignment of a bitstring or (power-)set value, in bits. */
extern unsigned int set_alignment;
/* Concatenate two lists (chains of TREE_LIST nodes) X and Y
if_statement: if (expression) @{ statements @} else @{ statements @}
The first lot of statements is executed if the expression is
-non-zero. Otherwise the second lot of statements is executed. Either
+nonzero. Otherwise the second lot of statements is executed. Either
list of statements may be empty, but both sets of braces and the else must be present.
@smallexample
exp,
build1 (CONVERT_EXPR, TREE_TYPE (exp), integer_zero_node));
emit_line_note ((const char *)filename, lineno); /* Output the line number information. */
- expand_start_cond (cond_exp, /* Exit-able if non zero. */ 0);
+ expand_start_cond (cond_exp, /* Exit-able if nonzero. */ 0);
}
/* Output the code for the else of an if statement. The else occurred
UNROLL_NAIVE
};
-/* Indexed by register number, if non-zero, then it contains a pointer
+/* Indexed by register number, if nonzero, then it contains a pointer
to a struct induction for a DEST_REG giv which has been combined with
one of more address givs. This is needed because whenever such a DEST_REG
giv is modified, we must modify the value of all split address givs
it is unsafe to split the biv since it may not have the proper
value on loop exit. */
- /* loop_number_exit_count is non-zero if the loop has an exit other than
+ /* loop_number_exit_count is nonzero if the loop has an exit other than
a fall through at the end. */
biv_splittable = 1;
|| GET_CODE (SET_SRC (tem)) != PLUS)
biv_splittable = 0;
- /* If final value is non-zero, then must emit an instruction which sets
+ /* If final value is nonzero, then must emit an instruction which sets
the value of the biv to the proper value. This is done after
handling all of the givs, since some of them may need to use the
biv's value in their initialization code. */
result += find_splittable_givs (loop, bl, unroll_type, increment,
unroll_number);
- /* If final value is non-zero, then must emit an instruction which sets
+ /* If final value is nonzero, then must emit an instruction which sets
the value of the biv to the proper value. This is done after
handling all of the givs, since some of them may need to use the
biv's value in their initialization code. */
/* Should emit insns after the loop if possible, as the biv final value
code below does. */
- /* If the final value is non-zero, and the giv has not been reduced,
+ /* If the final value is nonzero, and the giv has not been reduced,
then must emit an instruction to set the final value. */
if (final_value && !v->new_reg)
{
#endif
} in_section = no_section;
-/* Return a non-zero value if DECL has a section attribute. */
+/* Return a nonzero value if DECL has a section attribute. */
#ifndef IN_NAMED_SECTION
#define IN_NAMED_SECTION(DECL) \
((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
#endif
\f
/* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
- a non-zero value if the constant pool should be output before the
+ a nonzero value if the constant pool should be output before the
start of the function, or a zero value if the pool should output
after the end of the function. The default is to put it before the
start. */
/* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
the alignment of the integer in bits. Return 1 if we were able to output
- the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
+ the constant, otherwise 0. If FORCE is nonzero, abort if we can't output
the constant. */
bool
return STRHASH (((const struct deferred_string *) x)->label);
}
-/* 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
struct deferred_string *) is the same as that given by Y
(which is really a char *). */
Otherwise, output such a constant in memory (or defer it for later)
and generate an rtx for it.
- If DEFER is non-zero, the output of string constants can be deferred
+ If DEFER is nonzero, the output of string constants can be deferred
and output only if referenced in the function after all optimizations.
The TREE_CST_RTL of EXP is set up to point to that rtx.
/* Output the debug header HEADER. Also output COMMENT if flag_verbose_asm is
set. Return the header size. Just return the size if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_debug_header (header, comment, dosizeonly)
/* Output the address of SYMBOL. Also output COMMENT if flag_verbose_asm is
set. Return the address size. Just return the size if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_debug_addr (symbol, comment, dosizeonly)
/* Output the single byte DATA1. Also output COMMENT if flag_verbose_asm is
set. Return the data size. Just return the size if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_debug_data1 (data1, comment, dosizeonly)
/* Output the single word DATA2. Also output COMMENT if flag_verbose_asm is
set. Return the data size. Just return the size if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_debug_data2 (data2, comment, dosizeonly)
}
/* Output double word DATA4. Also output COMMENT if flag_verbose_asm is set.
- Return the data size. Just return the size if DOSIZEONLY is non-zero. */
+ Return the data size. Just return the size if DOSIZEONLY is nonzero. */
static int
write_debug_data4 (data4, comment, dosizeonly)
}
/* Output quad word DATA8. Also output COMMENT if flag_verbose_asm is set.
- Return the data size. Just return the size if DOSIZEONLY is non-zero. */
+ Return the data size. Just return the size if DOSIZEONLY is nonzero. */
static int
write_debug_data8 (data8, comment, dosizeonly)
/* Output the difference between LABEL1 and LABEL2. Also output COMMENT if
flag_verbose_asm is set. Return the data size. Just return the size if
- DOSIZEONLY is non-zero. */
+ DOSIZEONLY is nonzero. */
static int
write_debug_delta4 (label1, label2, comment, dosizeonly)
/* Output a character string STRING. Also write COMMENT if flag_verbose_asm is
set. Return the string length. Just return the length if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_debug_string (string, comment, dosizeonly)
}
/* Output a module begin header and return the header size. Just return the
- size if DOSIZEONLY is non-zero. */
+ size if DOSIZEONLY is nonzero. */
static int
write_modbeg (dosizeonly)
}
/* Output a module end trailer and return the trailer size. Just return
- the size if DOSIZEONLY is non-zero. */
+ the size if DOSIZEONLY is nonzero. */
static int
write_modend (dosizeonly)
}
/* Output a routine begin header routine RTNNUM and return the header size.
- Just return the size if DOSIZEONLY is non-zero. */
+ Just return the size if DOSIZEONLY is nonzero. */
static int
write_rtnbeg (rtnnum, dosizeonly)
}
/* Output a routine end trailer for routine RTNNUM and return the header size.
- Just return the size if DOSIZEONLY is non-zero. */
+ Just return the size if DOSIZEONLY is nonzero. */
static int
write_rtnend (rtnnum, dosizeonly)
: (I) < 65536 ? DST_K_INCR_LINUM_W : DST_K_INCR_LINUM_L)
/* Output the PC to line number correlations and return the size. Just return
- the size if DOSIZEONLY is non-zero */
+ the size if DOSIZEONLY is nonzero */
static int
write_pclines (dosizeonly)
/* Output a source correlation for file FILEID using information saved in
FILE_INFO_ENTRY and return the size. Just return the size if DOSIZEONLY is
- non-zero. */
+ nonzero. */
static int
write_srccorr (fileid, file_info_entry, dosizeonly)
}
/* Output all the source correlation entries and return the size. Just return
- the size if DOSIZEONLY is non-zero. */
+ the size if DOSIZEONLY is nonzero. */
static int
write_srccorrs (dosizeonly)
projects / gcc.git / commitdiff