is understood to specify a target object file.
Since @option{-E} is not implied, @option{-MD} can be used to generate
-a dependency output file as a side-effect of the compilation process.
+a dependency output file as a side effect of the compilation process.
@item -MMD
@opindex MMD
like @option{-C}, except that comments contained within macros are
also passed through to the output file where the macro is expanded.
-In addition to the side-effects of the @option{-C} option, the
+In addition to the side effects of the @option{-C} option, the
@option{-CC} option causes all C++-style comments inside a macro
to be converted to C-style comments. This is to prevent later use
of that macro from inadvertently commenting out the remainder of
@end smallexample
@noindent
-If the value in it has side-effects, the side-effects happen only once,
+If the value in it has side effects, the side effects happen only once,
not for each initialized field by the range initializer.
@noindent
@noindent
If the same field is initialized multiple times, it has the value from
the last initialization. If any such overridden initialization has
-side-effect, it is unspecified whether the side-effect happens or not.
+side effect, it is unspecified whether the side effect happens or not.
Currently, GCC discards them and issues a warning.
@node Case Ranges
inlining.
@c Don't enumerate the optimizations by name here; we try to be
@c future-compatible with this mechanism.
-If the function does not have side-effects, there are optimizations
+If the function does not have side effects, there are optimizations
other than inlining that cause function calls to be optimized away,
although the function call is live. To keep such calls from being
optimized away, put
@noindent
(@pxref{Extended Asm}) in the called function, to serve as a special
-side-effect.
+side effect.
@item noipa
@cindex @code{noipa} function attribute
and perform addition on those promoted operands. The result is then
cast to the type of the third argument. If the cast result is equal to the infinite
precision result, the built-in functions return false, otherwise they return true.
-The value of the third argument is ignored, just the side-effects in the third argument
+The value of the third argument is ignored, just the side effects in the third argument
are evaluated, and no integral argument promotions are performed on the last argument.
If the third argument is a bit-field, the type used for the result cast has the
precision and signedness of the given bit-field, rather than precision and signedness
is a built-in construct that returns a constant number of bytes from
@var{ptr} to the end of the object @var{ptr} pointer points to
(if known at compile time). @code{__builtin_object_size} never evaluates
-its arguments for side-effects. If there are any side-effects in them, it
+its arguments for side effects. If there are any side effects in them, it
returns @code{(size_t) -1} for @var{type} 0 or 1 and @code{(size_t) 0}
for @var{type} 2 or 3. If there are multiple objects @var{ptr} can
point to and all of them are known at compile time, the returned number
except that the expression returned has its type unaltered by promotion
rules. Also, the built-in function does not evaluate the expression
that is not chosen. For example, if @var{const_exp} evaluates to true,
-@var{exp2} is not evaluated even if it has side-effects.
+@var{exp2} is not evaluated even if it has side effects.
This built-in function can return an lvalue if the chosen argument is an
lvalue.
started successfully (note this is not 0, so the constant has to be
explicitly tested).
-If the transaction aborts, all side-effects
+If the transaction aborts, all side effects
are undone and an abort code encoded as a bit mask is returned.
The following macros are defined:
@deftypefn {RTM Function} {void} _xend ()
Commit the current transaction. When no transaction is active this faults.
-All memory side-effects of the transaction become visible
+All memory side effects of the transaction become visible
to other threads in an atomic manner.
@end deftypefn
As a GNU extension, the C language front-ends allow the second
operand of the @code{?:} operator may be omitted in the source.
For example, @code{x ? : 3} is equivalent to @code{x ? x : 3},
-assuming that @code{x} is an expression without side-effects.
+assuming that @code{x} is an expression without side effects.
In the tree representation, however, the second operand is always
present, possibly protected by @code{SAVE_EXPR} if the first
-argument does cause side-effects.
+argument does cause side effects.
@item CALL_EXPR
These nodes are used to represent calls to functions, including
@item SAVE_EXPR
A @code{SAVE_EXPR} represents an expression (possibly involving
-side-effects) that is used more than once. The side-effects should
+side effects) that is used more than once. The side effects should
occur only the first time the expression is evaluated. Subsequent uses
should just reuse the computed value. The first operand to the
-@code{SAVE_EXPR} is the expression to evaluate. The side-effects should
+@code{SAVE_EXPR} is the expression to evaluate. The side effects should
be executed where the @code{SAVE_EXPR} is first encountered in a
depth-first preorder traversal of the expression tree.
Operand @code{OMP_FOR_INCR} is the loop index increment of the
form @code{VAR @{+=,-=@} INCR}.
-Operand @code{OMP_FOR_PRE_BODY} contains side-effect code from
+Operand @code{OMP_FOR_PRE_BODY} contains side effect code from
operands @code{OMP_FOR_INIT}, @code{OMP_FOR_COND} and
-@code{OMP_FOR_INC}. These side-effects are part of the
+@code{OMP_FOR_INC}. These side effects are part of the
@code{OMP_FOR} block but must be evaluated before the start of
loop body.
@code{N1} and @code{N2} and the increment expression
@code{INCR} are required to be loop invariant integer
expressions that are evaluated without any synchronization. The
-evaluation order, frequency of evaluation and side-effects are
+evaluation order, frequency of evaluation and side effects are
unspecified by the standard.
@item OMP_SECTIONS
According to the C standard, such an expression is an rvalue whose type
is the unqualified version of its original type, i.e. @code{int}. Whether
GCC interprets this as a read of the volatile object being pointed to or
-only as a request to evaluate the expression for its side-effects depends
+only as a request to evaluate the expression for its side effects depends
on this type.
If it is a scalar type, or on most targets an aggregate type whose only
member object is of a scalar type, or a union type whose member objects
are of scalar types, the expression is interpreted by GCC as a read of
the volatile object; in the other cases, the expression is only evaluated
-for its side-effects.
+for its side effects.
@end itemize
@item -ftree-builtin-call-dce
@opindex ftree-builtin-call-dce
Perform conditional dead code elimination (DCE) for calls to built-in functions
-that may set @code{errno} but are otherwise side-effect free. This flag is
+that may set @code{errno} but are otherwise free of side effects. This flag is
enabled by default at @option{-O2} and higher if @option{-Os} is not also
specified.
@opindex fcompare-debug-second
This option is implicitly passed to the compiler for the second
compilation requested by @option{-fcompare-debug}, along with options to
-silence warnings, and omitting other options that would cause
-side-effect compiler outputs to files or to the standard output. Dump
+silence warnings, and omitting other options that would cause the compiler
+to produce output to files or to standard output as a side effect. Dump
files and preserved temporary files are renamed so as to contain the
@code{.gk} additional extension during the second compilation, to avoid
overwriting those generated by the first.
@item -mr10k-cache-barrier=@var{setting}
@opindex mr10k-cache-barrier
Specify whether GCC should insert cache barriers to avoid the
-side-effects of speculation on R10K processors.
+side effects of speculation on R10K processors.
In common with many processors, the R10K tries to predict the outcome
of a conditional branch and speculatively executes instructions from
@defun push_operand
This predicate allows a memory reference suitable for pushing a value
onto the stack. This will be a @code{MEM} which refers to
-@code{stack_pointer_rtx}, with a side-effect in its address expression
+@code{stack_pointer_rtx}, with a side effect in its address expression
(@pxref{Incdec}); which one is determined by the
@code{STACK_PUSH_CODE} macro (@pxref{Frame Layout}).
@end defun
@defun pop_operand
This predicate allows a memory reference suitable for popping a value
off the stack. Again, this will be a @code{MEM} referring to
-@code{stack_pointer_rtx}, with a side-effect in its address
+@code{stack_pointer_rtx}, with a side effect in its address
expression. However, this time @code{STACK_POP_CODE} is expected.
@end defun
have. Constraints can also require two operands to match.
Side-effects aren't allowed in operands of inline @code{asm}, unless
@samp{<} or @samp{>} constraints are used, because there is no guarantee
-that the side-effects will happen exactly once in an instruction that can update
+that the side effects will happen exactly once in an instruction that can update
the addressing register.
@ifset INTERNALS
A memory operand with autodecrement addressing (either predecrement or
postdecrement) is allowed. In inline @code{asm} this constraint is only
allowed if the operand is used exactly once in an instruction that can
-handle the side-effects. Not using an operand with @samp{<} in constraint
+handle the side effects. Not using an operand with @samp{<} in constraint
string in the inline @code{asm} pattern at all or using it in multiple
-instructions isn't valid, because the side-effects wouldn't be performed
+instructions isn't valid, because the side effects wouldn't be performed
or would be performed more than once. Furthermore, on some targets
the operand with @samp{<} in constraint string must be accompanied by
special instruction suffixes like @code{%U0} instruction suffix on PowerPC
representation. However, it differs from GENERIC in that the GIMPLE
grammar is more restrictive: expressions contain no more than 3
operands (except function calls), it has no control flow structures
-and expressions with side-effects are only allowed on the right hand
+and expressions with side effects are only allowed on the right hand
side of assignments. See the chapter describing GENERIC and GIMPLE
for more details.
projects / platform / upstream / gcc.git / commitdiff