used, for instance, during register allocation, as the pseudo
registers only need to be assigned to a unique hard register or to a
stack slot if they are live. The hard registers and stack slots may
-be freely reused for other values when a register is dead.
+be freely reused for other values when a register is dead.
Liveness information is available in the back end starting with
@code{pass_df_initialize} and ending with @code{pass_df_finish}. Three
to determine at any point @code{P} in the function if the register may be
used on some path from @code{P} to the end of the function. With
@code{UR}, it is possible to determine if there is a path from the
-beginning of the function to @code{P} that defines the variable.
+beginning of the function to @code{P} that defines the variable.
@code{LIVE} is the intersection of the @code{LR} and @code{UR} and a
variable is live at @code{P} if there is both an assignment that reaches
it from the beginning of the function and a use that can be reached on
The macros take a basic block number and return a bitmap that is indexed
by the register number. This information is only guaranteed to be up to
date after calls are made to @code{df_analyze}. See the file
-@code{df-core.c} for details on using the dataflow.
+@code{df-core.c} for details on using the dataflow.
@findex REG_DEAD, REG_UNUSED
Leonard Tower wrote parts of the parser, RTL generator, and RTL
definitions, and of the VAX machine description.
-@item
-Daniel Towner and Hariharan Sandanagobalane contributed and
+@item
+Daniel Towner and Hariharan Sandanagobalane contributed and
maintain the picoChip port.
@item
which use it. Otherwise, the precompiled headers will not be used.
@item __GFORTRAN__
-The GNU Fortran compiler defines this.
+The GNU Fortran compiler defines this.
@item __GNUC__
@itemx __GNUC_MINOR__
* Complex:: Data types for complex numbers.
* Floating Types:: Additional Floating Types.
* Half-Precision:: Half-Precision Floating Point.
-* Decimal Float:: Decimal Floating Types.
+* Decimal Float:: Decimal Floating Types.
* Hex Floats:: Hexadecimal floating-point constants.
* Fixed-Point:: Fixed-Point Types.
* Named Address Spaces::Named address spaces.
safe.
GCC implements taking the address of a nested function using a technique
-called @dfn{trampolines}. This technique was described in
+called @dfn{trampolines}. This technique was described in
@cite{Lexical Closures for C++} (Thomas M. Breuel, USENIX
C++ Conference Proceedings, October 17-21, 1988).
@}
return open (path, oflag, __builtin_va_arg_pack ());
@}
-
+
if (__builtin_va_arg_pack_len () < 1)
return __open_2 (path, oflag);
@cindex @code{__fp16} data type
On ARM targets, GCC supports half-precision (16-bit) floating point via
-the @code{__fp16} type. You must enable this type explicitly
+the @code{__fp16} type. You must enable this type explicitly
with the @option{-mfp16-format} command-line option in order to use it.
ARM supports two incompatible representations for half-precision
The @code{__fp16} type is a storage format only. For purposes
of arithmetic and other operations, @code{__fp16} values in C or C++
expressions are automatically promoted to @code{float}. In addition,
-you cannot declare a function with a return value or parameters
+you cannot declare a function with a return value or parameters
of type @code{__fp16}.
Note that conversions from @code{double} to @code{__fp16}
of rounding, this can sometimes produce a different result than a
direct conversion.
-ARM provides hardware support for conversions between
+ARM provides hardware support for conversions between
@code{__fp16} and @code{float} values
as an extension to VFP and NEON (Advanced SIMD). GCC generates
code using these hardware instructions if you compile with
-options to select an FPU that provides them;
+options to select an FPU that provides them;
for example, @option{-mfpu=neon-fp16 -mfloat-abi=softfp},
in addition to the @option{-mfp16-format} option to select
-a half-precision format.
+a half-precision format.
Language-level support for the @code{__fp16} data type is
independent of whether GCC generates code using hardware floating-point
@cindex @code{alloc_size} attribute
The @code{alloc_size} attribute is used to tell the compiler that the
function return value points to memory, where the size is given by
-one or two of the functions parameters. GCC uses this
+one or two of the functions parameters. GCC uses this
information to improve the correctness of @code{__builtin_object_size}.
The function parameter(s) denoting the allocated size are specified by
of the two function arguments specified. Argument numbering starts at
one.
-For instance,
+For instance,
@smallexample
void* my_calloc(size_t, size_t) __attribute__((alloc_size(1,2)))
attribute also implies ``default'' visibility. It is an error to
explicitly specify any other visibility.
-In previous versions of GCC, the @code{dllexport} attribute was ignored
+In previous versions of GCC, the @code{dllexport} attribute was ignored
for inlined functions, unless the @option{-fkeep-inline-functions} flag
had been used. The default behaviour now is to emit all dllexported
inline functions; however, this can cause object file-size bloat, in
are @code{printf_unlocked} and @code{fprintf_unlocked}.
@xref{C Dialect Options,,Options Controlling C Dialect}.
-For Objective-C dialects, @code{NSString} (or @code{__NSString__}) is
+For Objective-C dialects, @code{NSString} (or @code{__NSString__}) is
recognized in the same context. Declarations including these format attributes
will be parsed for correct syntax, however the result of checking of such format
-strings is not yet defined, and will not be carried out by this version of the
+strings is not yet defined, and will not be carried out by this version of the
compiler.
The target may also provide additional types of format checks.
synonyms, and cause the compiler to always call
the function by first loading its address into a register, and then using
the contents of that register. The @code{near} attribute has the opposite
-effect; it specifies that non-PIC calls should be made using the more
+effect; it specifies that non-PIC calls should be made using the more
efficient @code{jal} instruction.
@item malloc
On MIPS targets, you can use the @code{mips16} and @code{nomips16}
function attributes to locally select or turn off MIPS16 code generation.
-A function with the @code{mips16} attribute is emitted as MIPS16 code,
-while MIPS16 code generation is disabled for functions with the
-@code{nomips16} attribute. These attributes override the
+A function with the @code{mips16} attribute is emitted as MIPS16 code,
+while MIPS16 code generation is disabled for functions with the
+@code{nomips16} attribute. These attributes override the
@option{-mips16} and @option{-mno-mips16} options on the command line
-(@pxref{MIPS Options}).
+(@pxref{MIPS Options}).
When compiling files containing mixed MIPS16 and non-MIPS16 code, the
preprocessor symbol @code{__mips16} reflects the setting on the command line,
@cindex function without a prologue/epilogue code
Use this attribute on the ARM, AVR, MCORE, RX and SPU ports to indicate that
the specified function does not need prologue/epilogue sequences generated by
-the compiler. It is up to the programmer to provide these sequences. The
-only statements that can be safely included in naked functions are
+the compiler. It is up to the programmer to provide these sequences. The
+only statements that can be safely included in naked functions are
@code{asm} statements that do not have operands. All other statements,
-including declarations of local variables, @code{if} statements, and so
-forth, should be avoided. Naked functions should be used to implement the
+including declarations of local variables, @code{if} statements, and so
+forth, should be avoided. Naked functions should be used to implement the
body of an assembly function, while allowing the compiler to construct
the requisite function declaration for the assembler.
@item save_volatiles
@cindex save volatile registers on the MicroBlaze
Use this attribute on the MicroBlaze to indicate that the function is
-an interrupt handler. All volatile registers (in addition to non-volatile
-registers) will be saved in the function prologue. If the function is a leaf
-function, only volatiles used by the function are saved. A normal function
-return is generated instead of a return from interrupt.
+an interrupt handler. All volatile registers (in addition to non-volatile
+registers) will be saved in the function prologue. If the function is a leaf
+function, only volatiles used by the function are saved. A normal function
+return is generated instead of a return from interrupt.
@item section ("@var{section-name}")
@cindex @code{section} function attribute
in an @code{__attribute__} will still only provide you with 8 byte
alignment. See your linker documentation for further information.
-The @code{aligned} attribute can also be used for functions
+The @code{aligned} attribute can also be used for functions
(@pxref{Function Attributes}.)
@item cleanup (@var{cleanup_function})
Three attributes currently are defined for PowerPC configurations:
@code{altivec}, @code{ms_struct} and @code{gcc_struct}.
-For full documentation of the @code{ms_struct} and @code{gcc_struct}
+For full documentation of the @code{ms_struct} and @code{gcc_struct}
attributes please see the documentation in @ref{i386 Type Attributes}.
The @code{altivec} attribute allows one to declare AltiVec vector data
In this (inefficient) example, the @code{frob} instruction sets the
carry bit to indicate an error. The @code{jc} instruction detects
-this and branches to the @code{error} label. Finally, the output
+this and branches to the @code{error} label. Finally, the output
of the @code{frob} instruction (@code{%r5}) is stored into the memory
for variable @code{y}, which is later read by the @code{return} statement.
The normal code path consists of a single @code{nop} instruction.
However, we record the address of this @code{nop} together with the
address of a label that calls the @code{trace} function. This allows
-the @code{nop} instruction to be patched at runtime to be an
+the @code{nop} instruction to be patched at runtime to be an
unconditional branch to the stored label. It is assumed that an
optimizing compiler will move the labeled block out of line, to
optimize the fall through path from the @code{asm}.
@node Darwin Format Checks
@subsection Darwin Format Checks
-Darwin targets support the @code{CFString} (or @code{__CFString__}) in the format
+Darwin targets support the @code{CFString} (or @code{__CFString__}) in the format
attribute context. Declarations made with such attribution will be parsed for correct syntax
and format argument types. However, parsing of the format string itself is currently undefined
-and will not be carried out by this version of the compiler.
+and will not be carried out by this version of the compiler.
Additionally, @code{CFStringRefs} (defined by the @code{CoreFoundation} headers) may
also be used as format arguments. Note that the relevant headers are only likely to be
For compatibility with the Solaris and Tru64 UNIX system headers, GCC
supports two @code{#pragma} directives which change the name used in
-assembly for a given declaration. @code{#pragma extern_prefix} is only
-available on platforms whose system headers need it. To get this effect
+assembly for a given declaration. @code{#pragma extern_prefix} is only
+available on platforms whose system headers need it. To get this effect
on all platforms supported by GCC, use the asm labels extension (@pxref{Asm
Labels}).
#undef X
#define X -1
#pragma pop_macro("X")
-int x [X];
+int x [X];
@end smallexample
In this example, the definition of X as 1 is saved by @code{#pragma
false. Otherwise if @code{__has_trivial_assign (type)} is true then the trait
is true, else if @code{type} is a cv class or union type with copy assignment
operators that are known not to throw an exception then the trait is true,
-else it is false. Requires: @code{type} shall be a complete type,
+else it is false. Requires: @code{type} shall be a complete type,
(possibly cv-qualified) @code{void}, or an array of unknown bound.
@item __has_nothrow_copy (type)
If @code{__has_trivial_constructor (type)} is true then the trait is
true, else if @code{type} is a cv class or union type (or array
thereof) with a default constructor that is known not to throw an
-exception then the trait is true, else it is false. Requires:
-@code{type} shall be a complete type, (possibly cv-qualified)
+exception then the trait is true, else it is false. Requires:
+@code{type} shall be a complete type, (possibly cv-qualified)
@code{void}, or an array of unknown bound.
@item __has_trivial_assign (type)
false. Otherwise if @code{__is_pod (type)} is true then the trait is
true, else if @code{type} is a cv class or union type with a trivial
copy assignment ([class.copy]) then the trait is true, else it is
-false. Requires: @code{type} shall be a complete type, (possibly
+false. Requires: @code{type} shall be a complete type, (possibly
cv-qualified) @code{void}, or an array of unknown bound.
@item __has_trivial_copy (type)
-If @code{__is_pod (type)} is true or @code{type} is a reference type
+If @code{__is_pod (type)} is true or @code{type} is a reference type
then the trait is true, else if @code{type} is a cv class or union type
with a trivial copy constructor ([class.copy]) then the trait
is true, else it is false. Requires: @code{type} shall be a complete
has no non-static data members, or all non-static data members, if
any, are bit-fields of length 0, and @code{type} has no virtual
members, and @code{type} has no virtual base classes, and @code{type}
-has no base classes @code{base_type} for which
+has no base classes @code{base_type} for which
@code{__is_empty (base_type)} is false. Requires: @code{type} shall
be a complete type, (possibly cv-qualified) @code{void}, or an array
of unknown bound.
@node Cross-profiling
@section Data file relocation to support cross-profiling
-Running the program will cause profile output to be generated. For each
-source file compiled with @option{-fprofile-arcs}, an accompanying @file{.gcda}
-file will be placed in the object file directory. That implicitly requires
-running the program on the same system as it was built or having the same
+Running the program will cause profile output to be generated. For each
+source file compiled with @option{-fprofile-arcs}, an accompanying @file{.gcda}
+file will be placed in the object file directory. That implicitly requires
+running the program on the same system as it was built or having the same
absolute directory structure on the target system. The program will try
to create the needed directory structure, if it is not already present.
To support cross-profiling, a program compiled with @option{-fprofile-arcs}
-can relocate the data files based on two environment variables:
+can relocate the data files based on two environment variables:
@itemize @bullet
@item
-GCOV_PREFIX contains the prefix to add to the absolute paths
+GCOV_PREFIX contains the prefix to add to the absolute paths
in the object file. Prefix can be absolute, or relative. The
default is no prefix.
@menu
* Working with declarations:: Macros and functions that work on
declarations.
-* Internal structure:: How declaration nodes are represented.
+* Internal structure:: How declaration nodes are represented.
@end menu
@node Working with declarations
@item FIELD_DECL
These nodes represent non-static data members. The @code{DECL_SIZE} and
-@code{DECL_ALIGN} behave as for @code{VAR_DECL} nodes.
-The position of the field within the parent record is specified by a
+@code{DECL_ALIGN} behave as for @code{VAR_DECL} nodes.
+The position of the field within the parent record is specified by a
combination of three attributes. @code{DECL_FIELD_OFFSET} is the position,
counting in bytes, of the @code{DECL_OFFSET_ALIGN}-bit sized word containing
-the bit of the field closest to the beginning of the structure.
+the bit of the field closest to the beginning of the structure.
@code{DECL_FIELD_BIT_OFFSET} is the bit offset of the first bit of the field
within this word; this may be nonzero even for fields that are not bit-fields,
since @code{DECL_OFFSET_ALIGN} may be greater than the natural alignment
@item struct tree_parm_decl
This structure inherits from @code{struct tree_decl_with_rtl}. It is
-used to represent @code{PARM_DECL}.
+used to represent @code{PARM_DECL}.
@item struct tree_decl_with_vis
This structure inherits from @code{struct tree_decl_with_rtl}. It
@item struct tree_var_decl
This structure inherits from @code{struct tree_decl_with_vis}. It is
-used to represent @code{VAR_DECL}.
+used to represent @code{VAR_DECL}.
@item struct tree_function_decl
This structure inherits from @code{struct tree_decl_with_vis}. It is
-used to represent @code{FUNCTION_DECL}.
+used to represent @code{FUNCTION_DECL}.
@end table
@node Adding new DECL node types
@code{POINTER_TYPE}.
The number of arguments to the call is returned by @code{call_expr_nargs},
-while the arguments themselves can be accessed with the @code{CALL_EXPR_ARG}
-macro. The arguments are zero-indexed and numbered left-to-right.
+while the arguments themselves can be accessed with the @code{CALL_EXPR_ARG}
+macro. The arguments are zero-indexed and numbered left-to-right.
You can iterate over the arguments using @code{FOR_EACH_CALL_EXPR_ARG}, as in:
@smallexample
@tindex VEC_PACK_TRUNC_EXPR
@tindex VEC_PACK_SAT_EXPR
@tindex VEC_PACK_FIX_TRUNC_EXPR
-@tindex VEC_EXTRACT_EVEN_EXPR
+@tindex VEC_EXTRACT_EVEN_EXPR
@tindex VEC_EXTRACT_ODD_EXPR
@tindex VEC_INTERLEAVE_HIGH_EXPR
@tindex VEC_INTERLEAVE_LOW_EXPR
@table @code
@item VEC_LSHIFT_EXPR
@itemx VEC_RSHIFT_EXPR
-These nodes represent whole vector left and right shifts, respectively.
-The first operand is the vector to shift; it will always be of vector type.
+These nodes represent whole vector left and right shifts, respectively.
+The first operand is the vector to shift; it will always be of vector type.
The second operand is an expression for the number of bits by which to
shift. Note that the result is undefined if the second operand is larger
than or equal to the first operand's type size.
@item VEC_WIDEN_MULT_HI_EXPR
@itemx VEC_WIDEN_MULT_LO_EXPR
These nodes represent widening vector multiplication of the high and low
-parts of the two input vectors, respectively. Their operands are vectors
-that contain the same number of elements (@code{N}) of the same integral type.
-The result is a vector that contains half as many elements, of an integral type
+parts of the two input vectors, respectively. Their operands are vectors
+that contain the same number of elements (@code{N}) of the same integral type.
+The result is a vector that contains half as many elements, of an integral type
whose size is twice as wide. In the case of @code{VEC_WIDEN_MULT_HI_EXPR} the
high @code{N/2} elements of the two vector are multiplied to produce the
vector of @code{N/2} products. In the case of @code{VEC_WIDEN_MULT_LO_EXPR} the
@item VEC_UNPACK_HI_EXPR
@itemx VEC_UNPACK_LO_EXPR
These nodes represent unpacking of the high and low parts of the input vector,
-respectively. The single operand is a vector that contains @code{N} elements
+respectively. The single operand is a vector that contains @code{N} elements
of the same integral or floating point type. The result is a vector
that contains half as many elements, of an integral or floating point type
whose size is twice as wide. In the case of @code{VEC_UNPACK_HI_EXPR} the
@item VEC_EXTRACT_EVEN_EXPR
@itemx VEC_EXTRACT_ODD_EXPR
-These nodes represent extracting of the even/odd elements of the two input
-vectors, respectively. Their operands and result are vectors that contain the
+These nodes represent extracting of the even/odd elements of the two input
+vectors, respectively. Their operands and result are vectors that contain the
same number of elements of the same type.
@item VEC_INTERLEAVE_HIGH_EXPR
@itemx VEC_INTERLEAVE_LOW_EXPR
These nodes represent merging and interleaving of the high/low elements of the
-two input vectors, respectively. The operands and the result are vectors that
+two input vectors, respectively. The operands and the result are vectors that
contain the same number of elements (@code{N}) of the same type.
-In the case of @code{VEC_INTERLEAVE_HIGH_EXPR}, the high @code{N/2} elements of
+In the case of @code{VEC_INTERLEAVE_HIGH_EXPR}, the high @code{N/2} elements of
the first input vector are interleaved with the high @code{N/2} elements of the
second input vector. In the case of @code{VEC_INTERLEAVE_LOW_EXPR}, the low
-@code{N/2} elements of the first input vector are interleaved with the low
+@code{N/2} elements of the first input vector are interleaved with the low
@code{N/2} elements of the second input vector.
@end table
@item POINTER_TYPE
Used to represent pointer types, and pointer to data member types. If
-@code{TREE_TYPE}
+@code{TREE_TYPE}
is a pointer to data member type, then @code{TYPE_PTRMEM_P} will hold.
For a pointer to data member type of the form @samp{T X::*},
@code{TYPE_PTRMEM_CLASS_TYPE} will be the type @code{X}, while
@itemize @bullet
@item @code{code}
-Main identifier for a GIMPLE instruction.
+Main identifier for a GIMPLE instruction.
@item @code{subcode}
Used to distinguish different variants of the same basic
@item @code{bb}
Basic block holding the instruction.
-
+
@item @code{block}
Lexical block holding this statement. Also used for debug
information generation.
@};
@end smallexample
-
+
@node GIMPLE instruction set
@section GIMPLE instruction set
@cindex GIMPLE instruction set
@deftypefn {GIMPLE function} bool is_gimple_assign (gimple g)
Return true if the code of g is @code{GIMPLE_ASSIGN}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool is_gimple_call (gimple g)
Return true if the code of g is @code{GIMPLE_CALL}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool is_gimple_debug (gimple g)
Return true if the code of g is @code{GIMPLE_DEBUG}.
@end deftypefn
This section documents all the functions available to handle each
of the GIMPLE instructions.
-@subsection Common accessors
+@subsection Common accessors
The following are common accessors for gimple statements.
@deftypefn {GIMPLE function} {enum gimple_code} gimple_code (gimple g)
Return the code for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} basic_block gimple_bb (gimple g)
Return the basic block to which statement @code{G} belongs to.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_block (gimple g)
Return the lexical scope block holding statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_expr_type (gimple stmt)
Return the type of the main expression computed by @code{STMT}. Return
@code{void_type_node} if @code{STMT} computes nothing. This will only return
@deftypefn {GIMPLE function} void gimple_set_block (gimple g, tree block)
Set the lexical scope block of @code{G} to @code{BLOCK}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} location_t gimple_locus (gimple g)
Return locus information for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_locus (gimple g, location_t locus)
Set locus information for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_locus_empty_p (gimple g)
Return true if @code{G} does not have locus information.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_no_warning_p (gimple stmt)
Return true if no warnings should be emitted for statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_visited (gimple stmt, bool visited_p)
Set the visited status on statement @code{STMT} to @code{VISITED_P}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_visited_p (gimple stmt)
Return the visited status on statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_plf (gimple stmt, enum plf_mask plf, bool val_p)
Set pass local flag @code{PLF} on statement @code{STMT} to @code{VAL_P}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {unsigned int} gimple_plf (gimple stmt, enum plf_mask plf)
Return the value of pass local flag @code{PLF} on statement @code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_ops (gimple g)
Return true if statement @code{G} has register or memory operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_mem_ops (gimple g)
Return true if statement @code{G} has memory operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} unsigned gimple_num_ops (gimple g)
Return the number of operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_ops (gimple g)
Return the array of operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_op (gimple g, unsigned i)
Return operand @code{I} for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_op_ptr (gimple g, unsigned i)
Return a pointer to operand @code{I} for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_op (gimple g, unsigned i, tree op)
Set operand @code{I} of statement @code{G} to @code{OP}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_addresses_taken (gimple stmt)
Return the set of symbols that have had their address taken by
@code{STMT}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {struct def_optype_d *} gimple_def_ops (gimple g)
Return the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_def_ops (gimple g, struct def_optype_d *def)
Set @code{DEF} to be the set of @code{DEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {struct use_optype_d *} gimple_use_ops (gimple g)
Return the set of @code{USE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_use_ops (gimple g, struct use_optype_d *use)
Set @code{USE} to be the set of @code{USE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vuse_ops (gimple g)
Return the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_vuse_ops (gimple g, struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VUSE} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {struct voptype_d *} gimple_vdef_ops (gimple g)
Return the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_vdef_ops (gimple g, struct voptype_d *ops)
Set @code{OPS} to be the set of @code{VDEF} operands for statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_loaded_syms (gimple g)
Return the set of symbols loaded by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bitmap gimple_stored_syms (gimple g)
Return the set of symbols stored by statement @code{G}. Each element of
the set is the @code{DECL_UID} of the corresponding symbol.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_modified_p (gimple g)
Return true if statement @code{G} has operands and the modified field
has been set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_has_volatile_ops (gimple stmt)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_set_has_volatile_ops (gimple stmt, bool volatilep)
Return true if statement @code{STMT} contains volatile operands.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void update_stmt (gimple s)
Mark statement @code{S} as modified, and update it.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void update_stmt_if_modified (gimple s)
Update statement @code{S} if it has been marked modified.
@end deftypefn
-
+
@deftypefn {GIMPLE function} gimple gimple_copy (gimple stmt)
Return a deep copy of statement @code{STMT}.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_asm_ninputs (gimple g)
-Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
+Return the number of input operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_asm_noutputs (gimple g)
-Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
+Return the number of output operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_asm_nclobbers (gimple g)
-Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
+Return the number of clobber operands for @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_asm_input_op (gimple g, unsigned index)
-Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+Return input operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_asm_set_input_op (gimple g, unsigned index, tree in_op)
-Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
+Set @code{IN_OP} to be input operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_asm_output_op (gimple g, unsigned index)
-Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+Return output operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_asm_set_output_op (gimple g, @
unsigned index, tree out_op)
-Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
+Set @code{OUT_OP} to be output operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_asm_clobber_op (gimple g, unsigned index)
-Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
+Return clobber operand @code{INDEX} of @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_asm_set_clobber_op (gimple g, unsigned index, tree clobber_op)
-Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
+Set @code{CLOBBER_OP} to be clobber operand @code{INDEX} in @code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {const char *} gimple_asm_string (gimple g)
Return the string representing the assembly instruction in
-@code{GIMPLE_ASM} @code{G}.
+@code{GIMPLE_ASM} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_asm_volatile_p (gimple g)
-Return true if @code{G} is an asm statement marked volatile.
+Return true if @code{G} is an asm statement marked volatile.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_asm_set_volatile (gimple g)
-Mark asm statement @code{G} as volatile.
+Mark asm statement @code{G} as volatile.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_asm_clear_volatile (gimple g)
-Remove volatile marker from asm statement @code{G}.
+Remove volatile marker from asm statement @code{G}.
@end deftypefn
@node @code{GIMPLE_ASSIGN}
Return the code of the expression computed on the @code{RHS} of
assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {enum gimple_rhs_class} gimple_assign_rhs_class (gimple g)
Return the gimple rhs class of the code for the expression
@deftypefn {GIMPLE function} tree gimple_assign_lhs (gimple g)
Return the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_assign_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_assign_rhs1 (gimple g)
Return the first operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs1_ptr (gimple g)
Return the address of the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_assign_rhs2 (gimple g)
Return the second operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs2_ptr (gimple g)
Return the address of the second operand on the @code{RHS} of assignment
statement @code{G}.
@deftypefn {GIMPLE function} tree gimple_assign_rhs3 (gimple g)
Return the third operand on the @code{RHS} of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_assign_rhs3_ptr (gimple g)
Return the address of the third operand on the @code{RHS} of assignment
statement @code{G}.
@deftypefn {GIMPLE function} void gimple_assign_set_lhs (gimple g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of assignment statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_assign_set_rhs1 (gimple g, tree rhs)
Set @code{RHS} to be the first operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_assign_set_rhs2 (gimple g, tree rhs)
Set @code{RHS} to be the second operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_assign_set_rhs3 (gimple g, tree rhs)
Set @code{RHS} to be the third operand on the @code{RHS} of assignment
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_assign_cast_p (gimple s)
Return true if @code{S} is a type-cast assignment.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_bind_vars (gimple g)
-Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
+Return the variables declared in the @code{GIMPLE_BIND} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_set_vars (gimple g, tree vars)
Set @code{VARS} to be the set of variables declared in the @code{GIMPLE_BIND}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_append_vars (gimple g, tree vars)
@deftypefn {GIMPLE function} gimple_seq gimple_bind_body (gimple g)
Return the GIMPLE sequence contained in the @code{GIMPLE_BIND} statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_set_body (gimple g, gimple_seq seq)
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_add_stmt (gimple gs, gimple stmt)
-Append a statement to the end of a @code{GIMPLE_BIND}'s body.
+Append a statement to the end of a @code{GIMPLE_BIND}'s body.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_add_seq (gimple gs, gimple_seq seq)
@deftypefn {GIMPLE function} tree gimple_bind_block (gimple g)
Return the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND} statement
-@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
+@code{G}. This is analogous to the @code{BIND_EXPR_BLOCK} field in trees.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_bind_set_block (gimple g, tree block)
Set @code{BLOCK} to be the @code{TREE_BLOCK} node associated with @code{GIMPLE_BIND}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_call_lhs (gimple g)
Return the @code{LHS} of call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_call_lhs_ptr (gimple g)
Return a pointer to the @code{LHS} of call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_call_set_lhs (gimple g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_fn (gimple g)
Return the tree node representing the function called by call
statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_call_set_fn (gimple g, tree fn)
Set @code{FN} to be the function called by call statement @code{G}. This has
to be a gimple value specifying the address of the called
function.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_fndecl (gimple g)
If a given @code{GIMPLE_CALL}'s callee is a @code{FUNCTION_DECL}, return it.
Otherwise return @code{NULL}. This function is analogous to
@code{get_callee_fndecl} in @code{GENERIC}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_set_fndecl (gimple g, tree fndecl)
Set the called function to @code{FNDECL}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_call_return_type (gimple g)
Return the type returned by call statement @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_call_chain (gimple g)
-Return the static chain for call statement @code{G}.
+Return the static chain for call statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_call_set_chain (gimple g, tree chain)
-Set @code{CHAIN} to be the static chain for call statement @code{G}.
+Set @code{CHAIN} to be the static chain for call statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_call_num_args (gimple g)
-Return the number of arguments used by call statement @code{G}.
+Return the number of arguments used by call statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_call_arg (gimple g, unsigned index)
Return the argument at position @code{INDEX} for call statement @code{G}. The
first argument is 0.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_call_arg_ptr (gimple g, unsigned index)
Return a pointer to the argument at position @code{INDEX} for call
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_call_set_arg (gimple g, unsigned index, tree arg)
Set @code{ARG} to be the argument at position @code{INDEX} for call statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_call_set_tail (gimple s)
Mark call statement @code{S} as being a tail call (i.e., a call just
before the exit of a function). These calls are candidate for
-tail call optimization.
+tail call optimization.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_call_tail_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
+Return true if @code{GIMPLE_CALL} @code{S} is marked as a tail call.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_call_mark_uninlinable (gimple s)
-Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
+Mark @code{GIMPLE_CALL} @code{S} as being uninlinable.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_call_cannot_inline_p (gimple s)
-Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
+Return true if @code{GIMPLE_CALL} @code{S} cannot be inlined.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_call_noreturn_p (gimple s)
-Return true if @code{S} is a noreturn call.
+Return true if @code{S} is a noreturn call.
@end deftypefn
@deftypefn {GIMPLE function} gimple gimple_call_copy_skip_args (gimple stmt, bitmap args_to_skip)
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_catch_types (gimple g)
-Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
+Return the types handled by @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_catch_types_ptr (gimple g)
Return a pointer to the types handled by @code{GIMPLE_CATCH} statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_catch_handler (gimple g)
Return the GIMPLE sequence representing the body of the handler
-of @code{GIMPLE_CATCH} statement @code{G}.
+of @code{GIMPLE_CATCH} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_catch_set_types (gimple g, tree t)
-Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
+Set @code{T} to be the set of types handled by @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_catch_set_handler (gimple g, gimple_seq handler)
-Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
+Set @code{HANDLER} to be the body of @code{GIMPLE_CATCH} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {enum tree_code} gimple_cond_code (gimple g)
Return the code of the predicate computed by conditional
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_set_code (gimple g, enum tree_code code)
Set @code{CODE} to be the predicate code for the conditional statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_lhs (gimple g)
Return the @code{LHS} of the predicate computed by conditional statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_set_lhs (gimple g, tree lhs)
Set @code{LHS} to be the @code{LHS} operand of the predicate computed by
-conditional statement @code{G}.
+conditional statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_rhs (gimple g)
Return the @code{RHS} operand of the predicate computed by conditional
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_set_rhs (gimple g, tree rhs)
Set @code{RHS} to be the @code{RHS} operand of the predicate computed by
-conditional statement @code{G}.
+conditional statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_true_label (gimple g)
Return the label used by conditional statement @code{G} when its
-predicate evaluates to true.
+predicate evaluates to true.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_set_true_label (gimple g, tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
-its predicate evaluates to true.
+its predicate evaluates to true.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_set_false_label (gimple g, tree label)
Set @code{LABEL} to be the label used by conditional statement @code{G} when
-its predicate evaluates to false.
+its predicate evaluates to false.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_cond_false_label (gimple g)
Return the label used by conditional statement @code{G} when its
-predicate evaluates to false.
+predicate evaluates to false.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_make_false (gimple g)
-Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 0)'.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_cond_make_true (gimple g)
-Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
+Set the conditional @code{COND_STMT} to be of the form 'if (1 == 1)'.
@end deftypefn
@node @code{GIMPLE_DEBUG}
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_eh_filter_types (gimple g)
-Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
+Return the types handled by @code{GIMPLE_EH_FILTER} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_eh_filter_types_ptr (gimple g)
Return a pointer to the types handled by @code{GIMPLE_EH_FILTER}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_eh_filter_failure (gimple g)
Return the sequence of statement to execute when @code{GIMPLE_EH_FILTER}
-statement fails.
+statement fails.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_eh_filter_set_types (gimple g, tree types)
-Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
+Set @code{TYPES} to be the set of types handled by @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_eh_filter_set_failure (gimple g, gimple_seq failure)
Set @code{FAILURE} to be the sequence of statements to execute on
-failure for @code{GIMPLE_EH_FILTER} @code{G}.
+failure for @code{GIMPLE_EH_FILTER} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_eh_filter_must_not_throw (gimple g)
-Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
+Return the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_eh_filter_set_must_not_throw (gimple g, bool mntp)
-Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
+Set the @code{EH_FILTER_MUST_NOT_THROW} flag.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_label_label (gimple g)
-Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
+Return the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_label_set_label (gimple g, tree label)
Set @code{LABEL} to be the @code{LABEL_DECL} node used by @code{GIMPLE_LABEL}
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_goto_dest (gimple g)
-Return the destination of the unconditional jump @code{G}.
+Return the destination of the unconditional jump @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_goto_set_dest (gimple g, tree dest)
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_nop_p (gimple g)
-Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
+Returns @code{TRUE} if statement @code{G} is a @code{GIMPLE_NOP}.
@end deftypefn
@node @code{GIMPLE_OMP_ATOMIC_LOAD}
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_lhs (gimple g, tree lhs)
-Set the @code{LHS} of an atomic load.
+Set the @code{LHS} of an atomic load.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_lhs (gimple g)
-Get the @code{LHS} of an atomic load.
+Get the @code{LHS} of an atomic load.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_atomic_load_set_rhs (gimple g, tree rhs)
-Set the @code{RHS} of an atomic set.
+Set the @code{RHS} of an atomic set.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_atomic_load_rhs (gimple g)
-Get the @code{RHS} of an atomic set.
+Get the @code{RHS} of an atomic set.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_atomic_store_set_val (gimple g, tree val)
-Set the value being stored in an atomic store.
+Set the value being stored in an atomic store.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_atomic_store_val (gimple g)
-Return the value being stored in an atomic store.
+Return the value being stored in an atomic store.
@end deftypefn
@node @code{GIMPLE_OMP_CONTINUE}
Return the definition of the control variable on a
@code{GIMPLE_OMP_CONTINUE} in @code{S}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_def_ptr (gimple s)
Same as above, but return the pointer.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_def (gimple s)
Set the control variable definition for a @code{GIMPLE_OMP_CONTINUE}
statement in @code{S}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use (gimple s)
Return the use of the control variable on a @code{GIMPLE_OMP_CONTINUE}
in @code{S}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_continue_control_use_ptr (gimple s)
Same as above, but return the pointer.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_continue_set_control_use (gimple s)
Set the control variable use for a @code{GIMPLE_OMP_CONTINUE} statement
in @code{S}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_critical_name (gimple g)
-Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
+Return the name associated with @code{OMP_CRITICAL} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_critical_name_ptr (gimple g)
Return a pointer to the name associated with @code{OMP} critical
-statement @code{G}.
+statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_critical_set_name (gimple g, tree name)
-Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
+Set @code{NAME} to be the name associated with @code{OMP} critical statement @code{G}.
@end deftypefn
@node @code{GIMPLE_OMP_FOR}
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_clauses (gimple g)
-Return the clauses associated with @code{OMP_FOR} @code{G}.
+Return the clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_for_clauses_ptr (gimple g)
-Return a pointer to the @code{OMP_FOR} @code{G}.
+Return a pointer to the @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
+Set @code{CLAUSES} to be the list of clauses associated with @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_index (gimple g)
-Return the index variable for @code{OMP_FOR} @code{G}.
+Return the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_for_index_ptr (gimple g)
-Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
+Return a pointer to the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
+Set @code{INDEX} to be the index variable for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_initial (gimple g)
-Return the initial value for @code{OMP_FOR} @code{G}.
+Return the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_for_initial_ptr (gimple g)
-Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
+Return a pointer to the initial value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_initial (gimple g, tree initial)
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_final (gimple g)
-Return the final value for @code{OMP_FOR} @code{G}.
+Return the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_for_final_ptr (gimple g)
-turn a pointer to the final value for @code{OMP_FOR} @code{G}.
+turn a pointer to the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_final (gimple g, tree final)
-Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
+Set @code{FINAL} to be the final value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_for_incr (gimple g)
-Return the increment value for @code{OMP_FOR} @code{G}.
+Return the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_for_incr_ptr (gimple g)
-Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
+Return a pointer to the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_incr (gimple g, tree incr)
-Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
+Set @code{INCR} to be the increment value for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_omp_for_pre_body (gimple g)
Return the sequence of statements to execute before the @code{OMP_FOR}
-statement @code{G} starts.
+statement @code{G} starts.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_for_set_pre_body (gimple g, gimple_seq pre_body)
Set @code{PRE_BODY} to be the sequence of statements to execute before
the @code{OMP_FOR} statement @code{G} starts.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_for_set_cond (gimple g, enum tree_code cond)
-Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
+Set @code{COND} to be the condition code for @code{OMP_FOR} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {enum tree_code} gimple_omp_for_cond (gimple g)
-Return the condition code associated with @code{OMP_FOR} @code{G}.
+Return the condition code associated with @code{OMP_FOR} @code{G}.
@end deftypefn
Return true if @code{OMP} parallel statement @code{G} has the
@code{GF_OMP_PARALLEL_COMBINED} flag set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_combined_p (gimple g)
Set the @code{GF_OMP_PARALLEL_COMBINED} field in @code{OMP} parallel statement
@code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} gimple_seq gimple_omp_body (gimple g)
-Return the body for the @code{OMP} statement @code{G}.
+Return the body for the @code{OMP} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_set_body (gimple g, gimple_seq body)
-Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
+Set @code{BODY} to be the body for the @code{OMP} statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_parallel_clauses (gimple g)
-Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
+Return the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
+Return a pointer to the clauses associated with @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_clauses (gimple g, tree clauses)
Set @code{CLAUSES} to be the list of clauses associated with
-@code{OMP_PARALLEL} @code{G}.
+@code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_parallel_child_fn (gimple g)
Return the child function used to hold the body of @code{OMP_PARALLEL}
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_child_fn_ptr (gimple g)
Return a pointer to the child function used to hold the body of
-@code{OMP_PARALLEL} @code{G}.
+@code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_child_fn (gimple g, tree child_fn)
-Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
+Set @code{CHILD_FN} to be the child function for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_parallel_data_arg (gimple g)
Return the artificial argument used to send variables and values
-from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
+from the parent to the children threads in @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_parallel_data_arg_ptr (gimple g)
-Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
+Return a pointer to the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_parallel_set_data_arg (gimple g, tree data_arg)
-Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
+Set @code{DATA_ARG} to be the data argument for @code{OMP_PARALLEL} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} bool is_gimple_omp (gimple stmt)
Returns true when the gimple statement @code{STMT} is any of the OpenMP
-types.
+types.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_return_set_nowait (gimple s)
Set the nowait flag on @code{GIMPLE_OMP_RETURN} statement @code{S}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} bool gimple_omp_return_nowait_p (gimple g)
Return true if @code{OMP} return statement @code{G} has the
Return true if @code{OMP} section statement @code{G} has the
@code{GF_OMP_SECTION_LAST} flag set.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_section_set_last (gimple g)
Set the @code{GF_OMP_SECTION_LAST} flag on @code{G}.
@end deftypefn
Return the control variable associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_control_ptr (gimple g)
Return a pointer to the clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} void gimple_omp_sections_set_control (gimple g, tree control)
Set @code{CONTROL} to be the set of clauses associated with the
@code{GIMPLE_OMP_SECTIONS} in @code{G}.
@end deftypefn
-
+
@deftypefn {GIMPLE function} tree gimple_omp_sections_clauses (gimple g)
-Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
+Return the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_sections_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
+Return a pointer to the clauses associated with @code{OMP_SECTIONS} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_sections_set_clauses (gimple g, tree clauses)
Set @code{CLAUSES} to be the set of clauses associated with @code{OMP_SECTIONS}
-@code{G}.
+@code{G}.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_omp_single_clauses (gimple g)
-Return the clauses associated with @code{OMP_SINGLE} @code{G}.
+Return the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_omp_single_clauses_ptr (gimple g)
-Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
+Return a pointer to the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_omp_single_set_clauses (gimple g, tree clauses)
-Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
+Set @code{CLAUSES} to be the clauses associated with @code{OMP_SINGLE} @code{G}.
@end deftypefn
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_phi_capacity (gimple g)
-Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
+Return the maximum number of arguments supported by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} unsigned gimple_phi_num_args (gimple g)
Return the number of arguments in @code{GIMPLE_PHI} @code{G}. This must always
be exactly the number of incoming edges for the basic block
-holding @code{G}.
+holding @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_phi_result (gimple g)
-Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+Return the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {tree *} gimple_phi_result_ptr (gimple g)
-Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+Return a pointer to the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_phi_set_result (gimple g, tree result)
-Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
+Set @code{RESULT} to be the @code{SSA} name created by @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} {struct phi_arg_d *} gimple_phi_arg (gimple g, index)
Return the @code{PHI} argument corresponding to incoming edge @code{INDEX} for
-@code{GIMPLE_PHI} @code{G}.
+@code{GIMPLE_PHI} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_phi_set_arg (gimple g, index, struct phi_arg_d * phiarg)
Set @code{PHIARG} to be the argument corresponding to incoming edge
-@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
+@code{INDEX} for @code{GIMPLE_PHI} @code{G}.
@end deftypefn
@node @code{GIMPLE_RESX}
@end deftypefn
@deftypefn {GIMPLE function} int gimple_resx_region (gimple g)
-Return the region number for @code{GIMPLE_RESX} @code{G}.
+Return the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_resx_set_region (gimple g, int region)
-Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
+Set @code{REGION} to be the region number for @code{GIMPLE_RESX} @code{G}.
@end deftypefn
@node @code{GIMPLE_RETURN}
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_return_retval (gimple g)
-Return the return value for @code{GIMPLE_RETURN} @code{G}.
+Return the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_return_set_retval (gimple g, tree retval)
-Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
+Set @code{RETVAL} to be the return value for @code{GIMPLE_RETURN} @code{G}.
@end deftypefn
@node @code{GIMPLE_SWITCH}
@deftypefn {GIMPLE function} unsigned gimple_switch_num_labels (gimple g)
Return the number of labels associated with the switch statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_switch_set_num_labels (gimple g, @
unsigned nlabels)
Set @code{NLABELS} to be the number of labels for the switch statement
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_switch_index (gimple g)
-Return the index variable used by the switch statement @code{G}.
+Return the index variable used by the switch statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_switch_set_index (gimple g, tree index)
-Set @code{INDEX} to be the index variable for switch statement @code{G}.
+Set @code{INDEX} to be the index variable for switch statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_switch_label (gimple g, unsigned index)
Return the label numbered @code{INDEX}. The default label is 0, followed
-by any labels in a switch statement.
+by any labels in a switch statement.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_switch_set_label (gimple g, unsigned @
index, tree label)
Set the label number @code{INDEX} to @code{LABEL}. 0 is always the default
-label.
+label.
@end deftypefn
@deftypefn {GIMPLE function} tree gimple_switch_default_label (gimple g)
-Return the default label for a switch statement.
+Return the default label for a switch statement.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_switch_set_default_label (gimple g, @
tree label)
-Set the default label for a switch statement.
+Set the default label for a switch statement.
@end deftypefn
@deftypefn {GIMPLE function} {enum gimple_try_flags} gimple_try_kind (gimple g)
Return the kind of try block represented by @code{GIMPLE_TRY} @code{G}. This is
-either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
+either @code{GIMPLE_TRY_CATCH} or @code{GIMPLE_TRY_FINALLY}.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_try_catch_is_cleanup (gimple g)
-Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
+Return the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_try_eval (gimple g)
Return the sequence of statements used as the body for @code{GIMPLE_TRY}
-@code{G}.
+@code{G}.
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_try_cleanup (gimple g)
Return the sequence of statements used as the cleanup body for
-@code{GIMPLE_TRY} @code{G}.
+@code{GIMPLE_TRY} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_try_set_catch_is_cleanup (gimple g, @
bool catch_is_cleanup)
-Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
+Set the @code{GIMPLE_TRY_CATCH_IS_CLEANUP} flag.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_try_set_eval (gimple g, gimple_seq eval)
Set @code{EVAL} to be the sequence of statements to use as the body for
-@code{GIMPLE_TRY} @code{G}.
+@code{GIMPLE_TRY} @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_try_set_cleanup (gimple g, gimple_seq cleanup)
Set @code{CLEANUP} to be the sequence of statements to use as the
-cleanup body for @code{GIMPLE_TRY} @code{G}.
+cleanup body for @code{GIMPLE_TRY} @code{G}.
@end deftypefn
@node @code{GIMPLE_WITH_CLEANUP_EXPR}
@end deftypefn
@deftypefn {GIMPLE function} gimple_seq gimple_wce_cleanup (gimple g)
-Return the cleanup sequence for cleanup statement @code{G}.
+Return the cleanup sequence for cleanup statement @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_wce_set_cleanup (gimple g, gimple_seq cleanup)
-Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
+Set @code{CLEANUP} to be the cleanup sequence for @code{G}.
@end deftypefn
@deftypefn {GIMPLE function} bool gimple_wce_cleanup_eh_only (gimple g)
-Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
+Return the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
@deftypefn {GIMPLE function} void gimple_wce_set_cleanup_eh_only (gimple g, bool eh_only_p)
-Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
+Set the @code{CLEANUP_EH_ONLY} flag for a @code{WCE} tuple.
@end deftypefn
-@node GIMPLE sequences
-@section GIMPLE sequences
-@cindex GIMPLE sequences
+@node GIMPLE sequences
+@section GIMPLE sequences
+@cindex GIMPLE sequences
GIMPLE sequences are the tuple equivalent of @code{STATEMENT_LIST}'s
used in @code{GENERIC}. They are used to chain statements together, and
Determine whether @code{SEQ} contains exactly one statement.
@end deftypefn
-@node Sequence iterators
-@section Sequence iterators
-@cindex Sequence iterators
+@node Sequence iterators
+@section Sequence iterators
+@cindex Sequence iterators
Sequence iterators are convenience constructs for iterating
through statements in a sequence. Given a sequence @code{SEQ}, here is
@node Statement and operand traversals
@section Statement and operand traversals
@cindex Statement and operand traversals
-
+
There are two functions available for walking statements and
sequences: @code{walk_gimple_stmt} and @code{walk_gimple_seq},
accordingly, and a third function for walking the operands in a
@};
@end smallexample
-Then the objects of @code{struct sorted_fields_type} are allocated in GC
+Then the objects of @code{struct sorted_fields_type} are allocated in GC
memory as follows:
@smallexample
field_vec = ggc_alloc_sorted_fields_type (size);
@item HOST_LONG_LONG_FORMAT
If defined, the string used to indicate an argument of type @code{long
long} to functions like @code{printf}. The default value is
-@code{"ll"}.
+@code{"ll"}.
@item HOST_LONG_FORMAT
If defined, the string used to indicate an argument of type @code{long}
-to functions like @code{printf}. The default value is @code{"l"}.
+to functions like @code{printf}. The default value is @code{"l"}.
@item HOST_PTR_PRINTF
If defined, the string used to indicate an argument of type @code{void *}
-to functions like @code{printf}. The default value is @code{"%p"}.
+to functions like @code{printf}. The default value is @code{"%p"}.
@end ftable
In addition, if @command{configure} generates an incorrect definition of
@end ifset
@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-@c 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
+@c 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
@c 2010, 2011 Free Software Foundation, Inc.
@c *** Converted to texinfo by Dean Wakerley, dean@wakerley.com
@item @TeX{} (any working version)
-Necessary for running @command{texi2dvi} and @command{texi2pdf}, which
+Necessary for running @command{texi2dvi} and @command{texi2pdf}, which
are used when running @command{make dvi} or @command{make pdf} to create
DVI or PDF files, respectively.
On MIPS targets, make @option{-msynci} the default when no
@option{-mno-synci} option is passed.
-@item --without-synci
+@item --without-synci
On MIPS targets, make @option{-mno-synci} the default when no
@option{-msynci} option is passed. This is the default.
only useful when you are already using @option{--with-sysroot}. You
can use @option{--with-build-sysroot} when you are configuring with
@option{--prefix} set to a directory that is different from the one in
-which you are installing GCC and your target libraries.
+which you are installing GCC and your target libraries.
This option affects the system root for the compiler used to build
target libraries (which runs on the build system); it does not affect
be specified.
@item --with-arch-directory=ARCH
-Specifies the name to use for the @file{jre/lib/ARCH} directory in the SDK
-environment created when --enable-java-home is passed. Typical names for this
+Specifies the name to use for the @file{jre/lib/ARCH} directory in the SDK
+environment created when --enable-java-home is passed. Typical names for this
directory include i386, amd64, ia64, etc.
@item --with-os-directory=DIR
java-1.5.0-gcj.
@item --with-arch-suffix=SUFFIX
-Specifies the suffix for the sdk directory. Defaults to the empty string.
+Specifies the suffix for the sdk directory. Defaults to the empty string.
Examples include '.x86_64' in 'java-1.5.0-gcj-1.5.0.0.x86_64'.
@item --with-jvm-root-dir=DIR
@item --with-python-dir=DIR
Specifies where to install the Python modules used for aot-compile. DIR should
not include the prefix used in installation. For example, if the Python modules
-are to be installed in /usr/lib/python2.5/site-packages, then
+are to be installed in /usr/lib/python2.5/site-packages, then
--with-python-dir=/lib/python2.5/site-packages should be passed. If this is
not specified, then the Python modules are installed in $(prefix)/share/python.
GNU Make 3.80 and above, which is necessary to build GCC, support
building in parallel. To activate this, you can use @samp{make -j 2}
-instead of @samp{make}. You can also specify a bigger number, and
+instead of @samp{make}. You can also specify a bigger number, and
in most cases using a value greater than the number of processors in
your machine will result in fewer and shorter I/O latency hits, thus
improving overall throughput; this is especially true for slow drives
@heading @anchor{windows}Microsoft Windows
@subheading Intel 16-bit versions
-The 16-bit versions of Microsoft Windows, such as Windows 3.1, are not
+The 16-bit versions of Microsoft Windows, such as Windows 3.1, are not
supported.
-However, the 32-bit port has limited support for Microsoft
+However, the 32-bit port has limited support for Microsoft
Windows 3.11 in the Win32s environment, as a target only. See below.
@subheading Intel 32-bit versions
-The 32-bit versions of Windows, including Windows 95, Windows NT, Windows
-XP, and Windows Vista, are supported by several different target
-platforms. These targets differ in which Windows subsystem they target
+The 32-bit versions of Windows, including Windows 95, Windows NT, Windows
+XP, and Windows Vista, are supported by several different target
+platforms. These targets differ in which Windows subsystem they target
and which C libraries are used.
@itemize
-@item Cygwin @uref{#x-x-cygwin,,*-*-cygwin}: Cygwin provides a user-space
+@item Cygwin @uref{#x-x-cygwin,,*-*-cygwin}: Cygwin provides a user-space
Linux API emulation layer in the Win32 subsystem.
-@item Interix @uref{#x-x-interix,,*-*-interix}: The Interix subsystem
+@item Interix @uref{#x-x-interix,,*-*-interix}: The Interix subsystem
provides native support for POSIX.
-@item MinGW @uref{#x-x-mingw32,,*-*-mingw32}: MinGW is a native GCC port for
+@item MinGW @uref{#x-x-mingw32,,*-*-mingw32}: MinGW is a native GCC port for
the Win32 subsystem that provides a subset of POSIX.
-@item MKS i386-pc-mks: NuTCracker from MKS. See
+@item MKS i386-pc-mks: NuTCracker from MKS. See
@uref{http://www.mkssoftware.com/} for more information.
@end itemize
@subheading Windows CE
-Windows CE is supported as a target only on ARM (arm-wince-pe), Hitachi
+Windows CE is supported as a target only on ARM (arm-wince-pe), Hitachi
SuperH (sh-wince-pe), and MIPS (mips-wince-pe).
@subheading Other Windows Platforms
GCC no longer supports Windows NT on the Alpha or PowerPC.
-GCC no longer supports the Windows POSIX subsystem. However, it does
+GCC no longer supports the Windows POSIX subsystem. However, it does
support the Interix subsystem. See above.
Old target names including *-*-winnt and *-*-windowsnt are no longer used.
-PW32 (i386-pc-pw32) support was never completed, and the project seems to
+PW32 (i386-pc-pw32) support was never completed, and the project seems to
be inactive. See @uref{http://pw32.sourceforge.net/} for more information.
UWIN support has been removed due to a lack of maintenance.
@end html
@heading @anchor{x-x-interix}*-*-interix
-The Interix target is used by OpenNT, Interix, Services For UNIX (SFU),
-and Subsystem for UNIX-based Applications (SUA). Applications compiled
-with this target run in the Interix subsystem, which is separate from
+The Interix target is used by OpenNT, Interix, Services For UNIX (SFU),
+and Subsystem for UNIX-based Applications (SUA). Applications compiled
+with this target run in the Interix subsystem, which is separate from
the Win32 subsystem. This target was last known to work in GCC 3.3.
@html
floating-point unit implement @code{float} in hardware, but emulate
@code{double} in software. On such a machine, doing computations
using @code{double} values is much more expensive because of the
-overhead required for software emulation.
+overhead required for software emulation.
It is easy to accidentally do computations with @code{double} because
floating-point literals are implicitly of type @code{double}. For
@group
float area(float radius)
@{
- return 3.14159 * radius * radius;
+ return 3.14159 * radius * radius;
@}
@end group
@end smallexample
@end group
@end smallexample
-Also warn for dangerous uses of the
+Also warn for dangerous uses of the
?: with omitted middle operand GNU extension. When the condition
in the ?: operator is a boolean expression the omitted value will
be always 1. Often the user expects it to be a value computed
-inside the conditional expression instead.
+inside the conditional expression instead.
This warning is enabled by @option{-Wall}.
entry to a use of the variable that is initialized, but there exist
some other paths the variable is not initialized, the compiler will
emit a warning if it can not prove the uninitialized paths do not
-happen at runtime. These warnings are made optional because GCC is
+happen at runtime. These warnings are made optional because GCC is
not smart enough to see all the reasons why the code might be correct
despite appearing to have an error. Here is one example of how
this can happen:
@opindex Wtrampolines
@opindex Wno-trampolines
Warn about trampolines generated for pointers to nested functions.
-
+
A trampoline is a small piece of data or code that is created at run
time on the stack when the address of a nested function is taken, and
is used to call the nested function indirectly. For some targets, it
optimizations that have a flag are listed in this section.
Most optimizations are only enabled if an @option{-O} level is set on
-the command line. Otherwise they are disabled, even if individual
+the command line. Otherwise they are disabled, even if individual
optimization flags are specified.
Depending on the target and how GCC was configured, a slightly different
@item -fsched-group-heuristic
@opindex fsched-group-heuristic
-Enable the group heuristic in the scheduler. This heuristic favors
-the instruction that belongs to a schedule group. This is enabled
-by default when scheduling is enabled, i.e.@: with @option{-fschedule-insns}
+Enable the group heuristic in the scheduler. This heuristic favors
+the instruction that belongs to a schedule group. This is enabled
+by default when scheduling is enabled, i.e.@: with @option{-fschedule-insns}
or @option{-fschedule-insns2} or at @option{-O2} or higher.
@item -fsched-critical-path-heuristic
@opindex fsched-critical-path-heuristic
-Enable the critical-path heuristic in the scheduler. This heuristic favors
-instructions on the critical path. This is enabled by default when
-scheduling is enabled, i.e.@: with @option{-fschedule-insns}
+Enable the critical-path heuristic in the scheduler. This heuristic favors
+instructions on the critical path. This is enabled by default when
+scheduling is enabled, i.e.@: with @option{-fschedule-insns}
or @option{-fschedule-insns2} or at @option{-O2} or higher.
@item -fsched-spec-insn-heuristic
@opindex fsched-spec-insn-heuristic
-Enable the speculative instruction heuristic in the scheduler. This
-heuristic favors speculative instructions with greater dependency weakness.
-This is enabled by default when scheduling is enabled, i.e.@:
-with @option{-fschedule-insns} or @option{-fschedule-insns2}
+Enable the speculative instruction heuristic in the scheduler. This
+heuristic favors speculative instructions with greater dependency weakness.
+This is enabled by default when scheduling is enabled, i.e.@:
+with @option{-fschedule-insns} or @option{-fschedule-insns2}
or at @option{-O2} or higher.
@item -fsched-rank-heuristic
@opindex fsched-rank-heuristic
-Enable the rank heuristic in the scheduler. This heuristic favors
-the instruction belonging to a basic block with greater size or frequency.
-This is enabled by default when scheduling is enabled, i.e.@:
-with @option{-fschedule-insns} or @option{-fschedule-insns2} or
+Enable the rank heuristic in the scheduler. This heuristic favors
+the instruction belonging to a basic block with greater size or frequency.
+This is enabled by default when scheduling is enabled, i.e.@:
+with @option{-fschedule-insns} or @option{-fschedule-insns2} or
at @option{-O2} or higher.
@item -fsched-last-insn-heuristic
@opindex fsched-last-insn-heuristic
-Enable the last-instruction heuristic in the scheduler. This heuristic
+Enable the last-instruction heuristic in the scheduler. This heuristic
favors the instruction that is less dependent on the last instruction
-scheduled. This is enabled by default when scheduling is enabled,
-i.e.@: with @option{-fschedule-insns} or @option{-fschedule-insns2} or
+scheduled. This is enabled by default when scheduling is enabled,
+i.e.@: with @option{-fschedule-insns} or @option{-fschedule-insns2} or
at @option{-O2} or higher.
@item -fsched-dep-count-heuristic
@opindex fsched-dep-count-heuristic
-Enable the dependent-count heuristic in the scheduler. This heuristic
-favors the instruction that has more instructions depending on it.
-This is enabled by default when scheduling is enabled, i.e.@:
-with @option{-fschedule-insns} or @option{-fschedule-insns2} or
+Enable the dependent-count heuristic in the scheduler. This heuristic
+favors the instruction that has more instructions depending on it.
+This is enabled by default when scheduling is enabled, i.e.@:
+with @option{-fschedule-insns} or @option{-fschedule-insns2} or
at @option{-O2} or higher.
@item -freschedule-modulo-scheduled-loops
GIMPLE files from @file{libfoo.a} and pass them on to the running GCC
to make them part of the aggregated GIMPLE image to be optimized.
-If you are not using a linker with linker plugin support and/or do not
+If you are not using a linker with linker plugin support and/or do not
enable linker plugin then the objects inside @file{libfoo.a}
will be extracted and linked as usual, but they will not participate
in the LTO optimization process.
operate. If the program does not require any symbols to be exported, it is
possible to combine @option{-flto} and with @option{-fwhole-program} to allow
the interprocedural optimizers to use more aggressive assumptions which may
-lead to improved optimization opportunities.
+lead to improved optimization opportunities.
Use of @option{-fwhole-program} is not needed when linker plugin is
active (see @option{-fuse-linker-plugin}).
environment variable @env{MAKE} may be used to override the program
used. The default value for @var{n} is 1.
-You can also specify @option{-flto=jobserver} to use GNU make's
-job server mode to determine the number of parallel jobs. This
+You can also specify @option{-flto=jobserver} to use GNU make's
+job server mode to determine the number of parallel jobs. This
is useful when the Makefile calling GCC is already executing in parallel.
The parent Makefile will need a @samp{+} prepended to the command recipe
-for this to work. This will likely only work if @env{MAKE} is
+for this to work. This will likely only work if @env{MAKE} is
GNU make.
This option is disabled by default.
This option enables the extraction of object files with GIMPLE bytecode out of
library archives. This improves the quality of optimization by exposing more
-code the link time optimizer. This information specify what symbols
+code the link time optimizer. This information specify what symbols
can be accessed externally (by non-LTO object or during dynamic linking).
Resulting code quality improvements on binaries (and shared libraries that do
use hidden visibility) is similar to @code{-fwhole-program}. See
@opindex mvzeroupper
This option instructs GCC to emit a @code{vzeroupper} instruction
before a transfer of control flow out of the function to minimize
-AVX to SSE transition penalty as well as remove unnecessary zeroupper
+AVX to SSE transition penalty as well as remove unnecessary zeroupper
intrinsics.
@item -mcx16
@item -mcpu=@var{cpu-type}
@opindex mcpu=
Use features of and schedule code for given CPU.
-Supported values are in the format @samp{v@var{X}.@var{YY}.@var{Z}},
-where @var{X} is a major version, @var{YY} is the minor version, and
+Supported values are in the format @samp{v@var{X}.@var{YY}.@var{Z}},
+where @var{X} is a major version, @var{YY} is the minor version, and
@var{Z} is compatibility code. Example values are @samp{v3.00.a},
-@samp{v4.00.b}, @samp{v5.00.a}, @samp{v5.00.b}, @samp{v5.00.b}, @samp{v6.00.a}.
+@samp{v4.00.b}, @samp{v5.00.a}, @samp{v5.00.b}, @samp{v5.00.b}, @samp{v6.00.a}.
@item -mxl-soft-mul
@opindex mxl-soft-mul
Use hardware floating point square root instruction.
@item -mxl-mode-@var{app-model}
-Select application model @var{app-model}. Valid models are
+Select application model @var{app-model}. Valid models are
@table @samp
@item executable
normal executable (default), uses startup code @file{crt0.o}.
@item xmdstub
-for use with Xilinx Microprocessor Debugger (XMD) based
-software intrusive debug agent called xmdstub. This uses startup file
+for use with Xilinx Microprocessor Debugger (XMD) based
+software intrusive debug agent called xmdstub. This uses startup file
@file{crt1.o} and sets the start address of the program to be 0x800.
@item bootstrap
for applications that are loaded using a bootloader.
-This model uses startup file @file{crt2.o} which does not contain a processor
-reset vector handler. This is suitable for transferring control on a
+This model uses startup file @file{crt2.o} which does not contain a processor
+reset vector handler. This is suitable for transferring control on a
processor reset to the bootloader rather than the application.
@item novectors
-for applications that do not require any of the
+for applications that do not require any of the
MicroBlaze vectors. This option may be useful for applications running
within a monitoring application. This model uses @file{crt3.o} as a startup file.
@end table
-Option @option{-xl-mode-@var{app-model}} is a deprecated alias for
+Option @option{-xl-mode-@var{app-model}} is a deprecated alias for
@option{-mxl-mode-@var{app-model}}.
@end table
@item -maccumulate-outgoing-args
@opindex maccumulate-outgoing-args
-Reserve space once for outgoing arguments in the function prologue rather
+Reserve space once for outgoing arguments in the function prologue rather
than around each call. Generally beneficial for performance and size. Also
needed for unwinding to avoid changing the stack frame around conditional code.
decimal floating point arithmetic and is only activated on selected
targets.
-The software decimal floating point library supports either DPD
-(Densely Packed Decimal) or BID (Binary Integer Decimal) encoding
+The software decimal floating point library supports either DPD
+(Densely Packed Decimal) or BID (Binary Integer Decimal) encoding
as selected at configure time.
and mapping this order to the elements of this array avoids costly
queries to the loop body representation.
-Three types of data references are currently handled: ARRAY_REF,
-INDIRECT_REF and COMPONENT_REF@. The data structure for the data reference
-is @code{data_reference}, where @code{data_reference_p} is a name of a
-pointer to the data reference structure. The structure contains the
+Three types of data references are currently handled: ARRAY_REF,
+INDIRECT_REF and COMPONENT_REF@. The data structure for the data reference
+is @code{data_reference}, where @code{data_reference_p} is a name of a
+pointer to the data reference structure. The structure contains the
following elements:
@itemize
-@item @code{base_object_info}: Provides information about the base object
-of the data reference and its access functions. These access functions
-represent the evolution of the data reference in the loop relative to
-its base, in keeping with the classical meaning of the data reference
-access function for the support of arrays. For example, for a reference
-@code{a.b[i][j]}, the base object is @code{a.b} and the access functions,
-one for each array subscript, are:
+@item @code{base_object_info}: Provides information about the base object
+of the data reference and its access functions. These access functions
+represent the evolution of the data reference in the loop relative to
+its base, in keeping with the classical meaning of the data reference
+access function for the support of arrays. For example, for a reference
+@code{a.b[i][j]}, the base object is @code{a.b} and the access functions,
+one for each array subscript, are:
@code{@{i_init, + i_step@}_1, @{j_init, +, j_step@}_2}.
-@item @code{first_location_in_loop}: Provides information about the first
-location accessed by the data reference in the loop and about the access
-function used to represent evolution relative to this location. This data
-is used to support pointers, and is not used for arrays (for which we
+@item @code{first_location_in_loop}: Provides information about the first
+location accessed by the data reference in the loop and about the access
+function used to represent evolution relative to this location. This data
+is used to support pointers, and is not used for arrays (for which we
have base objects). Pointer accesses are represented as a one-dimensional
-access that starts from the first location accessed in the loop. For
+access that starts from the first location accessed in the loop. For
example:
@smallexample
*((int *)p + i + j) = a[i][j];
@end smallexample
-The access function of the pointer access is @code{@{0, + 4B@}_for2}
-relative to @code{p + i}. The access functions of the array are
-@code{@{i_init, + i_step@}_for1} and @code{@{j_init, +, j_step@}_for2}
+The access function of the pointer access is @code{@{0, + 4B@}_for2}
+relative to @code{p + i}. The access functions of the array are
+@code{@{i_init, + i_step@}_for1} and @code{@{j_init, +, j_step@}_for2}
relative to @code{a}.
-Usually, the object the pointer refers to is either unknown, or we can't
-prove that the access is confined to the boundaries of a certain object.
+Usually, the object the pointer refers to is either unknown, or we can't
+prove that the access is confined to the boundaries of a certain object.
-Two data references can be compared only if at least one of these two
-representations has all its fields filled for both data references.
+Two data references can be compared only if at least one of these two
+representations has all its fields filled for both data references.
-The current strategy for data dependence tests is as follows:
-If both @code{a} and @code{b} are represented as arrays, compare
+The current strategy for data dependence tests is as follows:
+If both @code{a} and @code{b} are represented as arrays, compare
@code{a.base_object} and @code{b.base_object};
-if they are equal, apply dependence tests (use access functions based on
+if they are equal, apply dependence tests (use access functions based on
base_objects).
-Else if both @code{a} and @code{b} are represented as pointers, compare
-@code{a.first_location} and @code{b.first_location};
-if they are equal, apply dependence tests (use access functions based on
+Else if both @code{a} and @code{b} are represented as pointers, compare
+@code{a.first_location} and @code{b.first_location};
+if they are equal, apply dependence tests (use access functions based on
first location).
-However, if @code{a} and @code{b} are represented differently, only try
+However, if @code{a} and @code{b} are represented differently, only try
to prove that the bases are definitely different.
@item Aliasing information.
given in the @code{subscripts}, @code{dir_vects}, and @code{dist_vects}
arrays,
@item a boolean that determines whether the dependence relation can be
-represented by a classical distance vector,
+represented by a classical distance vector,
@item an array @code{subscripts} that contains a description of each
subscript of the data references. Given two array accesses a
subscript is the tuple composed of the access functions for a given
The interface used by the Omega solver for describing the linear
programming problems is described in @file{omega.h}, and the solver is
-@code{omega_solve_problem}.
+@code{omega_solve_problem}.
three instructions
@item m
-Memory operand.
+Memory operand.
Normally, @code{m} does not allow addresses that update the base register.
If @samp{<} or @samp{>} constraint is also used, they are allowed and
therefore on PowerPC targets in that case it is only safe
0, 1, 2, or 3 (shifts for the @code{lea} instruction).
@item N
-Unsigned 8-bit integer constant (for @code{in} and @code{out}
+Unsigned 8-bit integer constant (for @code{in} and @code{out}
instructions).
@ifset INTERNALS
@item SPU---@file{config/spu/spu.h}
@table @code
@item a
-An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is treated as a 64 bit value.
+An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is treated as a 64 bit value.
@item c
-An immediate for and/xor/or instructions. const_int is treated as a 64 bit value.
+An immediate for and/xor/or instructions. const_int is treated as a 64 bit value.
@item d
-An immediate for the @code{iohl} instruction. const_int is treated as a 64 bit value.
+An immediate for the @code{iohl} instruction. const_int is treated as a 64 bit value.
@item f
-An immediate which can be loaded with @code{fsmbi}.
+An immediate which can be loaded with @code{fsmbi}.
@item A
-An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is treated as a 32 bit value.
+An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is treated as a 32 bit value.
@item B
-An immediate for most arithmetic instructions. const_int is treated as a 32 bit value.
+An immediate for most arithmetic instructions. const_int is treated as a 32 bit value.
@item C
-An immediate for and/xor/or instructions. const_int is treated as a 32 bit value.
+An immediate for and/xor/or instructions. const_int is treated as a 32 bit value.
@item D
-An immediate for the @code{iohl} instruction. const_int is treated as a 32 bit value.
+An immediate for the @code{iohl} instruction. const_int is treated as a 32 bit value.
@item I
-A constant in the range [@minus{}64, 63] for shift/rotate instructions.
+A constant in the range [@minus{}64, 63] for shift/rotate instructions.
@item J
-An unsigned 7-bit constant for conversion/nop/channel instructions.
+An unsigned 7-bit constant for conversion/nop/channel instructions.
@item K
-A signed 10-bit constant for most arithmetic instructions.
+A signed 10-bit constant for most arithmetic instructions.
@item M
-A signed 16 bit immediate for @code{stop}.
+A signed 16 bit immediate for @code{stop}.
@item N
-An unsigned 16-bit constant for @code{iohl} and @code{fsmbi}.
+An unsigned 16-bit constant for @code{iohl} and @code{fsmbi}.
@item O
-An unsigned 7-bit constant whose 3 least significant bits are 0.
+An unsigned 7-bit constant whose 3 least significant bits are 0.
@item P
-An unsigned 3-bit constant for 16-byte rotates and shifts
+An unsigned 3-bit constant for 16-byte rotates and shifts
@item R
-Call operand, reg, for indirect calls
+Call operand, reg, for indirect calls
@item S
-Call operand, symbol, for relative calls.
+Call operand, symbol, for relative calls.
@item T
-Call operand, const_int, for absolute calls.
+Call operand, const_int, for absolute calls.
@item U
-An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is sign extended to 128 bit.
+An immediate which can be loaded with the il/ila/ilh/ilhu instructions. const_int is sign extended to 128 bit.
@item W
-An immediate for shift and rotate instructions. const_int is treated as a 32 bit value.
+An immediate for shift and rotate instructions. const_int is treated as a 32 bit value.
@item Y
-An immediate for and/xor/or instructions. const_int is sign extended as a 128 bit.
+An immediate for and/xor/or instructions. const_int is sign extended as a 128 bit.
@item Z
-An immediate for the @code{iohl} instruction. const_int is sign extended to 128 bit.
+An immediate for the @code{iohl} instruction. const_int is sign extended to 128 bit.
@end table
Machine-specific constraints can be given names of arbitrary length,
but they must be entirely composed of letters, digits, underscores
(@samp{_}), and angle brackets (@samp{< >}). Like C identifiers, they
-must begin with a letter or underscore.
+must begin with a letter or underscore.
In order to avoid ambiguity in operand constraint strings, no
constraint can have a name that begins with any other constraint's
@cindex @code{vec_extract_even@var{m}} instruction pattern
@item @samp{vec_extract_even@var{m}}
-Extract even elements from the input vectors (operand 1 and operand 2).
+Extract even elements from the input vectors (operand 1 and operand 2).
The even elements of operand 2 are concatenated to the even elements of operand
-1 in their original order. The result is stored in operand 0.
-The output and input vectors should have the same modes.
+1 in their original order. The result is stored in operand 0.
+The output and input vectors should have the same modes.
@cindex @code{vec_extract_odd@var{m}} instruction pattern
@item @samp{vec_extract_odd@var{m}}
-Extract odd elements from the input vectors (operand 1 and operand 2).
-The odd elements of operand 2 are concatenated to the odd elements of operand
+Extract odd elements from the input vectors (operand 1 and operand 2).
+The odd elements of operand 2 are concatenated to the odd elements of operand
1 in their original order. The result is stored in operand 0.
The output and input vectors should have the same modes.
@item @samp{vec_interleave_low@var{m}}
Merge low elements of the two input vectors into the output vector. The output
and input vectors should have the same modes (@code{N} elements). The low
-@code{N/2} elements of the first input vector are interleaved with the low
+@code{N/2} elements of the first input vector are interleaved with the low
@code{N/2} elements of the second input vector.
@cindex @code{vec_init@var{m}} instruction pattern
@item @samp{sdot_prod@var{m}}
@cindex @code{udot_prod@var{m}} instruction pattern
@item @samp{udot_prod@var{m}}
-Compute the sum of the products of two signed/unsigned elements.
-Operand 1 and operand 2 are of the same mode. Their product, which is of a
-wider mode, is computed and added to operand 3. Operand 3 is of a mode equal or
+Compute the sum of the products of two signed/unsigned elements.
+Operand 1 and operand 2 are of the same mode. Their product, which is of a
+wider mode, is computed and added to operand 3. Operand 3 is of a mode equal or
wider than the mode of the product. The result is placed in operand 0, which
-is of the same mode as operand 3.
+is of the same mode as operand 3.
@cindex @code{ssum_widen@var{m3}} instruction pattern
@item @samp{ssum_widen@var{m3}}
@cindex @code{usum_widen@var{m3}} instruction pattern
@item @samp{usum_widen@var{m3}}
-Operands 0 and 2 are of the same mode, which is wider than the mode of
+Operands 0 and 2 are of the same mode, which is wider than the mode of
operand 1. Add operand 1 to operand 2 and place the widened result in
operand 0. (This is used express accumulation of elements into an accumulator
of a wider mode.)
unit in the first string can be reserved only if each pattern of units
whose names are in the second string is not reserved. This is an
asymmetric relation (actually @samp{exclusion_set} is analogous to
-this one but it is symmetric). For example it might be useful in a
+this one but it is symmetric). For example it might be useful in a
@acronym{VLIW} description to say that @samp{slot0} cannot be reserved
after either @samp{slot1} or @samp{slot2} have been reserved. This
can be described as:
enumeration, you need to have it implement the method
@smallexample
-- (unsigned long) countByEnumeratingWithState: (NSFastEnumerationState *)state
+- (unsigned long) countByEnumeratingWithState: (NSFastEnumerationState *)state
objects: (id *)objects
count: (unsigned long)len;
@end smallexample
+ (BOOL) resolveInstanceMethod: (SEL)selector;
@end smallexample
-in the case of an instance method, or
+in the case of an instance method, or
@smallexample
+ (BOOL) resolveClassMethod: (SEL)selector;
Vectorization. This pass transforms loops to operate on vector types
instead of scalar types. Data parallelism across loop iterations is exploited
-to group data elements from consecutive iterations into a vector and operate
-on them in parallel. Depending on available target support the loop is
+to group data elements from consecutive iterations into a vector and operate
+on them in parallel. Depending on available target support the loop is
conceptually unrolled by a factor @code{VF} (vectorization factor), which is
-the number of elements operated upon in parallel in each iteration, and the
+the number of elements operated upon in parallel in each iteration, and the
@code{VF} copies of each scalar operation are fused to form a vector operation.
Additional loop transformations such as peeling and versioning may take place
-to align the number of iterations, and to align the memory accesses in the
+to align the number of iterations, and to align the memory accesses in the
loop.
The pass is implemented in @file{tree-vectorizer.c} (the main driver),
-@file{tree-vect-loop.c} and @file{tree-vect-loop-manip.c} (loop specific parts
-and general loop utilities), @file{tree-vect-slp} (loop-aware SLP
+@file{tree-vect-loop.c} and @file{tree-vect-loop-manip.c} (loop specific parts
+and general loop utilities), @file{tree-vect-slp} (loop-aware SLP
functionality), @file{tree-vect-stmts.c} and @file{tree-vect-data-refs.c}.
Analysis of data references is in @file{tree-data-ref.c}.
SLP Vectorization. This pass performs vectorization of straight-line code. The
pass is implemented in @file{tree-vectorizer.c} (the main driver),
-@file{tree-vect-slp.c}, @file{tree-vect-stmts.c} and
+@file{tree-vect-slp.c}, @file{tree-vect-stmts.c} and
@file{tree-vect-data-refs.c}.
Autoparallelization. This pass splits the loop iteration space to run
We identify if convertible loops, if-convert statements and merge
basic blocks in one big block. The idea is to present loop in such
form so that vectorizer can have one to one mapping between statements
-and available vector operations. This pass is located in
+and available vector operations. This pass is located in
@file{tree-if-conv.c} and is described by @code{pass_if_conversion}.
@item Conditional constant propagation
and invoked at pre-determined locations in the compilation
process.
-Plugins are loaded with
+Plugins are loaded with
@option{-fplugin=/path/to/@var{name}.so} @option{-fplugin-arg-@var{name}-@var{key1}[=@var{value1}]}
@end smallexample
-@section Interacting with the GCC Garbage Collector
+@section Interacting with the GCC Garbage Collector
Some plugins may want to be informed when GGC (the GCC Garbage
Collector) is running. They can register callbacks for the
for the @code{PLUGIN_GGC_MARKING} event. Such callbacks can call the
@code{ggc_set_mark} routine, preferably thru the @code{ggc_mark} macro
(and conversely, these routines should usually not be used in plugins
-outside of the @code{PLUGIN_GGC_MARKING} event).
+outside of the @code{PLUGIN_GGC_MARKING} event).
Some plugins may need to add extra GGC root tables, e.g. to handle their own
@code{GTY}-ed data. This can be done with the @code{PLUGIN_REGISTER_GGC_ROOTS}
/* Plugin callback called during attribute registration.
Registered with register_callback (plugin_name, PLUGIN_ATTRIBUTES, register_attributes, NULL)
*/
-static void
+static void
register_attributes (void *event_data, void *data)
@{
warning (0, G_("Callback to register attributes"));
register_callback (plugin_name, PLUGIN_PRAGMAS,
register_my_pragma, NULL);
*/
-static void
-register_my_pragma (void *event_data, void *data)
+static void
+register_my_pragma (void *event_data, void *data)
@{
warning (0, G_("Callback to register pragmas"));
c_register_pragma ("GCCPLUGIN", "sayhello", handle_pragma_sayhello);
@end smallexample
It is suggested to pass @code{"GCCPLUGIN"} (or a short name identifying
-your plugin) as the ``space'' argument of your pragma.
+your plugin) as the ``space'' argument of your pragma.
@section Recording information about pass execution
@findex MODE_CC
@item MODE_CC
Modes representing condition code values. These are @code{CCmode} plus
-any @code{CC_MODE} modes listed in the @file{@var{machine}-modes.def}.
+any @code{CC_MODE} modes listed in the @file{@var{machine}-modes.def}.
@xref{Jump Patterns},
also see @ref{Condition Code}.
Each pseudo register has a natural mode. If it is necessary to
operate on it in a different mode, the register must be
-enclosed in a @code{subreg}.
+enclosed in a @code{subreg}.
There are currently three supported types for the first operand of a
@code{subreg}:
are stored in @var{reg} and the high-order bits are discarded.
When used as an rvalue, the low-order bits of the @code{subreg} are
taken from @var{reg} while the high-order bits may or may not be
-defined.
+defined.
The high-order bits of rvalues are in the following circumstances:
two bytes to an unknown value assuming @code{SUBREG_PROMOTED_VAR_P} is
false.
-@item Normal subregs
+@item Normal subregs
When @var{m1} is at least as narrow as @var{m2} the @code{subreg}
expression is called @dfn{normal}.
integer values, with no particular numerical value. Only real.c and
the runtime libraries care about @code{FLOAT_WORDS_BIG_ENDIAN}.
-Thus,
+Thus,
@smallexample
(subreg:HI (reg:SI @var{x}) 2)
This describes an operation that selects parts of a vector. @var{vec1} is
the source vector, and @var{selection} is a @code{parallel} that contains a
@code{const_int} for each of the subparts of the result vector, giving the
-number of the source subpart that should be stored into it.
+number of the source subpart that should be stored into it.
The result mode @var{m} is either the submode for a single element of
-@var{vec1} (if only one subpart is selected), or another vector mode
+@var{vec1} (if only one subpart is selected), or another vector mode
with that element submode (if multiple subparts are selected).
@findex vec_concat
dependencies between instructions within a basic block. Neither a jump
nor a label may come between the related insns. These are only used by
the schedulers and by combine. This is a deprecated data structure.
-Def-use and use-def chains are now preferred.
+Def-use and use-def chains are now preferred.
@findex REG_NOTES
@item REG_NOTES (@var{i})
into hot and cold sections is turned on.
@findex REG_SETJMP
-@item REG_SETJMP
-Appears attached to each @code{CALL_INSN} to @code{setjmp} or a
+@item REG_SETJMP
+Appears attached to each @code{CALL_INSN} to @code{setjmp} or a
related function.
@end table
@end table
DVI-formatted manuals are generated by @samp{make dvi}, which uses
-@command{texi2dvi} (via the Makefile macro @code{$(TEXI2DVI)}).
+@command{texi2dvi} (via the Makefile macro @code{$(TEXI2DVI)}).
PDF-formatted manuals are generated by @samp{make pdf}, which uses
@command{texi2pdf} (via the Makefile macro @code{$(TEXI2PDF)}). HTML
formatted manuals are generated by @samp{make html}. Info
@item
The environment variable @code{GCC_EXEC_PREFIX} or, if @code{GCC_EXEC_PREFIX}
-is not set and the compiler has not been installed in the configure-time
+is not set and the compiler has not been installed in the configure-time
@var{prefix}, the location in which the compiler has actually been installed.
@item
@item
The macro @code{STANDARD_EXEC_PREFIX}, if the compiler has been installed
-in the configured-time @var{prefix}.
+in the configured-time @var{prefix}.
@item
-The location @file{/usr/libexec/gcc/}, but only if this is a native compiler.
+The location @file{/usr/libexec/gcc/}, but only if this is a native compiler.
@item
-The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
+The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
@item
-The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
+The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
compiler.
@end enumerate
@item
The macro @code{STANDARD_EXEC_PREFIX}, but only if the toolchain is installed
-in the configured @var{prefix} or this is a native compiler.
+in the configured @var{prefix} or this is a native compiler.
@item
The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
@item
-The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
+The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
compiler.
@item
-The macro @code{MD_STARTFILE_PREFIX}, if defined, but only if this is a
+The macro @code{MD_STARTFILE_PREFIX}, if defined, but only if this is a
native compiler, or we have a target system root.
@item
-The macro @code{MD_STARTFILE_PREFIX_1}, if defined, but only if this is a
+The macro @code{MD_STARTFILE_PREFIX_1}, if defined, but only if this is a
native compiler, or we have a target system root.
@item
@deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode @var{mode}, const_rtx @var{fun})
Define this hook if the back-end needs to know the name of the libcall
-function in order to determine where the result should be returned.
+function in order to determine where the result should be returned.
The mode of the result is given by @var{mode} and the name of the called
-library function is given by @var{fun}. The hook should return an RTX
+library function is given by @var{fun}. The hook should return an RTX
representing the place where the library function result will be returned.
If this hook is not defined, then LIBCALL_VALUE will be used.
If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the
first thing this hook should do is emit a block move into @var{m_tramp}
from the memory block returned by @code{assemble_trampoline_template}.
-Note that the block move need only cover the constant parts of the
+Note that the block move need only cover the constant parts of the
trampoline. If the target isolates the variable parts of the trampoline
to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied.
If the target requires any other actions, such as flushing caches or
-enabling stack execution, these actions should be performed after
+enabling stack execution, these actions should be performed after
initializing the trampoline proper.
@end deftypefn
is a valid address. On most machines the default definition of
@code{(CONSTANT_P (@var{x}) && GET_CODE (@var{x}) != CONST_DOUBLE)}
is acceptable, but a few machines are more restrictive as to which
-constant addresses are supported.
+constant addresses are supported.
@end defmac
@defmac CONSTANT_P (@var{x})
@deftypefn {Target Hook} int TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST (enum vect_cost_for_stmt @var{type_of_cost}, tree @var{vectype}, int @var{misalign})
Returns cost of different scalar or vector statements for vectorization cost model.
-For vector memory operations the cost may depend on type (@var{vectype}) and
+For vector memory operations the cost may depend on type (@var{vectype}) and
misalignment value (@var{misalign}).
@end deftypefn
@defmac SET_RATIO (@var{speed})
The threshold of number of scalar move insns, @emph{below} which a sequence
of insns should be generated to set memory to a constant value, instead of
-a block set insn or a library call.
+a block set insn or a library call.
Increasing the value will always make code faster, but
eventually incurs high cost in increased code size.
@defmac SET_BY_PIECES_P (@var{size}, @var{alignment})
A C expression used to determine whether @code{store_by_pieces} will be
-used to set a chunk of memory to a constant value, or whether some
-other mechanism will be used. Used by @code{__builtin_memset} when
+used to set a chunk of memory to a constant value, or whether some
+other mechanism will be used. Used by @code{__builtin_memset} when
storing values other than constant zero.
Defaults to 1 if @code{move_by_pieces_ninsns} returns less
than @code{SET_RATIO}.
when the source operand contains a symbolic address. You may also
need to alter the handling of switch statements so that they use
relative addresses.
-@c i rearranged the order of the macros above to try to force one of
+@c i rearranged the order of the macros above to try to force one of
@c them to the next line, to eliminate an overfull hbox. --mew 10feb93
@defmac PIC_OFFSET_TABLE_REGNUM
@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_SOURCE_FILENAME (FILE *@var{file}, const char *@var{name})
Output COFF information or DWARF debugging information which indicates that filename @var{name} is the current source file to the stdio stream @var{file}.
-
+
This target hook need not be defined if the standard form of output for the file format in use is appropriate.
@end deftypefn
@deftypefn {Target Hook} {section *} TARGET_ASM_FUNCTION_SECTION (tree @var{decl}, enum node_frequency @var{freq}, bool @var{startup}, bool @var{exit})
Return preferred text (sub)section for function @var{decl}.
Main purpose of this function is to separate cold, normal and hot
-functions. @var{startup} is true when function is known to be used only
+functions. @var{startup} is true when function is known to be used only
at startup (from static constructors or it is @code{main()}).
@var{exit} is true when function is known to be used only at exit
(from static destructors).
@defmac CLZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
@defmacx CTZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
A C expression that indicates whether the architecture defines a value
-for @code{clz} or @code{ctz} with a zero operand.
+for @code{clz} or @code{ctz} with a zero operand.
A result of @code{0} indicates the value is undefined.
If the value is defined for only the RTL expression, the macro should
evaluate to @code{1}; if the value applies also to the corresponding optab
entry (which is normally the case if it expands directly into
-the corresponding RTL), then the macro should evaluate to @code{2}.
+the corresponding RTL), then the macro should evaluate to @code{2}.
In the cases where the value is defined, @var{value} should be set to
-this value.
+this value.
If this macro is not defined, the value of @code{clz} or
@code{ctz} at zero is assumed to be undefined.
@defmac FUNCTION_MODE
An alias for the machine mode used for memory references to functions
being called, in @code{call} RTL expressions. On most CISC machines,
-where an instruction can begin at any byte address, this should be
+where an instruction can begin at any byte address, this should be
@code{QImode}. On most RISC machines, where all instructions have fixed
size and alignment, this should be a mode with the same size and alignment
as the machine instruction words - typically @code{SImode} or @code{HImode}.
@end deftypefn
@deftypefn {Target Hook} void TARGET_SET_CURRENT_FUNCTION (tree @var{decl})
-The compiler invokes this hook whenever it changes its current function
+The compiler invokes this hook whenever it changes its current function
context (@code{cfun}). You can define this function if
the back end needs to perform any initialization or reset actions on a
per-function basis. For example, it may be used to implement function
@deftypefn {Target Hook} {const char *} TARGET_INVALID_PARAMETER_TYPE (const_tree @var{type})
If defined, this macro returns the diagnostic message when it is
-invalid for functions to include parameters of type @var{type},
+invalid for functions to include parameters of type @var{type},
or @code{NULL} if validity should be determined by
the front end. This is currently used only by the C and C++ front ends.
@end deftypefn
@deftypefn {Target Hook} {const char *} TARGET_INVALID_RETURN_TYPE (const_tree @var{type})
If defined, this macro returns the diagnostic message when it is
-invalid for functions to have return type @var{type},
+invalid for functions to have return type @var{type},
or @code{NULL} if validity should be determined by
the front end. This is currently used only by the C and C++ front ends.
@end deftypefn
@deftypefn {Target Hook} tree TARGET_PROMOTED_TYPE (const_tree @var{type})
-If defined, this target hook returns the type to which values of
-@var{type} should be promoted when they appear in expressions,
+If defined, this target hook returns the type to which values of
+@var{type} should be promoted when they appear in expressions,
analogous to the integer promotions, or @code{NULL_TREE} to use the
front end's normal promotion rules. This hook is useful when there are
target-specific types with special promotion rules.
@end deftypefn
@deftypefn {Target Hook} tree TARGET_CONVERT_TO_TYPE (tree @var{type}, tree @var{expr})
-If defined, this hook returns the result of converting @var{expr} to
-@var{type}. It should return the converted expression,
+If defined, this hook returns the result of converting @var{expr} to
+@var{type}. It should return the converted expression,
or @code{NULL_TREE} to apply the front end's normal conversion rules.
-This hook is useful when there are target-specific types with special
+This hook is useful when there are target-specific types with special
conversion rules.
This is currently used only by the C and C++ front ends.
@end deftypefn
@defmac LIBGCC2_UNWIND_ATTRIBUTE
Define this macro if any target-specific attributes need to be attached
-to the functions in @file{libgcc} that provide low-level support for
+to the functions in @file{libgcc} that provide low-level support for
call stack unwinding. It is used in declarations in @file{unwind-generic.h}
and the associated definitions of those functions.
@end defmac
@item
The environment variable @code{GCC_EXEC_PREFIX} or, if @code{GCC_EXEC_PREFIX}
-is not set and the compiler has not been installed in the configure-time
+is not set and the compiler has not been installed in the configure-time
@var{prefix}, the location in which the compiler has actually been installed.
@item
@item
The macro @code{STANDARD_EXEC_PREFIX}, if the compiler has been installed
-in the configured-time @var{prefix}.
+in the configured-time @var{prefix}.
@item
-The location @file{/usr/libexec/gcc/}, but only if this is a native compiler.
+The location @file{/usr/libexec/gcc/}, but only if this is a native compiler.
@item
-The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
+The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
@item
-The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
+The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
compiler.
@end enumerate
@item
The macro @code{STANDARD_EXEC_PREFIX}, but only if the toolchain is installed
-in the configured @var{prefix} or this is a native compiler.
+in the configured @var{prefix} or this is a native compiler.
@item
The location @file{/usr/lib/gcc/}, but only if this is a native compiler.
@item
-The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
+The macro @code{MD_EXEC_PREFIX}, if defined, but only if this is a native
compiler.
@item
-The macro @code{MD_STARTFILE_PREFIX}, if defined, but only if this is a
+The macro @code{MD_STARTFILE_PREFIX}, if defined, but only if this is a
native compiler, or we have a target system root.
@item
-The macro @code{MD_STARTFILE_PREFIX_1}, if defined, but only if this is a
+The macro @code{MD_STARTFILE_PREFIX_1}, if defined, but only if this is a
native compiler, or we have a target system root.
@item
@hook TARGET_LIBCALL_VALUE
Define this hook if the back-end needs to know the name of the libcall
-function in order to determine where the result should be returned.
+function in order to determine where the result should be returned.
The mode of the result is given by @var{mode} and the name of the called
-library function is given by @var{fun}. The hook should return an RTX
+library function is given by @var{fun}. The hook should return an RTX
representing the place where the library function result will be returned.
If this hook is not defined, then LIBCALL_VALUE will be used.
If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the
first thing this hook should do is emit a block move into @var{m_tramp}
from the memory block returned by @code{assemble_trampoline_template}.
-Note that the block move need only cover the constant parts of the
+Note that the block move need only cover the constant parts of the
trampoline. If the target isolates the variable parts of the trampoline
to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied.
If the target requires any other actions, such as flushing caches or
-enabling stack execution, these actions should be performed after
+enabling stack execution, these actions should be performed after
initializing the trampoline proper.
@end deftypefn
is a valid address. On most machines the default definition of
@code{(CONSTANT_P (@var{x}) && GET_CODE (@var{x}) != CONST_DOUBLE)}
is acceptable, but a few machines are more restrictive as to which
-constant addresses are supported.
+constant addresses are supported.
@end defmac
@defmac CONSTANT_P (@var{x})
@hook TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
Returns cost of different scalar or vector statements for vectorization cost model.
-For vector memory operations the cost may depend on type (@var{vectype}) and
+For vector memory operations the cost may depend on type (@var{vectype}) and
misalignment value (@var{misalign}).
@end deftypefn
@defmac SET_RATIO (@var{speed})
The threshold of number of scalar move insns, @emph{below} which a sequence
of insns should be generated to set memory to a constant value, instead of
-a block set insn or a library call.
+a block set insn or a library call.
Increasing the value will always make code faster, but
eventually incurs high cost in increased code size.
@defmac SET_BY_PIECES_P (@var{size}, @var{alignment})
A C expression used to determine whether @code{store_by_pieces} will be
-used to set a chunk of memory to a constant value, or whether some
-other mechanism will be used. Used by @code{__builtin_memset} when
+used to set a chunk of memory to a constant value, or whether some
+other mechanism will be used. Used by @code{__builtin_memset} when
storing values other than constant zero.
Defaults to 1 if @code{move_by_pieces_ninsns} returns less
than @code{SET_RATIO}.
when the source operand contains a symbolic address. You may also
need to alter the handling of switch statements so that they use
relative addresses.
-@c i rearranged the order of the macros above to try to force one of
+@c i rearranged the order of the macros above to try to force one of
@c them to the next line, to eliminate an overfull hbox. --mew 10feb93
@defmac PIC_OFFSET_TABLE_REGNUM
@hook TARGET_ASM_FUNCTION_SECTION
Return preferred text (sub)section for function @var{decl}.
Main purpose of this function is to separate cold, normal and hot
-functions. @var{startup} is true when function is known to be used only
+functions. @var{startup} is true when function is known to be used only
at startup (from static constructors or it is @code{main()}).
@var{exit} is true when function is known to be used only at exit
(from static destructors).
@defmac CLZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
@defmacx CTZ_DEFINED_VALUE_AT_ZERO (@var{mode}, @var{value})
A C expression that indicates whether the architecture defines a value
-for @code{clz} or @code{ctz} with a zero operand.
+for @code{clz} or @code{ctz} with a zero operand.
A result of @code{0} indicates the value is undefined.
If the value is defined for only the RTL expression, the macro should
evaluate to @code{1}; if the value applies also to the corresponding optab
entry (which is normally the case if it expands directly into
-the corresponding RTL), then the macro should evaluate to @code{2}.
+the corresponding RTL), then the macro should evaluate to @code{2}.
In the cases where the value is defined, @var{value} should be set to
-this value.
+this value.
If this macro is not defined, the value of @code{clz} or
@code{ctz} at zero is assumed to be undefined.
@defmac FUNCTION_MODE
An alias for the machine mode used for memory references to functions
being called, in @code{call} RTL expressions. On most CISC machines,
-where an instruction can begin at any byte address, this should be
+where an instruction can begin at any byte address, this should be
@code{QImode}. On most RISC machines, where all instructions have fixed
size and alignment, this should be a mode with the same size and alignment
as the machine instruction words - typically @code{SImode} or @code{HImode}.
@end deftypefn
@hook TARGET_SET_CURRENT_FUNCTION
-The compiler invokes this hook whenever it changes its current function
+The compiler invokes this hook whenever it changes its current function
context (@code{cfun}). You can define this function if
the back end needs to perform any initialization or reset actions on a
per-function basis. For example, it may be used to implement function
@hook TARGET_INVALID_PARAMETER_TYPE
If defined, this macro returns the diagnostic message when it is
-invalid for functions to include parameters of type @var{type},
+invalid for functions to include parameters of type @var{type},
or @code{NULL} if validity should be determined by
the front end. This is currently used only by the C and C++ front ends.
@end deftypefn
@hook TARGET_INVALID_RETURN_TYPE
If defined, this macro returns the diagnostic message when it is
-invalid for functions to have return type @var{type},
+invalid for functions to have return type @var{type},
or @code{NULL} if validity should be determined by
the front end. This is currently used only by the C and C++ front ends.
@end deftypefn
@hook TARGET_PROMOTED_TYPE
-If defined, this target hook returns the type to which values of
-@var{type} should be promoted when they appear in expressions,
+If defined, this target hook returns the type to which values of
+@var{type} should be promoted when they appear in expressions,
analogous to the integer promotions, or @code{NULL_TREE} to use the
front end's normal promotion rules. This hook is useful when there are
target-specific types with special promotion rules.
@end deftypefn
@hook TARGET_CONVERT_TO_TYPE
-If defined, this hook returns the result of converting @var{expr} to
-@var{type}. It should return the converted expression,
+If defined, this hook returns the result of converting @var{expr} to
+@var{type}. It should return the converted expression,
or @code{NULL_TREE} to apply the front end's normal conversion rules.
-This hook is useful when there are target-specific types with special
+This hook is useful when there are target-specific types with special
conversion rules.
This is currently used only by the C and C++ front ends.
@end deftypefn
@defmac LIBGCC2_UNWIND_ATTRIBUTE
Define this macro if any target-specific attributes need to be attached
-to the functions in @file{libgcc} that provide low-level support for
+to the functions in @file{libgcc} that provide low-level support for
call stack unwinding. It is used in declarations in @file{unwind-generic.h}
and the associated definitions of those functions.
@end defmac
call to @code{update_stmt}.
@subsection Operand Iterators And Access Routines
-@cindex Operand Iterators
+@cindex Operand Iterators
@cindex Operand Access Routines
Operands are collected by @file{tree-ssa-operands.c}. They are stored
The following access routines are available for examining operands:
@enumerate
-@item @code{SINGLE_SSA_@{USE,DEF,TREE@}_OPERAND}: These accessors will return
-NULL unless there is exactly one operand matching the specified flags. If
-there is exactly one operand, the operand is returned as either a @code{tree},
+@item @code{SINGLE_SSA_@{USE,DEF,TREE@}_OPERAND}: These accessors will return
+NULL unless there is exactly one operand matching the specified flags. If
+there is exactly one operand, the operand is returned as either a @code{tree},
@code{def_operand_p}, or @code{use_operand_p}.
@smallexample
def_operand_p d = SINGLE_SSA_DEF_OPERAND (stmt, SSA_OP_ALL_DEFS);
@end smallexample
-@item @code{ZERO_SSA_OPERANDS}: This macro returns true if there are no
+@item @code{ZERO_SSA_OPERANDS}: This macro returns true if there are no
operands matching the specified flags.
@smallexample
return;
@end smallexample
-@item @code{NUM_SSA_OPERANDS}: This macro Returns the number of operands
-matching 'flags'. This actually executes a loop to perform the count, so
+@item @code{NUM_SSA_OPERANDS}: This macro Returns the number of operands
+matching 'flags'. This actually executes a loop to perform the count, so
only use this if it is really needed.
@smallexample
There are also a couple of variants on the stmt iterators regarding PHI
nodes.
-@code{FOR_EACH_PHI_ARG} Works exactly like
-@code{FOR_EACH_SSA_USE_OPERAND}, except it works over @code{PHI} arguments
+@code{FOR_EACH_PHI_ARG} Works exactly like
+@code{FOR_EACH_SSA_USE_OPERAND}, except it works over @code{PHI} arguments
instead of statement operands.
@smallexample
my_code;
@end smallexample
-@code{FOR_EACH_PHI_OR_STMT_@{USE,DEF@}} works exactly like
+@code{FOR_EACH_PHI_OR_STMT_@{USE,DEF@}} works exactly like
@code{FOR_EACH_SSA_@{USE,DEF@}_OPERAND}, except it will function on
either a statement or a @code{PHI} node. These should be used when it is
-appropriate but they are not quite as efficient as the individual
+appropriate but they are not quite as efficient as the individual
@code{FOR_EACH_PHI} and @code{FOR_EACH_SSA} routines.
@smallexample
@subsection Immediate Uses
@cindex Immediate Uses
-Immediate use information is now always available. Using the immediate use
+Immediate use information is now always available. Using the immediate use
iterators, you may examine every use of any @code{SSA_NAME}. For instance,
to change each use of @code{ssa_var} to @code{ssa_var2} and call fold_stmt on
each stmt after that is done:
There are 2 iterators which can be used. @code{FOR_EACH_IMM_USE_FAST} is
used when the immediate uses are not changed, i.e., you are looking at the
-uses, but not setting them.
+uses, but not setting them.
-If they do get changed, then care must be taken that things are not changed
-under the iterators, so use the @code{FOR_EACH_IMM_USE_STMT} and
-@code{FOR_EACH_IMM_USE_ON_STMT} iterators. They attempt to preserve the
-sanity of the use list by moving all the uses for a statement into
-a controlled position, and then iterating over those uses. Then the
+If they do get changed, then care must be taken that things are not changed
+under the iterators, so use the @code{FOR_EACH_IMM_USE_STMT} and
+@code{FOR_EACH_IMM_USE_ON_STMT} iterators. They attempt to preserve the
+sanity of the use list by moving all the uses for a statement into
+a controlled position, and then iterating over those uses. Then the
optimization can manipulate the stmt when all the uses have been
-processed. This is a little slower than the FAST version since it adds a
-placeholder element and must sort through the list a bit for each statement.
-This placeholder element must be also be removed if the loop is
-terminated early. The macro @code{BREAK_FROM_IMM_USE_SAFE} is provided
+processed. This is a little slower than the FAST version since it adds a
+placeholder element and must sort through the list a bit for each statement.
+This placeholder element must be also be removed if the loop is
+terminated early. The macro @code{BREAK_FROM_IMM_USE_SAFE} is provided
to do this :
@smallexample
@end smallexample
There are checks in @code{verify_ssa} which verify that the immediate use list
-is up to date, as well as checking that an optimization didn't break from the
-loop without using this macro. It is safe to simply 'break'; from a
+is up to date, as well as checking that an optimization didn't break from the
+loop without using this macro. It is safe to simply 'break'; from a
@code{FOR_EACH_IMM_USE_FAST} traverse.
Some useful functions and macros:
@enumerate
@item @code{has_zero_uses (ssa_var)} : Returns true if there are no uses of
@code{ssa_var}.
-@item @code{has_single_use (ssa_var)} : Returns true if there is only a
+@item @code{has_single_use (ssa_var)} : Returns true if there is only a
single use of @code{ssa_var}.
@item @code{single_imm_use (ssa_var, use_operand_p *ptr, tree *stmt)} :
Returns true if there is only a single use of @code{ssa_var}, and also returns
@end enumerate
Note that uses are not put into an immediate use list until their statement is
-actually inserted into the instruction stream via a @code{bsi_*} routine.
+actually inserted into the instruction stream via a @code{bsi_*} routine.
-It is also still possible to utilize lazy updating of statements, but this
-should be used only when absolutely required. Both alias analysis and the
-dominator optimizations currently do this.
+It is also still possible to utilize lazy updating of statements, but this
+should be used only when absolutely required. Both alias analysis and the
+dominator optimizations currently do this.
-When lazy updating is being used, the immediate use information is out of date
+When lazy updating is being used, the immediate use information is out of date
and cannot be used reliably. Lazy updating is achieved by simply marking
-statements modified via calls to @code{mark_stmt_modified} instead of
-@code{update_stmt}. When lazy updating is no longer required, all the
-modified statements must have @code{update_stmt} called in order to bring them
-up to date. This must be done before the optimization is finished, or
+statements modified via calls to @code{mark_stmt_modified} instead of
+@code{update_stmt}. When lazy updating is no longer required, all the
+modified statements must have @code{update_stmt} called in order to bring them
+up to date. This must be done before the optimization is finished, or
@code{verify_ssa} will trigger an abort.
This is done with a simple loop over the instruction stream:
invalidate the SSA property. This can happen when a pass has
added new symbols or changed the program so that variables that
were previously aliased aren't anymore. Whenever something like this
-happens, the affected symbols must be renamed into SSA form again.
+happens, the affected symbols must be renamed into SSA form again.
Transformations that emit new code or replicate existing statements
will also need to update the SSA form@.
projects / platform / upstream / linaro-gcc.git / commitdiff