[hellogcc] Update gccint-zh trunk to upstreams r179462
- From: Yao Qi <qiyaoltc@xxxxxxxxx>
- To: hellogcc@xxxxxxxxxxxxx
- Date: Fri, 7 Oct 2011 21:47:22 +0800
这个patch是fsf gcc doc目录下边和gccint有关文件从 r170935到
r179462的修改。我们gccint-zh trunk也是根据这个patch进行修改。
--
Yao Qi <qiyaoltc AT gmail DOT com>
You could live a better life, if you had a better mind and a better body.
Index: loop.texi
===================================================================
--- loop.texi (revision 170935)
+++ loop.texi (revision 179462)
@@ -498,28 +498,28 @@
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
@@ -528,27 +528,27 @@
*((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.
@@ -571,7 +571,7 @@
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
@@ -652,4 +652,4 @@
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}.
Index: generic.texi
===================================================================
--- generic.texi (revision 170935)
+++ generic.texi (revision 179462)
@@ -621,7 +621,7 @@
@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
@@ -734,11 +734,11 @@
@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
@@ -810,7 +810,7 @@
@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
@@ -819,11 +819,11 @@
@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
@@ -1574,8 +1574,8 @@
@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
@@ -1695,7 +1695,7 @@
@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
@@ -1703,8 +1703,8 @@
@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.
@@ -1712,9 +1712,9 @@
@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
@@ -1724,7 +1724,7 @@
@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
@@ -1770,19 +1770,19 @@
@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
@@ -2210,7 +2210,9 @@
@code{OMP_CLAUSE_COPYPRIVATE}, @code{OMP_CLAUSE_IF},
@code{OMP_CLAUSE_NUM_THREADS}, @code{OMP_CLAUSE_SCHEDULE},
@code{OMP_CLAUSE_NOWAIT}, @code{OMP_CLAUSE_ORDERED},
-@code{OMP_CLAUSE_DEFAULT}, and @code{OMP_CLAUSE_REDUCTION}. Each code
+@code{OMP_CLAUSE_DEFAULT}, @code{OMP_CLAUSE_REDUCTION},
+@code{OMP_CLAUSE_COLLAPSE}, @code{OMP_CLAUSE_UNTIED},
+@code{OMP_CLAUSE_FINAL}, and @code{OMP_CLAUSE_MERGEABLE}. Each code
represents the corresponding OpenMP clause.
Clauses associated with the same directive are chained together
@@ -2502,7 +2504,7 @@
@tindex UNKNOWN_TYPE
@tindex TYPENAME_TYPE
@tindex TYPEOF_TYPE
-@findex CP_TYPE_QUALS
+@findex cp_type_quals
@findex TYPE_UNQUALIFIED
@findex TYPE_QUAL_CONST
@findex TYPE_QUAL_VOLATILE
@@ -2534,8 +2536,8 @@
The following functions and macros deal with cv-qualification of types:
@ftable @code
-@item CP_TYPE_QUALS
-This macro returns the set of type qualifiers applied to this type.
+@item cp_type_quals
+This function returns the set of type qualifiers applied to this type.
This value is @code{TYPE_UNQUALIFIED} if no qualifiers have been
applied. The @code{TYPE_QUAL_CONST} bit is set if the type is
@code{const}-qualified. The @code{TYPE_QUAL_VOLATILE} bit is set if the
@@ -2616,7 +2618,7 @@
@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
Index: sourcebuild.texi
===================================================================
--- sourcebuild.texi (revision 170935)
+++ sourcebuild.texi (revision 179462)
@@ -366,7 +366,7 @@
@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
@@ -834,6 +834,9 @@
@file{MAINTAINERS}. Some existing architectures may be unmaintained,
but it would be unusual to add support for a target that does not have
a maintainer when support is added.
+@item
+Target triplets covering all @file{config.gcc} stanzas for the target,
+in the list in @file{contrib/config-list.mk}.
@end itemize
@node Testsuites
@@ -1013,6 +1016,11 @@
default, or that don't provide them at all. It must come after
all @code{dg-options} directives.
For supported values of @var{feature} see @ref{Add Options, ,}.
+
+@item @{ dg-additional-options @var{options} [@{ target @var{selector} @}] @}
+This directive provides a list of compiler options, to be used
+if the target system matches @var{selector}, that are added to the default
+options used for this set of tests.
@end table
@subsubsection Modify the test timeout value
@@ -1671,6 +1679,9 @@
conversion functions and overflow is not always detected correctly by
those functions.
+@item mmap
+Target supports @code{mmap}.
+
@item newlib
Target supports Newlib.
@@ -1752,6 +1763,9 @@
@item gc_sections
Target supports @option{--gc-sections}.
+@item gld
+Target uses GNU @command{ld}.
+
@item keeps_null_pointer_checks
Target keeps null pointer checks, either due to the use of
@option{-fno-delete-null-pointer-checks} or hardwired into the target.
@@ -1779,6 +1793,9 @@
@item pe_aligned_commons
Target supports @option{-mpe-aligned-commons}.
+@item pie
+Target supports @option{-pie}, @option{-fpie} and @option{-fPIE}.
+
@item section_anchors
Target supports section anchors.
@@ -2113,9 +2130,9 @@
@node Ada Tests
@section Ada Language Testsuites
-The Ada testsuite includes executable tests from the ACATS 2.5
+The Ada testsuite includes executable tests from the ACATS
testsuite, publicly available at
-@uref{http://www.adaic.org/compilers/acats/2.5}.
+@uref{http://www.ada-auth.org/acats.html}.
These tests are integrated in the GCC testsuite in the
@file{ada/acats} directory, and
Index: plugins.texi
===================================================================
--- plugins.texi (revision 170935)
+++ plugins.texi (revision 179462)
@@ -14,7 +14,7 @@
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}]}
@@ -151,6 +151,7 @@
@{
PLUGIN_PASS_MANAGER_SETUP, /* To hook into pass manager. */
PLUGIN_FINISH_TYPE, /* After finishing parsing a type. */
+ PLUGIN_FINISH_DECL, /* After finishing parsing a declaration. */
PLUGIN_FINISH_UNIT, /* Useful for summary processing. */
PLUGIN_PRE_GENERICIZE, /* Allows to see low level AST in C and C++
frontends. */
PLUGIN_FINISH, /* Called before GCC exits. */
@@ -264,7 +265,7 @@
@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
@@ -277,7 +278,7 @@
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}
@@ -331,12 +332,12 @@
/* Attribute definition */
static struct attribute_spec user_attr =
- @{ "user", 1, 1, false, false, false, handle_user_attribute @};
+ @{ "user", 1, 1, false, false, false, handle_user_attribute, false @};
/* 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"));
@@ -356,8 +357,8 @@
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);
@@ -365,7 +366,7 @@
@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
@@ -417,6 +418,17 @@
Inside plugins, this @code{plugin} directory name can be queried by
calling @code{default_plugin_dir_name ()}.
+Plugins may know, when they are compiled, the GCC version for which
+@file{plugin-version.h} is provided. The constant macros
+@code{GCCPLUGIN_VERSION_MAJOR}, @code{GCCPLUGIN_VERSION_MINOR},
+@code{GCCPLUGIN_VERSION_PATCHLEVEL}, @code{GCCPLUGIN_VERSION} are
+integer numbers, so a plugin could ensure it is built for GCC 4.7 with
+@smallexample
+#if GCCPLUGIN_VERSION != 4007
+#error this GCC plugin is for GCC 4.7
+#endif
+@end smallexample
+
The following GNU Makefile excerpt shows how to build a simple plugin:
@smallexample
@@ -435,6 +447,6 @@
plugin.so}, using backquote shell syntax to query the @file{plugin}
directory.
-Plugins needing to use @command{gengtype} require a GCC build
-directory for the same version of GCC that they will be linked
-against.
+When a plugin needs to use @command{gengtype}, be sure that both
+@file{gengtype} and @file{gtype.state} have the same version as the
+GCC for which the plugin is built.
Index: configfiles.texi
===================================================================
--- configfiles.texi (revision 170935)
+++ configfiles.texi (revision 179462)
@@ -59,6 +59,14 @@
machine.
@item
@file{tm_p.h}, which includes the header @file{@var{machine}-protos.h}
-that contains prototypes for functions in the target @file{.c} file.
-FIXME: why is such a separate header necessary?
+that contains prototypes for functions in the target
+@file{@var{machine}.c} file. The header @file{@var{machine}-protos.h}
+can include prototypes of functions that use rtl and tree data
+structures inside appropriate @code{#ifdef RTX_CODE} and @code{#ifdef
+TREE_CODE} conditional code segements. The
+@file{@var{machine}-protos.h} is included after the @file{rtl.h}
+and/or @file{tree.h} would have been included. The @file{tm_p.h} also
+includes the header @file{tm-preds.h} which is generated by
+@file{genpreds} program during the build to define the declarations
+and inline functions for the predicate functions.
@end itemize
Index: options.texi
===================================================================
--- options.texi (revision 170935)
+++ options.texi (revision 179462)
@@ -71,7 +71,8 @@
@item
A variable record to record any additional files that the
-@file{options.c} file should include. This is useful to provide
+@file{options.c} or @file{options-save.c} file should include. This
+is useful to provide
inline functions needed for target variables and/or @code{#ifdef}
sequences to properly set up the initialization. These records have
two fields: the string @samp{SourceInclude} and the name of the
@@ -222,6 +223,13 @@
propagate through the @code{Negative} property of the option to be
turned off.
+As a consequence, if you have a group of mutually-exclusive
+options, their @code{Negative} properties should form a circular chain.
+For example, if options @option{-@var{a}}, @option{-@var{b}} and
+@option{-@var{c}} are mutually exclusive, their respective @code{Negative}
+properties should be @samp{Negative(@var{b})}, @samp{Negative(@var{c})}
+and @samp{Negative(@var{a})}.
+
@item Joined
@itemx Separate
The option takes a mandatory argument. @code{Joined} indicates
@@ -257,6 +265,11 @@
@code{-falign-loops}=@var{n} are supported to make sure the saved
options are given a full integer.
+@item ToLower
+The option's argument should be converted to lowercase as part of
+putting it in canonical form, and before comparing with the strings
+indicated by any @code{Enum} property.
+
@item NoDriverArg
For an option marked @code{Separate}, the option only takes an
argument in the compiler proper, not in the driver. This is for
@@ -364,7 +377,8 @@
@item Alias(@var{opt})
@itemx Alias(@var{opt}, @var{arg})
@itemx Alias(@var{opt}, @var{posarg}, @var{negarg})
-The option is an alias for @option{-@var{opt}}. In the first form,
+The option is an alias for @option{-@var{opt}} (or the negative form
+of that option, depending on @code{NegativeAlias}). In the first form,
any argument passed to the alias is considered to be passed to
@option{-@var{opt}}, and @option{-@var{opt}} is considered to be
negated if the alias is used in negated form. In the second form, the
@@ -387,6 +401,13 @@
for it; only the canonical form of the option will be seen in those
places.
+@item NegativeAlias
+For an option marked with @code{Alias(@var{opt})}, the option is
+considered to be an alias for the positive form of @option{-@var{opt}}
+if negated and for the negative form of @option{-@var{opt}} if not
+negated. @code{NegativeAlias} may not be used with the forms of
+@code{Alias} taking more than one argument.
+
@item Ignore
This option is ignored apart from printing any warning specified using
@code{Warn}. The option will not be seen by specs and no @samp{OPT_}
Index: passes.texi
===================================================================
--- passes.texi (revision 170935)
+++ passes.texi (revision 179462)
@@ -1,4 +1,4 @@
-@c markers: CROSSREF BUG TODO
+@c markers: BUG TODO
@c Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
@c 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
@@ -32,7 +32,7 @@
The language front end is invoked only once, via
@code{lang_hooks.parse_file}, to parse the entire input. The language
front end may use any intermediate language representation deemed
-appropriate. The C front end uses GENERIC trees (CROSSREF), plus
+appropriate. The C front end uses GENERIC trees (@pxref{GENERIC}), plus
a double handful of language specific tree codes defined in
@file{c-common.def}. The Fortran front end uses a completely different
private representation.
@@ -46,10 +46,9 @@
At some point the front end must translate the representation used in the
front end to a representation understood by the language-independent
portions of the compiler. Current practice takes one of two forms.
-The C front end manually invokes the gimplifier (CROSSREF) on each function,
+The C front end manually invokes the gimplifier (@pxref{GIMPLE}) on each
function,
and uses the gimplifier callbacks to convert the language-specific tree
-nodes directly to GIMPLE (CROSSREF) before passing the function off to
-be compiled.
+nodes directly to GIMPLE before passing the function off to be compiled.
The Fortran front end converts from a private representation to GENERIC,
which is later lowered to GIMPLE when the function is compiled. Which
route to choose probably depends on how well GENERIC (plus extensions)
@@ -111,11 +110,10 @@
@cindex GIMPLE
@dfn{Gimplification} is a whimsical term for the process of converting
the intermediate representation of a function into the GIMPLE language
-(CROSSREF). The term stuck, and so words like ``gimplification'',
+(@pxref{GIMPLE}). The term stuck, and so words like ``gimplification'',
``gimplify'', ``gimplifier'' and the like are sprinkled throughout this
section of code.
-@cindex GENERIC
While a front end may certainly choose to generate GIMPLE directly if
it chooses, this can be a moderately complex process unless the
intermediate language used by the front end is already fairly simple.
@@ -437,23 +435,23 @@
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
@@ -472,7 +470,7 @@
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
Index: cfg.texi
===================================================================
--- cfg.texi (revision 170935)
+++ cfg.texi (revision 179462)
@@ -626,7 +626,7 @@
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
@@ -634,7 +634,7 @@
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
@@ -645,7 +645,7 @@
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
Index: gimple.texi
===================================================================
--- gimple.texi (revision 170935)
+++ gimple.texi (revision 179462)
@@ -122,7 +122,7 @@
@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
@@ -185,7 +185,7 @@
@item @code{bb}
Basic block holding the instruction.
-
+
@item @code{block}
Lexical block holding this statement. Also used for debug
information generation.
@@ -318,7 +318,7 @@
@};
@end smallexample
-
+
@node GIMPLE instruction set
@section GIMPLE instruction set
@cindex GIMPLE instruction set
@@ -692,11 +692,11 @@
@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
@@ -718,21 +718,21 @@
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
@@ -753,135 +753,135 @@
@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
@@ -941,57 +941,57 @@
@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}
@@ -1040,8 +1040,8 @@
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
computed on the rhs of assignment statement @code{G}. This will never
@@ -1051,24 +1051,24 @@
@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}.
@@ -1077,7 +1077,7 @@
@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}.
@@ -1086,22 +1086,22 @@
@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
@@ -1117,12 +1117,12 @@
@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)
@@ -1132,7 +1132,7 @@
@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)
@@ -1140,7 +1140,7 @@
@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)
@@ -1150,12 +1150,12 @@
@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
@@ -1190,32 +1190,32 @@
@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
@@ -1223,54 +1223,54 @@
@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)
@@ -1290,25 +1290,25 @@
@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
@@ -1332,60 +1332,60 @@
@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}
@@ -1475,34 +1475,34 @@
@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
@@ -1516,12 +1516,12 @@
@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
@@ -1530,7 +1530,7 @@
@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)
@@ -1547,7 +1547,7 @@
@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}
@@ -1561,19 +1561,19 @@
@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
@@ -1587,11 +1587,11 @@
@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}
@@ -1608,25 +1608,25 @@
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}.
@@ -1644,16 +1644,16 @@
@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}
@@ -1674,35 +1674,35 @@
@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)
@@ -1710,45 +1710,45 @@
@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
@@ -1792,63 +1792,63 @@
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
@@ -1864,8 +1864,8 @@
@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
@code{GF_OMP_RETURN_NOWAIT} flag set.
@@ -1885,7 +1885,7 @@
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
@@ -1910,28 +1910,28 @@
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
@@ -1947,15 +1947,15 @@
@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
@@ -1968,35 +1968,35 @@
@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}
@@ -2011,11 +2011,11 @@
@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}
@@ -2027,11 +2027,11 @@
@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}
@@ -2057,41 +2057,41 @@
@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
@@ -2111,36 +2111,36 @@
@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}
@@ -2153,25 +2153,25 @@
@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
@@ -2256,9 +2256,9 @@
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
@@ -2516,7 +2516,7 @@
@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
Index: tm.texi
===================================================================
--- tm.texi (revision 170935)
+++ tm.texi (revision 179462)
@@ -1,5 +1,5 @@
@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,
-@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@@ -91,6 +91,24 @@
from being defined in the @file{.h} file to being part of the
@code{targetm} structure.
+Similarly, there is a @code{targetcm} variable for hooks that are
+specific to front ends for C-family languages, documented as ``C
+Target Hook''. This is declared in @file{c-family/c-target.h}, the
+initializer @code{TARGETCM_INITIALIZER} in
+@file{c-family/c-target-def.h}. If targets initialize @code{targetcm}
+themselves, they should set @code{target_has_targetcm=yes} in
+@file{config.gcc}; otherwise a default definition is used.
+
+Similarly, there is a @code{targetm_common} variable for hooks that
+are shared between the compiler driver and the compilers proper,
+documented as ``Common Target Hook''. This is declared in
+@file{common/common-target.h}, the initializer
+@code{TARGETM_COMMON_INITIALIZER} in
+@file{common/common-target-def.h}. If targets initialize
+@code{targetm_common} themselves, they should set
+@code{target_has_targetm_common=yes} in @file{config.gcc}; otherwise a
+default definition is used.
+
@node Driver
@section Controlling the Compilation Driver, @file{gcc}
@cindex driver
@@ -375,6 +393,10 @@
removing duplicate search directories changes the linker's semantics.
@end defmac
+@deftypevr {Common Target Hook} bool TARGET_ALWAYS_STRIP_DOTDOT
+True if @file{..} components should always be removed from directory names
computed relative to GCC's internal directories, false (default) if such
components should be preserved and directory names containing them passed to
other tools such as the linker.
+@end deftypevr
+
@defmac MULTILIB_DEFAULTS
Define this macro as a C expression for the initializer of an array of
string to tell the driver program which options are defaults for this
@@ -524,7 +546,7 @@
@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
@@ -532,16 +554,16 @@
@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
@@ -561,21 +583,21 @@
@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
@@ -656,7 +678,7 @@
any target-specific headers.
@end deftypevar
-@deftypevr {Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
+@deftypevr {Common Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
This variable specifies the initial value of @code{target_flags}.
Its default setting is 0.
@end deftypevr
@@ -664,24 +686,21 @@
@cindex optional hardware or system features
@cindex features, optional, in system conventions
-@deftypefn {Target Hook} bool TARGET_HANDLE_OPTION (size_t @var{code}, const
char *@var{arg}, int @var{value})
+@deftypefn {Common Target Hook} bool TARGET_HANDLE_OPTION (struct gcc_options
*@var{opts}, struct gcc_options *@var{opts_set}, const struct cl_decoded_option
*@var{decoded}, location_t @var{loc})
This hook is called whenever the user specifies one of the
target-specific options described by the @file{.opt} definition files
(@pxref{Options}). It has the opportunity to do some option-specific
processing and should return true if the option is valid. The default
definition does nothing but return true.
-@var{code} specifies the @code{OPT_@var{name}} enumeration value
-associated with the selected option; @var{name} is just a rendering of
-the option name in which non-alphanumeric characters are replaced by
-underscores. @var{arg} specifies the string argument and is null if
-no argument was given. If the option is flagged as a @code{UInteger}
-(@pxref{Option properties}), @var{value} is the numeric value of the
-argument. Otherwise @var{value} is 1 if the positive form of the
-option was used and 0 if the ``no-'' form was.
+@var{decoded} specifies the option and its arguments. @var{opts} and
+@var{opts_set} are the @code{gcc_options} structures to be used for
+storing option state, and @var{loc} is the location at which the
+option was passed (@code{UNKNOWN_LOCATION} except for options passed
+via attributes).
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_HANDLE_C_OPTION (size_t @var{code}, const
char *@var{arg}, int @var{value})
+@deftypefn {C Target Hook} bool TARGET_HANDLE_C_OPTION (size_t @var{code},
const char *@var{arg}, int @var{value})
This target hook is called whenever the user specifies one of the
target-specific C language family options described by the @file{.opt}
definition files(@pxref{Options}). It has the opportunity to do some
@@ -695,34 +714,18 @@
should use @code{TARGET_HANDLE_C_OPTION} instead.
@end deftypefn
-@deftypefn {Target Hook} tree TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree
@var{string})
+@deftypefn {C Target Hook} tree TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree
@var{string})
Targets may provide a string object type that can be used within and between
C, C++ and their respective Objective-C dialects. A string object might, for
example, embed encoding and length information. These objects are considered
opaque to the compiler and handled as references. An ideal implementation makes
the composition of the string object match that of the Objective-C
@code{NSString} (@code{NXString} for GNUStep), allowing efficient interworking
between C-only and Objective-C code. If a target implements string objects then
this hook should return a reference to such an object constructed from the
normal `C' string representation provided in @var{string}. At present, the hook
is used by Objective-C only, to obtain a common-format string object when the
target provides one.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_STRING_OBJECT_REF_TYPE_P (const_tree
@var{stringref})
+@deftypefn {C Target Hook} bool TARGET_STRING_OBJECT_REF_TYPE_P (const_tree
@var{stringref})
If a target implements string objects then this hook should return @code{true}
if @var{stringref} is a valid reference to such an object.
@end deftypefn
-@deftypefn {Target Hook} void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree
@var{format_arg}, tree @var{args_list})
+@deftypefn {C Target Hook} void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree
@var{format_arg}, tree @var{args_list})
If a target implements string objects then this hook should should provide a
facility to check the function arguments in @var{args_list} against the format
specifiers in @var{format_arg} where the type of @var{format_arg} is one
recognized as a valid string reference type.
@end deftypefn
-@defmac TARGET_VERSION
-This macro is a C statement to print on @code{stderr} a string
-describing the particular machine description choice. Every machine
-description should define @code{TARGET_VERSION}. For example:
-
-@smallexample
-#ifdef MOTOROLA
-#define TARGET_VERSION \
- fprintf (stderr, " (68k, Motorola syntax)");
-#else
-#define TARGET_VERSION \
- fprintf (stderr, " (68k, MIT syntax)");
-#endif
-@end smallexample
-@end defmac
-
@deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
but is called when the optimize level is changed via an attribute or
@@ -741,7 +744,7 @@
frontends.
@end defmac
-@deftypevr {Target Hook} {const struct default_options *}
TARGET_OPTION_OPTIMIZATION_TABLE
+@deftypevr {Common Target Hook} {const struct default_options *}
TARGET_OPTION_OPTIMIZATION_TABLE
Some machines may desire to change what optimizations are performed for
various optimization levels. This variable, if defined, describes
options to enable at particular sets of optimization levels. These
@@ -755,21 +758,14 @@
@code{optimize} attribute.
@end deftypevr
-@deftypefn {Target Hook} void TARGET_OPTION_INIT_STRUCT (struct gcc_options
*@var{opts})
+@deftypefn {Common Target Hook} void TARGET_OPTION_INIT_STRUCT (struct
gcc_options *@var{opts})
Set target-dependent initial values of fields in @var{opts}.
@end deftypefn
-@deftypefn {Target Hook} void TARGET_OPTION_DEFAULT_PARAMS (void)
+@deftypefn {Common Target Hook} void TARGET_OPTION_DEFAULT_PARAMS (void)
Set target-dependent default values for @option{--param} settings, using calls
to @code{set_default_param_value}.
@end deftypefn
-@deftypefn {Target Hook} void TARGET_HELP (void)
-This hook is called in response to the user invoking
-@option{--target-help} on the command line. It gives the target a
-chance to display extra information on the target specific command
-line options found in its @file{.opt} file.
-@end deftypefn
-
@defmac SWITCHABLE_TARGET
Some targets need to switch between substantially different subtargets
during compilation. For example, the MIPS target has one subtarget for
@@ -874,11 +870,18 @@
@defmac WORDS_BIG_ENDIAN
Define this macro to have the value 1 if, in a multiword object, the
most significant word has the lowest number. This applies to both
-memory locations and registers; GCC fundamentally assumes that the
-order of words in memory is the same as the order in registers. This
+memory locations and registers; see @code{REG_WORDS_BIG_ENDIAN} if the
+order of words in memory is not the same as the order in registers. This
macro need not be a constant.
@end defmac
+@defmac REG_WORDS_BIG_ENDIAN
+On some machines, the order of words in a multiword object differs between
+registers in memory. In such a situation, define this macro to describe
+the order of words in a register. The macro @code{WORDS_BIG_ENDIAN} controls
+the order of words in memory.
+@end defmac
+
@defmac FLOAT_WORDS_BIG_ENDIAN
Define this macro to have the value 1 if @code{DFmode}, @code{XFmode} or
@code{TFmode} floating point numbers are stored in memory with the word
@@ -973,6 +976,8 @@
then the hook should return the same mode as @code{promote_mode}, though
the signedness may be different.
+@var{type} can be NULL when promoting function arguments of libcalls.
+
The default is to not promote arguments and return values. You can
also define the hook to @code{default_promote_function_mode_always_promote}
if you would like to apply the same rules given by @code{PROMOTE_MODE}.
@@ -1590,6 +1595,15 @@
is 128 then the default is 1, otherwise it is 0.
@end defmac
+@defmac LIBGCC2_GNU_PREFIX
+This macro corresponds to the @code{TARGET_LIBFUNC_GNU_PREFIX} target
+hook and should be defined if that hook is overriden to be true. It
+causes function names in libgcc to be changed to use a @code{__gnu_}
+prefix for their name rather than the default @code{__}. A port which
+uses this macro should also arrange to use @file{t-gnu-prefix} in
+the libgcc @file{config.host}.
+@end defmac
+
@defmac SF_SIZE
@defmacx DF_SIZE
@defmacx XF_SIZE
@@ -2337,13 +2351,19 @@
You can define such letters to correspond to various classes, then use
them in operand constraints.
+You must define the narrowest register classes for allocatable
+registers, so that each class either has no subclasses, or that for
+some mode, the move cost between registers within the class is
+cheaper than moving a register in the class to or from memory
+(@pxref{Costs}).
+
You should define a class for the union of two classes whenever some
instruction allows both classes. For example, if an instruction allows
either a floating point (coprocessor) register or a general register for a
certain operand, you should define a class @code{FLOAT_OR_GENERAL_REGS}
which includes both of them. Otherwise you will get suboptimal code,
or even internal compiler errors when reload cannot find a register in the
-the class computed via @code{reg_class_subunion}.
+class computed via @code{reg_class_subunion}.
You must also specify certain redundant information about the register
classes: for each class, which classes contain it and which ones are
@@ -2533,7 +2553,7 @@
register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
-@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
+@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
@@ -2570,8 +2590,8 @@
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
-@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
-of using @code{PREFERRED_RELOAD_CLASS}.
+@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
+of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
through the alternatives and call repeatedly @code{PREFERRED_RELOAD_CLASS}
@@ -2581,15 +2601,6 @@
the SSE registers (and vice versa).
@end defmac
-@defmac PREFERRED_OUTPUT_RELOAD_CLASS (@var{x}, @var{class})
-Like @code{PREFERRED_RELOAD_CLASS}, but for output reloads instead of
-input reloads. If you don't define this macro, the default is to use
-@var{class}, unchanged.
-
-You can also use @code{PREFERRED_OUTPUT_RELOAD_CLASS} to discourage
-reload from using some alternatives, like @code{PREFERRED_RELOAD_CLASS}.
-@end defmac
-
@deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_OUTPUT_RELOAD_CLASS (rtx
@var{x}, reg_class_t @var{rclass})
Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of
input reloads.
@@ -2826,6 +2837,23 @@
allocation.
@end deftypefn
+@deftypefn {Target Hook} {unsigned char} TARGET_CLASS_MAX_NREGS (reg_class_t
@var{rclass}, enum machine_mode @var{mode})
+A target hook returns the maximum number of consecutive registers
+of class @var{rclass} needed to hold a value of mode @var{mode}.
+
+This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact,
+the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass},
+@var{mode})} target hook should be the maximum value of
+@code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}
+values in the class @var{rclass}.
+
+This target hook helps control the handling of multiple-word values
+in the reload pass.
+
+The default version of this target hook returns the size of @var{mode}
+in words.
+@end deftypefn
+
@defmac CLASS_MAX_NREGS (@var{class}, @var{mode})
A C expression for the maximum number of consecutive registers
of class @var{class} needed to hold a value of mode @var{mode}.
@@ -2857,36 +2885,6 @@
@end smallexample
@end defmac
-@deftypefn {Target Hook} {const reg_class_t *} TARGET_IRA_COVER_CLASSES (void)
-Return an array of cover classes for the Integrated Register Allocator
-(@acronym{IRA}). Cover classes are a set of non-intersecting register
-classes covering all hard registers used for register allocation
-purposes. If a move between two registers in the same cover class is
-possible, it should be cheaper than a load or store of the registers.
-The array is terminated by a @code{LIM_REG_CLASSES} element.
-
-The order of cover classes in the array is important. If two classes
-have the same cost of usage for a pseudo, the class occurred first in
-the array is chosen for the pseudo.
-
-This hook is called once at compiler startup, after the command-line
-options have been processed. It is then re-examined by every call to
-@code{target_reinit}.
-
-The default implementation returns @code{IRA_COVER_CLASSES}, if defined,
-otherwise there is no default implementation. You must define either this
-macro or @code{IRA_COVER_CLASSES} in order to use the integrated register
-allocator with Chaitin-Briggs coloring. If the macro is not defined,
-the only available coloring algorithm is Chow's priority coloring.
-
-This hook must not be modified from @code{NULL} to non-@code{NULL} or
-vice versa by command-line option processing.
-@end deftypefn
-
-@defmac IRA_COVER_CLASSES
-See the documentation for @code{TARGET_IRA_COVER_CLASSES}.
-@end defmac
-
@node Old Constraints
@section Obsolete Macros for Defining Constraints
@cindex defining constraints, obsolete method
@@ -3403,11 +3401,6 @@
to be emitted.
@end defmac
-@defmac MD_UNWIND_SUPPORT
-A string specifying a file to be #include'd in unwind-dw2.c. The file
-so included typically defines @code{MD_FALLBACK_FRAME_STATE_FOR}.
-@end defmac
-
@defmac MD_FALLBACK_FRAME_STATE_FOR (@var{context}, @var{fs})
This macro allows the target to add CPU and operating system specific
code to the call-frame unwinder for use when there is no unwind data
@@ -3723,6 +3716,24 @@
@end defmac
+@defmac REG_VALUE_IN_UNWIND_CONTEXT
+
+Define this macro if the target stores register values as
+@code{_Unwind_Word} type in unwind context. It should be defined if
+target register size is larger than the size of @code{void *}. The
+default is to store register values as @code{void *} type.
+
+@end defmac
+
+@defmac ASSUME_EXTENDED_UNWIND_CONTEXT
+
+Define this macro to be 1 if the target always uses extended unwind
+context with version, args_size and by_value fields. If it is undefined,
+it will be defined to 1 when @code{REG_VALUE_IN_UNWIND_CONTEXT} is
+defined and 0 otherwise.
+
+@end defmac
+
@node Elimination
@subsection Eliminating Frame Pointer and Arg Pointer
@@ -3983,26 +3994,23 @@
types of arguments are passed in registers or how they are arranged in
the stack.
-@defmac FUNCTION_ARG (@var{cum}, @var{mode}, @var{type}, @var{named})
-A C expression that controls whether a function argument is passed
-in a register, and which register.
+@deftypefn {Target Hook} rtx TARGET_FUNCTION_ARG (cumulative_args_t @var{ca},
enum machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
+Return an RTX indicating whether a function argument is passed in a
+register and if so, which register.
-The arguments are @var{cum}, which summarizes all the previous
+The arguments are @var{ca}, which summarizes all the previous
arguments; @var{mode}, the machine mode of the argument; @var{type},
the data type of the argument as a tree node or 0 if that is not known
(which happens for C support library functions); and @var{named},
-which is 1 for an ordinary argument and 0 for nameless arguments that
-correspond to @samp{@dots{}} in the called function's prototype.
-@var{type} can be an incomplete type if a syntax error has previously
-occurred.
+which is @code{true} for an ordinary argument and @code{false} for
+nameless arguments that correspond to @samp{@dots{}} in the called
+function's prototype. @var{type} can be an incomplete type if a
+syntax error has previously occurred.
-The value of the expression is usually either a @code{reg} RTX for the
-hard register in which to pass the argument, or zero to pass the
-argument on the stack.
+The return value is usually either a @code{reg} RTX for the hard
+register in which to pass the argument, or zero to pass the argument
+on the stack.
-For machines like the VAX and 68000, where normally all arguments are
-pushed, zero suffices as a definition.
-
The value of the expression can also be a @code{parallel} RTX@. This is
used when an argument is passed in multiple locations. The mode of the
@code{parallel} should be the mode of the entire argument. The
@@ -4017,26 +4025,27 @@
RTX may have a first operand of zero. This indicates that the entire
argument is also stored on the stack.
-The last time this macro is called, it is called with @code{MODE ==
+The last time this hook is called, it is called with @code{MODE ==
VOIDmode}, and its result is passed to the @code{call} or @code{call_value}
pattern as operands 2 and 3 respectively.
@cindex @file{stdarg.h} and register arguments
-The usual way to make the ISO library @file{stdarg.h} work on a machine
-where some arguments are usually passed in registers, is to cause
-nameless arguments to be passed on the stack instead. This is done
-by making @code{FUNCTION_ARG} return 0 whenever @var{named} is 0.
+The usual way to make the ISO library @file{stdarg.h} work on a
+machine where some arguments are usually passed in registers, is to
+cause nameless arguments to be passed on the stack instead. This is
+done by making @code{TARGET_FUNCTION_ARG} return 0 whenever
+@var{named} is @code{false}.
-@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{FUNCTION_ARG}
-@cindex @code{REG_PARM_STACK_SPACE}, and @code{FUNCTION_ARG}
+@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG}
+@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG}
You may use the hook @code{targetm.calls.must_pass_in_stack}
in the definition of this macro to determine if this argument is of a
type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE}
-is not defined and @code{FUNCTION_ARG} returns nonzero for such an
+is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an
argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is
defined, the argument will be computed in the stack and then loaded into
a register.
-@end defmac
+@end deftypefn
@deftypefn {Target Hook} bool TARGET_MUST_PASS_IN_STACK (enum machine_mode
@var{mode}, const_tree @var{type})
This target hook should return @code{true} if we should not pass @var{type}
@@ -4045,22 +4054,23 @@
documentation.
@end deftypefn
-@defmac FUNCTION_INCOMING_ARG (@var{cum}, @var{mode}, @var{type}, @var{named})
-Define this macro if the target machine has ``register windows'', so
+@deftypefn {Target Hook} rtx TARGET_FUNCTION_INCOMING_ARG (cumulative_args_t
@var{ca}, enum machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
+Define this hook if the target machine has ``register windows'', so
that the register in which a function sees an arguments is not
necessarily the same as the one in which the caller passed the
argument.
-For such machines, @code{FUNCTION_ARG} computes the register in which
-the caller passes the value, and @code{FUNCTION_INCOMING_ARG} should
-be defined in a similar fashion to tell the function being called
-where the arguments will arrive.
+For such machines, @code{TARGET_FUNCTION_ARG} computes the register in
+which the caller passes the value, and
+@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar
+fashion to tell the function being called where the arguments will
+arrive.
-If @code{FUNCTION_INCOMING_ARG} is not defined, @code{FUNCTION_ARG}
-serves both purposes.
-@end defmac
+If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,
+@code{TARGET_FUNCTION_ARG} serves both purposes.
+@end deftypefn
-@deftypefn {Target Hook} int TARGET_ARG_PARTIAL_BYTES (CUMULATIVE_ARGS
*@var{cum}, enum machine_mode @var{mode}, tree @var{type}, bool @var{named})
+@deftypefn {Target Hook} int TARGET_ARG_PARTIAL_BYTES (cumulative_args_t
@var{cum}, enum machine_mode @var{mode}, tree @var{type}, bool @var{named})
This target hook returns the number of bytes at the beginning of an
argument that must be put in registers. The value must be zero for
arguments that are passed entirely in registers or that are entirely
@@ -4074,12 +4084,12 @@
in registers and the rest must be pushed. This macro tells the
compiler when this occurs, and how many bytes should go in registers.
-@code{FUNCTION_ARG} for these arguments should return the first
+@code{TARGET_FUNCTION_ARG} for these arguments should return the first
register to be used by the caller for this argument; likewise
-@code{FUNCTION_INCOMING_ARG}, for the called function.
+@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_PASS_BY_REFERENCE (CUMULATIVE_ARGS
*@var{cum}, enum machine_mode @var{mode}, const_tree @var{type}, bool
@var{named})
+@deftypefn {Target Hook} bool TARGET_PASS_BY_REFERENCE (cumulative_args_t
@var{cum}, enum machine_mode @var{mode}, const_tree @var{type}, bool
@var{named})
This target hook should return @code{true} if an argument at the
position indicated by @var{cum} should be passed by reference. This
predicate is queried after target independent reasons for being
@@ -4091,7 +4101,7 @@
to that type.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_CALLEE_COPIES (CUMULATIVE_ARGS
*@var{cum}, enum machine_mode @var{mode}, const_tree @var{type}, bool
@var{named})
+@deftypefn {Target Hook} bool TARGET_CALLEE_COPIES (cumulative_args_t
@var{cum}, enum machine_mode @var{mode}, const_tree @var{type}, bool
@var{named})
The function argument described by the parameters to this hook is
known to be passed by reference. The hook should return true if the
function argument should be copied by the callee instead of copied
@@ -4105,10 +4115,10 @@
@end deftypefn
@defmac CUMULATIVE_ARGS
-A C type for declaring a variable that is used as the first argument of
-@code{FUNCTION_ARG} and other related values. For some target machines,
-the type @code{int} suffices and can hold the number of bytes of
-argument so far.
+A C type for declaring a variable that is used as the first argument
+of @code{TARGET_FUNCTION_ARG} and other related values. For some
+target machines, the type @code{int} suffices and can hold the number
+of bytes of argument so far.
There is no need to record in @code{CUMULATIVE_ARGS} anything about the
arguments that have been passed on the stack. The compiler has other
@@ -4170,17 +4180,17 @@
@c --mew 5feb93 i switched the order of the sentences. --mew 10feb93
@end defmac
-@defmac FUNCTION_ARG_ADVANCE (@var{cum}, @var{mode}, @var{type}, @var{named})
-A C statement (sans semicolon) to update the summarizer variable
-@var{cum} to advance past an argument in the argument list. The
-values @var{mode}, @var{type} and @var{named} describe that argument.
-Once this is done, the variable @var{cum} is suitable for analyzing
-the @emph{following} argument with @code{FUNCTION_ARG}, etc.
+@deftypefn {Target Hook} void TARGET_FUNCTION_ARG_ADVANCE (cumulative_args_t
@var{ca}, enum machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
+This hook updates the summarizer variable pointed to by @var{ca} to
+advance past an argument in the argument list. The values @var{mode},
+@var{type} and @var{named} describe that argument. Once this is done,
+the variable @var{cum} is suitable for analyzing the @emph{following}
+argument with @code{TARGET_FUNCTION_ARG}, etc.
-This macro need not do anything if the argument in question was passed
+This hook need not do anything if the argument in question was passed
on the stack. The compiler knows how to track the amount of stack space
used for arguments without any special help.
-@end defmac
+@end deftypefn
@defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type})
If defined, a C expression that is the number of bytes to add to the
@@ -4196,9 +4206,9 @@
@code{enum direction}: either @code{upward} to pad above the argument,
@code{downward} to pad below, or @code{none} to inhibit padding.
-The @emph{amount} of padding is always just enough to reach the next
-multiple of @code{TARGET_FUNCTION_ARG_BOUNDARY}; this macro does not
-control it.
+The @emph{amount} of padding is not controlled by this macro, but by the
+target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is
+always just enough to reach the next multiple of that boundary.
This macro has a default definition which is right for most systems.
For little-endian machines, the default is to pad upward. For
@@ -4231,6 +4241,13 @@
@code{PARM_BOUNDARY} for all arguments.
@end deftypefn
+@deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_ROUND_BOUNDARY
(enum machine_mode @var{mode}, const_tree @var{type})
+Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},
+which is the default value for this hook. You can define this hook to
+return a different value if an argument size must be rounded to a larger
+value.
+@end deftypefn
+
@defmac FUNCTION_ARG_REGNO_P (@var{regno})
A C expression that is nonzero if @var{regno} is the number of a hard
register in which function arguments are sometimes passed. This does
@@ -4319,6 +4336,34 @@
must have move patterns for this mode.
@end deftypefn
+@deftypefn {Target Hook} bool TARGET_ARRAY_MODE_SUPPORTED_P (enum machine_mode
@var{mode}, unsigned HOST_WIDE_INT @var{nelems})
+Return true if GCC should try to use a scalar mode to store an array
+of @var{nelems} elements, given that each element has mode @var{mode}.
+Returning true here overrides the usual @code{MAX_FIXED_MODE} limit
+and allows GCC to use any defined integer mode.
+
+One use of this hook is to support vector load and store operations
+that operate on several homogeneous vectors. For example, ARM NEON
+has operations like:
+
+@smallexample
+int8x8x3_t vld3_s8 (const int8_t *)
+@end smallexample
+
+where the return type is defined as:
+
+@smallexample
+typedef struct int8x8x3_t
+@{
+ int8x8_t val[3];
+@} int8x8x3_t;
+@end smallexample
+
+If this hook allows @code{val} to have a scalar mode, then
+@code{int8x8x3_t} can have the same mode. GCC can then store
+@code{int8x8x3_t}s in registers rather than forcing them onto the stack.
+@end deftypefn
+
@deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (enum
machine_mode @var{mode})
Define this to return nonzero for machine modes for which the port has
small register classes. If this target hook returns nonzero for a given
@@ -4380,7 +4425,7 @@
place regardless of mode.) The value of the expression is usually a
@code{reg} RTX for the hard register where the return value is stored.
The value can also be a @code{parallel} RTX, if the return value is in
-multiple places. See @code{FUNCTION_ARG} for an explanation of the
+multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the
@code{parallel} form. Note that the callee will populate every
location specified in the @code{parallel}, but if the first element of
the @code{parallel} contains the whole return value, callers will use
@@ -4425,10 +4470,10 @@
@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.
@@ -4953,7 +4998,7 @@
normally defined in @file{libgcc2.c}.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_SUPPORTS_SPLIT_STACK (bool @var{report},
struct gcc_options *@var{opts})
+@deftypefn {Common Target Hook} bool TARGET_SUPPORTS_SPLIT_STACK (bool
@var{report}, struct gcc_options *@var{opts})
Whether this target supports splitting the stack when the options described in
@var{opts} have been passed. This is called after options have been parsed, so
the target may reject splitting the stack in some configurations. The default
version of this hook returns false. If @var{report} is true, this function may
issue a warning or error; if @var{report} is false, it must simply return a
value
@end deftypefn
@@ -5033,7 +5078,7 @@
to use as the return of @code{__builtin_saveregs}.
@end deftypefn
-@deftypefn {Target Hook} void TARGET_SETUP_INCOMING_VARARGS (CUMULATIVE_ARGS
*@var{args_so_far}, enum machine_mode @var{mode}, tree @var{type}, int
*@var{pretend_args_size}, int @var{second_time})
+@deftypefn {Target Hook} void TARGET_SETUP_INCOMING_VARARGS (cumulative_args_t
@var{args_so_far}, enum machine_mode @var{mode}, tree @var{type}, int
*@var{pretend_args_size}, int @var{second_time})
This target hook offers an alternative to using
@code{__builtin_saveregs} and defining the hook
@code{TARGET_EXPAND_BUILTIN_SAVEREGS}. Use it to store the anonymous
@@ -5067,11 +5112,11 @@
not generate any instructions in this case.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_STRICT_ARGUMENT_NAMING (CUMULATIVE_ARGS
*@var{ca})
+@deftypefn {Target Hook} bool TARGET_STRICT_ARGUMENT_NAMING (cumulative_args_t
@var{ca})
Define this hook to return @code{true} if the location where a function
argument is passed depends on whether or not it is a named argument.
-This hook controls how the @var{named} argument to @code{FUNCTION_ARG}
+This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}
is set for varargs and stdarg functions. If this hook returns
@code{true}, the @var{named} argument is always true for named
arguments, and false for unnamed arguments. If it returns @code{false},
@@ -5082,7 +5127,7 @@
You need not define this hook if it always returns @code{false}.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED
(CUMULATIVE_ARGS *@var{ca})
+@deftypefn {Target Hook} bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED
(cumulative_args_t @var{ca})
If you need to conditionally change ABIs so that one works with
@code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither
@code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING}
was
@@ -5157,12 +5202,12 @@
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
@@ -5197,19 +5242,6 @@
@var{end} are both pointer expressions.
@end defmac
-The operating system may also require the stack to be made executable
-before calling the trampoline. To implement this requirement, define
-the following macro.
-
-@defmac ENABLE_EXECUTE_STACK
-Define this macro if certain operations must be performed before executing
-code located on the stack. The macro should expand to a series of C
-file-scope constructs (e.g.@: functions) and provide a unique entry point
-named @code{__enable_execute_stack}. The target is responsible for
-emitting calls to the entry point in the code, for example from the
-@code{TARGET_TRAMPOLINE_INIT} hook.
-@end defmac
-
To use a standard subroutine, define the following macro. In addition,
you must make sure that the instructions in a trampoline fill an entire
cache line with identical instructions, or else ensure that the
@@ -5257,6 +5289,15 @@
The default is to do nothing. Most ports don't need to define this hook.
@end deftypefn
+@deftypevr {Target Hook} bool TARGET_LIBFUNC_GNU_PREFIX
+If false (the default), internal library routines start with two
+underscores. If set to true, these routines start with @code{__gnu_}
+instead. E.g., @code{__muldi3} changes to @code{__gnu_muldi3}. This
+currently only affects functions defined in @file{libgcc2.c}. If this
+is set to true, the @file{tm.h} file must also
+@code{#define LIBGCC2_GNU_PREFIX}.
+@end deftypevr
+
@defmac FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
This macro should return @code{true} if the library routine that
implements the floating point comparison operator @var{comparison} in
@@ -5366,7 +5407,7 @@
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})
@@ -5577,14 +5618,14 @@
@code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
@end defmac
-@defmac LEGITIMATE_CONSTANT_P (@var{x})
-A C expression that is nonzero if @var{x} is a legitimate constant for
-an immediate operand on the target machine. You can assume that
-@var{x} satisfies @code{CONSTANT_P}, so you need not check this. In fact,
-@samp{1} is a suitable definition for this macro on machines where
-anything @code{CONSTANT_P} is valid.
-@end defmac
+@deftypefn {Target Hook} bool TARGET_LEGITIMATE_CONSTANT_P (enum machine_mode
@var{mode}, rtx @var{x})
+This hook returns true if @var{x} is a legitimate constant for a
+@var{mode}-mode immediate operand on the target machine. You can assume that
+@var{x} satisfies @code{CONSTANT_P}, so you need not check this.
+The default definition returns true.
+@end deftypefn
+
@deftypefn {Target Hook} rtx TARGET_DELEGITIMIZE_ADDRESS (rtx @var{x})
This hook is used to undo the possibly obfuscating effects of the
@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target
@@ -5595,11 +5636,13 @@
into their original form.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_CANNOT_FORCE_CONST_MEM (rtx @var{x})
+@deftypefn {Target Hook} bool TARGET_CANNOT_FORCE_CONST_MEM (enum machine_mode
@var{mode}, rtx @var{x})
This hook should return true if @var{x} is of a form that cannot (or
-should not) be spilled to the constant pool. The default version of
-this hook returns false.
+should not) be spilled to the constant pool. @var{mode} is the mode
+of @var{x}.
+The default version of this hook returns false.
+
The primary reason to define this hook is to prevent reload from
deciding that a non-legitimate constant would be better reloaded
from the constant pool instead of spilling and reloading a register
@@ -5678,7 +5721,7 @@
@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
@@ -6276,7 +6319,7 @@
@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.
@@ -6288,8 +6331,8 @@
@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}.
@@ -6363,15 +6406,20 @@
@code{BRANCH_COST} is greater than or equal to the value 2.
@end defmac
-@deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, int @var{code},
int @var{outer_code}, int *@var{total}, bool @var{speed})
+@deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, int @var{code},
int @var{outer_code}, int @var{opno}, int *@var{total}, bool @var{speed})
This target hook describes the relative costs of RTL expressions.
The cost may depend on the precise form of the expression, which is
-available for examination in @var{x}, and the rtx code of the expression
-in which it is contained, found in @var{outer_code}. @var{code} is the
-expression code---redundant, since it can be obtained with
-@code{GET_CODE (@var{x})}.
+available for examination in @var{x}, and the fact that @var{x} appears
+as operand @var{opno} of an expression with rtx code @var{outer_code}.
+That is, the hook can assume that there is some rtx @var{y} such
+that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that
+either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or
+(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}.
+@var{code} is @var{x}'s expression code---redundant, since it can be
+obtained with @code{GET_CODE (@var{x})}.
+
In implementing this hook, you can use the construct
@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast
instructions.
@@ -6786,6 +6834,17 @@
in its second parameter.
@end deftypefn
+@deftypevr {Target Hook} bool TARGET_SCHED_EXPOSED_PIPELINE
+True if the processor has an exposed pipeline, which means that not just
+the order of instructions is important for correctness when scheduling, but
+also the latencies of operations.
+@end deftypevr
+
+@deftypefn {Target Hook} int TARGET_SCHED_REASSOCIATION_WIDTH (unsigned int
@var{opc}, enum machine_mode @var{mode})
+This hook is called by tree reassociator to determine a level of
+parallelism required in output calculations chain.
+@end deftypefn
+
@node Sections
@section Dividing the Output into Sections (Texts, Data, @dots{})
@c the above section title is WAY too long. maybe cut the part between
@@ -6863,8 +6922,8 @@
@defmac BSS_SECTION_ASM_OP
If defined, a C expression whose value is a string, including spacing,
containing the assembler operation to identify the following data as
-uninitialized global data. If not defined, and neither
-@code{ASM_OUTPUT_BSS} nor @code{ASM_OUTPUT_ALIGNED_BSS} are defined,
+uninitialized global data. If not defined, and
+@code{ASM_OUTPUT_ALIGNED_BSS} not defined,
uninitialized global data will be output in the data section if
@option{-fno-common} is passed, otherwise @code{ASM_OUTPUT_COMMON} will be
used.
@@ -7027,6 +7086,12 @@
otherwise.
@end deftypefn
+@deftypevr {Target Hook} {const char *} TARGET_ASM_MERGEABLE_RODATA_PREFIX
+Usually, the compiler uses the prefix @code{".rodata"} to construct
+section names for mergeable constant data. Define this macro to override
+the string if a different section name should be used.
+@end deftypevr
+
@deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_RTX_SECTION (enum
machine_mode @var{mode}, rtx @var{x}, unsigned HOST_WIDE_INT @var{align})
Return the section into which a constant @var{x}, of mode @var{mode},
should be placed. You can assume that @var{x} is some kind of
@@ -7140,7 +7205,7 @@
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
@@ -7328,7 +7393,7 @@
@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).
@@ -7339,7 +7404,7 @@
Used by the target to emit any assembler directives or additional labels
needed when a function is partitioned between different sections. Output
should be written to @var{file}. The function decl is available as @var{decl}
and the new section is `cold' if @var{new_is_cold} is @code{true}.
@end deftypefn
-@deftypevr {Target Hook} bool TARGET_HAVE_NAMED_SECTIONS
+@deftypevr {Common Target Hook} bool TARGET_HAVE_NAMED_SECTIONS
This flag is true if the target supports @code{TARGET_ASM_NAMED_SECTION}.
It must not be modified by command-line option processing.
@end deftypevr
@@ -7640,20 +7705,19 @@
the variable's decl in order to chose what to output.
@end defmac
-@defmac ASM_OUTPUT_BSS (@var{stream}, @var{decl}, @var{name}, @var{size},
@var{rounded})
+@defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name},
@var{size}, @var{alignment})
A C statement (sans semicolon) to output to the stdio stream
@var{stream} the assembler definition of uninitialized global @var{decl} named
-@var{name} whose size is @var{size} bytes. The variable @var{rounded}
-is the size rounded up to whatever alignment the caller wants.
+@var{name} whose size is @var{size} bytes. The variable @var{alignment}
+is the alignment specified as the number of bits.
-Try to use function @code{asm_output_bss} defined in @file{varasm.c} when
-defining this macro. If unable, use the expression
+Try to use function @code{asm_output_aligned_bss} defined in file
+@file{varasm.c} when defining this macro. If unable, use the expression
@code{assemble_name (@var{stream}, @var{name})} to output the name itself;
before and after that, output the additional assembler syntax for defining
the name, and a newline.
-There are two ways of handling global BSS@. One is to define either
-this macro or its aligned counterpart, @code{ASM_OUTPUT_ALIGNED_BSS}.
+There are two ways of handling global BSS@. One is to define this macro.
The other is to have @code{TARGET_ASM_SELECT_SECTION} return a
switchable BSS section (@pxref{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS}).
You do not need to do both.
@@ -7665,17 +7729,6 @@
common in order to save space in the object file.
@end defmac
-@defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name},
@var{size}, @var{alignment})
-Like @code{ASM_OUTPUT_BSS} except takes the required alignment as a
-separate, explicit argument. If you define this macro, it is used in
-place of @code{ASM_OUTPUT_BSS}, and gives you more flexibility in
-handling the required alignment of the variable. The alignment is specified
-as the number of bits.
-
-Try to use function @code{asm_output_aligned_bss} defined in file
-@file{varasm.c} when defining this macro.
-@end defmac
-
@defmac ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size}, @var{rounded})
A C statement (sans semicolon) to output to the stdio stream
@var{stream} the assembler definition of a local-common-label named
@@ -8866,7 +8919,7 @@
or @code{OBJECT_FORMAT_ELF}), GCC will provide a default definition of 1.
@end defmac
-@deftypefn {Target Hook} {enum unwind_info_type} TARGET_EXCEPT_UNWIND_INFO
(struct gcc_options *@var{opts})
+@deftypefn {Common Target Hook} {enum unwind_info_type}
TARGET_EXCEPT_UNWIND_INFO (struct gcc_options *@var{opts})
This hook defines the mechanism that will be used for exception handling
by the target. If the target has ABI specified unwind tables, the hook
should return @code{UI_TARGET}. If the target is to use the
@@ -8892,7 +8945,7 @@
must define this hook so that @var{opts} is used correctly.
@end deftypefn
-@deftypevr {Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
+@deftypevr {Common Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
This variable should be set to @code{true} if the target ABI requires unwinding
tables even when exceptions are not used. It must not be modified by
command-line option processing.
@@ -9430,6 +9483,14 @@
True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections should
be emitted. These sections are not used on most platforms, and in particular
GDB does not use them.
@end deftypevr
+@deftypevr {Target Hook} bool TARGET_DELAY_SCHED2
+True if sched2 is not to be run at its normal place. This usually means it
will be run as part of machine-specific reorg.
+@end deftypevr
+
+@deftypevr {Target Hook} bool TARGET_DELAY_VARTRACK
+True if vartrack is not to be run at its normal place. This usually means it
will be run as part of machine-specific reorg.
+@end deftypevr
+
@defmac ASM_OUTPUT_DWARF_DELTA (@var{stream}, @var{size}, @var{label1},
@var{label2})
A C statement to issue assembly directives that create a difference
@var{lab1} minus @var{lab2}, using an integer of the given @var{size}.
@@ -10113,6 +10174,10 @@
@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just been
defined. Use this hook to make adjustments to the class (eg, tweak visibility
or perform any other required target modifications).
@end deftypefn
+@deftypefn {Target Hook} tree TARGET_CXX_DECL_MANGLING_CONTEXT (const_tree
@var{decl})
+Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.
+@end deftypefn
+
@node Named Address Spaces
@section Adding support for named address spaces
@cindex named address spaces
@@ -10191,7 +10256,7 @@
except that it includes explicit named address space support.
@end deftypefn
-@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_SUBSET_P (addr_space_t
@var{superset}, addr_space_t @var{subset})
+@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_SUBSET_P (addr_space_t
@var{subset}, addr_space_t @var{superset})
Define this to return whether the @var{subset} named address space is
contained within the @var{superset} named address space. Pointers to
a named address space that is a subset of another named address space
@@ -10555,14 +10620,14 @@
@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.
@@ -10595,7 +10660,7 @@
@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}.
@@ -10871,7 +10936,7 @@
To create a built-in function, call the function
@code{lang_hooks.builtin_function}
which is defined by the language front end. You can use any type nodes set
-up by @code{build_common_tree_nodes} and @code{build_common_tree_nodes_2};
+up by @code{build_common_tree_nodes};
only language front ends that use those two functions will call
@samp{TARGET_INIT_BUILTINS}.
@end deftypefn
@@ -10982,7 +11047,7 @@
@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
@@ -11196,21 +11261,21 @@
@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.
@@ -11218,10 +11283,10 @@
@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
@@ -11239,7 +11304,7 @@
@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
Index: libgcc.texi
===================================================================
--- libgcc.texi (revision 170935)
+++ libgcc.texi (revision 179462)
@@ -502,8 +502,8 @@
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.
Index: tree-ssa.texi
===================================================================
--- tree-ssa.texi (revision 170935)
+++ tree-ssa.texi (revision 179462)
@@ -184,7 +184,7 @@
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
@@ -194,9 +194,9 @@
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
@@ -205,7 +205,7 @@
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
@@ -213,8 +213,8 @@
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
@@ -331,8 +331,8 @@
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
@@ -351,10 +351,10 @@
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
@@ -372,7 +372,7 @@
@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:
@@ -393,18 +393,18 @@
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
@@ -420,15 +420,15 @@
@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
@@ -443,18 +443,18 @@
@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:
@@ -561,7 +561,7 @@
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@.
Index: tm.texi.in
===================================================================
--- tm.texi.in (revision 170935)
+++ tm.texi.in (revision 179462)
@@ -1,5 +1,5 @@
@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,
-@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+@c 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@@ -91,6 +91,24 @@
from being defined in the @file{.h} file to being part of the
@code{targetm} structure.
+Similarly, there is a @code{targetcm} variable for hooks that are
+specific to front ends for C-family languages, documented as ``C
+Target Hook''. This is declared in @file{c-family/c-target.h}, the
+initializer @code{TARGETCM_INITIALIZER} in
+@file{c-family/c-target-def.h}. If targets initialize @code{targetcm}
+themselves, they should set @code{target_has_targetcm=yes} in
+@file{config.gcc}; otherwise a default definition is used.
+
+Similarly, there is a @code{targetm_common} variable for hooks that
+are shared between the compiler driver and the compilers proper,
+documented as ``Common Target Hook''. This is declared in
+@file{common/common-target.h}, the initializer
+@code{TARGETM_COMMON_INITIALIZER} in
+@file{common/common-target-def.h}. If targets initialize
+@code{targetm_common} themselves, they should set
+@code{target_has_targetm_common=yes} in @file{config.gcc}; otherwise a
+default definition is used.
+
@node Driver
@section Controlling the Compilation Driver, @file{gcc}
@cindex driver
@@ -375,6 +393,8 @@
removing duplicate search directories changes the linker's semantics.
@end defmac
+@hook TARGET_ALWAYS_STRIP_DOTDOT
+
@defmac MULTILIB_DEFAULTS
Define this macro as a C expression for the initializer of an array of
string to tell the driver program which options are defaults for this
@@ -524,7 +544,7 @@
@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
@@ -532,16 +552,16 @@
@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
@@ -561,21 +581,21 @@
@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
@@ -671,14 +691,11 @@
processing and should return true if the option is valid. The default
definition does nothing but return true.
-@var{code} specifies the @code{OPT_@var{name}} enumeration value
-associated with the selected option; @var{name} is just a rendering of
-the option name in which non-alphanumeric characters are replaced by
-underscores. @var{arg} specifies the string argument and is null if
-no argument was given. If the option is flagged as a @code{UInteger}
-(@pxref{Option properties}), @var{value} is the numeric value of the
-argument. Otherwise @var{value} is 1 if the positive form of the
-option was used and 0 if the ``no-'' form was.
+@var{decoded} specifies the option and its arguments. @var{opts} and
+@var{opts_set} are the @code{gcc_options} structures to be used for
+storing option state, and @var{loc} is the location at which the
+option was passed (@code{UNKNOWN_LOCATION} except for options passed
+via attributes).
@end deftypefn
@hook TARGET_HANDLE_C_OPTION
@@ -701,22 +718,6 @@
@hook TARGET_CHECK_STRING_OBJECT_FORMAT_ARG
-@defmac TARGET_VERSION
-This macro is a C statement to print on @code{stderr} a string
-describing the particular machine description choice. Every machine
-description should define @code{TARGET_VERSION}. For example:
-
-@smallexample
-#ifdef MOTOROLA
-#define TARGET_VERSION \
- fprintf (stderr, " (68k, Motorola syntax)");
-#else
-#define TARGET_VERSION \
- fprintf (stderr, " (68k, MIT syntax)");
-#endif
-@end smallexample
-@end defmac
-
@hook TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
but is called when the optimize level is changed via an attribute or
@@ -753,13 +754,6 @@
@hook TARGET_OPTION_DEFAULT_PARAMS
-@hook TARGET_HELP
-This hook is called in response to the user invoking
-@option{--target-help} on the command line. It gives the target a
-chance to display extra information on the target specific command
-line options found in its @file{.opt} file.
-@end deftypefn
-
@defmac SWITCHABLE_TARGET
Some targets need to switch between substantially different subtargets
during compilation. For example, the MIPS target has one subtarget for
@@ -864,11 +858,18 @@
@defmac WORDS_BIG_ENDIAN
Define this macro to have the value 1 if, in a multiword object, the
most significant word has the lowest number. This applies to both
-memory locations and registers; GCC fundamentally assumes that the
-order of words in memory is the same as the order in registers. This
+memory locations and registers; see @code{REG_WORDS_BIG_ENDIAN} if the
+order of words in memory is not the same as the order in registers. This
macro need not be a constant.
@end defmac
+@defmac REG_WORDS_BIG_ENDIAN
+On some machines, the order of words in a multiword object differs between
+registers in memory. In such a situation, define this macro to describe
+the order of words in a register. The macro @code{WORDS_BIG_ENDIAN} controls
+the order of words in memory.
+@end defmac
+
@defmac FLOAT_WORDS_BIG_ENDIAN
Define this macro to have the value 1 if @code{DFmode}, @code{XFmode} or
@code{TFmode} floating point numbers are stored in memory with the word
@@ -963,6 +964,8 @@
then the hook should return the same mode as @code{promote_mode}, though
the signedness may be different.
+@var{type} can be NULL when promoting function arguments of libcalls.
+
The default is to not promote arguments and return values. You can
also define the hook to @code{default_promote_function_mode_always_promote}
if you would like to apply the same rules given by @code{PROMOTE_MODE}.
@@ -1580,6 +1583,15 @@
is 128 then the default is 1, otherwise it is 0.
@end defmac
+@defmac LIBGCC2_GNU_PREFIX
+This macro corresponds to the @code{TARGET_LIBFUNC_GNU_PREFIX} target
+hook and should be defined if that hook is overriden to be true. It
+causes function names in libgcc to be changed to use a @code{__gnu_}
+prefix for their name rather than the default @code{__}. A port which
+uses this macro should also arrange to use @file{t-gnu-prefix} in
+the libgcc @file{config.host}.
+@end defmac
+
@defmac SF_SIZE
@defmacx DF_SIZE
@defmacx XF_SIZE
@@ -2327,13 +2339,19 @@
You can define such letters to correspond to various classes, then use
them in operand constraints.
+You must define the narrowest register classes for allocatable
+registers, so that each class either has no subclasses, or that for
+some mode, the move cost between registers within the class is
+cheaper than moving a register in the class to or from memory
+(@pxref{Costs}).
+
You should define a class for the union of two classes whenever some
instruction allows both classes. For example, if an instruction allows
either a floating point (coprocessor) register or a general register for a
certain operand, you should define a class @code{FLOAT_OR_GENERAL_REGS}
which includes both of them. Otherwise you will get suboptimal code,
or even internal compiler errors when reload cannot find a register in the
-the class computed via @code{reg_class_subunion}.
+class computed via @code{reg_class_subunion}.
You must also specify certain redundant information about the register
classes: for each class, which classes contain it and which ones are
@@ -2521,7 +2539,7 @@
register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
-@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
+@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
@@ -2558,8 +2576,8 @@
register, so @code{PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when
@var{x} is a floating-point constant. If the constant can't be loaded
into any kind of register, code generation will be better if
-@code{LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
-of using @code{PREFERRED_RELOAD_CLASS}.
+@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead
+of using @code{TARGET_PREFERRED_RELOAD_CLASS}.
If an insn has pseudos in it after register allocation, reload will go
through the alternatives and call repeatedly @code{PREFERRED_RELOAD_CLASS}
@@ -2569,15 +2587,6 @@
the SSE registers (and vice versa).
@end defmac
-@defmac PREFERRED_OUTPUT_RELOAD_CLASS (@var{x}, @var{class})
-Like @code{PREFERRED_RELOAD_CLASS}, but for output reloads instead of
-input reloads. If you don't define this macro, the default is to use
-@var{class}, unchanged.
-
-You can also use @code{PREFERRED_OUTPUT_RELOAD_CLASS} to discourage
-reload from using some alternatives, like @code{PREFERRED_RELOAD_CLASS}.
-@end defmac
-
@hook TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of
input reloads.
@@ -2814,6 +2823,23 @@
allocation.
@end deftypefn
+@hook TARGET_CLASS_MAX_NREGS
+A target hook returns the maximum number of consecutive registers
+of class @var{rclass} needed to hold a value of mode @var{mode}.
+
+This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact,
+the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass},
+@var{mode})} target hook should be the maximum value of
+@code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}
+values in the class @var{rclass}.
+
+This target hook helps control the handling of multiple-word values
+in the reload pass.
+
+The default version of this target hook returns the size of @var{mode}
+in words.
+@end deftypefn
+
@defmac CLASS_MAX_NREGS (@var{class}, @var{mode})
A C expression for the maximum number of consecutive registers
of class @var{class} needed to hold a value of mode @var{mode}.
@@ -2845,36 +2871,6 @@
@end smallexample
@end defmac
-@hook TARGET_IRA_COVER_CLASSES
-Return an array of cover classes for the Integrated Register Allocator
-(@acronym{IRA}). Cover classes are a set of non-intersecting register
-classes covering all hard registers used for register allocation
-purposes. If a move between two registers in the same cover class is
-possible, it should be cheaper than a load or store of the registers.
-The array is terminated by a @code{LIM_REG_CLASSES} element.
-
-The order of cover classes in the array is important. If two classes
-have the same cost of usage for a pseudo, the class occurred first in
-the array is chosen for the pseudo.
-
-This hook is called once at compiler startup, after the command-line
-options have been processed. It is then re-examined by every call to
-@code{target_reinit}.
-
-The default implementation returns @code{IRA_COVER_CLASSES}, if defined,
-otherwise there is no default implementation. You must define either this
-macro or @code{IRA_COVER_CLASSES} in order to use the integrated register
-allocator with Chaitin-Briggs coloring. If the macro is not defined,
-the only available coloring algorithm is Chow's priority coloring.
-
-This hook must not be modified from @code{NULL} to non-@code{NULL} or
-vice versa by command-line option processing.
-@end deftypefn
-
-@defmac IRA_COVER_CLASSES
-See the documentation for @code{TARGET_IRA_COVER_CLASSES}.
-@end defmac
-
@node Old Constraints
@section Obsolete Macros for Defining Constraints
@cindex defining constraints, obsolete method
@@ -3391,11 +3387,6 @@
to be emitted.
@end defmac
-@defmac MD_UNWIND_SUPPORT
-A string specifying a file to be #include'd in unwind-dw2.c. The file
-so included typically defines @code{MD_FALLBACK_FRAME_STATE_FOR}.
-@end defmac
-
@defmac MD_FALLBACK_FRAME_STATE_FOR (@var{context}, @var{fs})
This macro allows the target to add CPU and operating system specific
code to the call-frame unwinder for use when there is no unwind data
@@ -3711,6 +3702,24 @@
@end defmac
+@defmac REG_VALUE_IN_UNWIND_CONTEXT
+
+Define this macro if the target stores register values as
+@code{_Unwind_Word} type in unwind context. It should be defined if
+target register size is larger than the size of @code{void *}. The
+default is to store register values as @code{void *} type.
+
+@end defmac
+
+@defmac ASSUME_EXTENDED_UNWIND_CONTEXT
+
+Define this macro to be 1 if the target always uses extended unwind
+context with version, args_size and by_value fields. If it is undefined,
+it will be defined to 1 when @code{REG_VALUE_IN_UNWIND_CONTEXT} is
+defined and 0 otherwise.
+
+@end defmac
+
@node Elimination
@subsection Eliminating Frame Pointer and Arg Pointer
@@ -3971,26 +3980,23 @@
types of arguments are passed in registers or how they are arranged in
the stack.
-@defmac FUNCTION_ARG (@var{cum}, @var{mode}, @var{type}, @var{named})
-A C expression that controls whether a function argument is passed
-in a register, and which register.
+@hook TARGET_FUNCTION_ARG
+Return an RTX indicating whether a function argument is passed in a
+register and if so, which register.
-The arguments are @var{cum}, which summarizes all the previous
+The arguments are @var{ca}, which summarizes all the previous
arguments; @var{mode}, the machine mode of the argument; @var{type},
the data type of the argument as a tree node or 0 if that is not known
(which happens for C support library functions); and @var{named},
-which is 1 for an ordinary argument and 0 for nameless arguments that
-correspond to @samp{@dots{}} in the called function's prototype.
-@var{type} can be an incomplete type if a syntax error has previously
-occurred.
+which is @code{true} for an ordinary argument and @code{false} for
+nameless arguments that correspond to @samp{@dots{}} in the called
+function's prototype. @var{type} can be an incomplete type if a
+syntax error has previously occurred.
-The value of the expression is usually either a @code{reg} RTX for the
-hard register in which to pass the argument, or zero to pass the
-argument on the stack.
+The return value is usually either a @code{reg} RTX for the hard
+register in which to pass the argument, or zero to pass the argument
+on the stack.
-For machines like the VAX and 68000, where normally all arguments are
-pushed, zero suffices as a definition.
-
The value of the expression can also be a @code{parallel} RTX@. This is
used when an argument is passed in multiple locations. The mode of the
@code{parallel} should be the mode of the entire argument. The
@@ -4005,26 +4011,27 @@
RTX may have a first operand of zero. This indicates that the entire
argument is also stored on the stack.
-The last time this macro is called, it is called with @code{MODE ==
+The last time this hook is called, it is called with @code{MODE ==
VOIDmode}, and its result is passed to the @code{call} or @code{call_value}
pattern as operands 2 and 3 respectively.
@cindex @file{stdarg.h} and register arguments
-The usual way to make the ISO library @file{stdarg.h} work on a machine
-where some arguments are usually passed in registers, is to cause
-nameless arguments to be passed on the stack instead. This is done
-by making @code{FUNCTION_ARG} return 0 whenever @var{named} is 0.
+The usual way to make the ISO library @file{stdarg.h} work on a
+machine where some arguments are usually passed in registers, is to
+cause nameless arguments to be passed on the stack instead. This is
+done by making @code{TARGET_FUNCTION_ARG} return 0 whenever
+@var{named} is @code{false}.
-@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{FUNCTION_ARG}
-@cindex @code{REG_PARM_STACK_SPACE}, and @code{FUNCTION_ARG}
+@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG}
+@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG}
You may use the hook @code{targetm.calls.must_pass_in_stack}
in the definition of this macro to determine if this argument is of a
type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE}
-is not defined and @code{FUNCTION_ARG} returns nonzero for such an
+is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an
argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is
defined, the argument will be computed in the stack and then loaded into
a register.
-@end defmac
+@end deftypefn
@hook TARGET_MUST_PASS_IN_STACK
This target hook should return @code{true} if we should not pass @var{type}
@@ -4033,20 +4040,21 @@
documentation.
@end deftypefn
-@defmac FUNCTION_INCOMING_ARG (@var{cum}, @var{mode}, @var{type}, @var{named})
-Define this macro if the target machine has ``register windows'', so
+@hook TARGET_FUNCTION_INCOMING_ARG
+Define this hook if the target machine has ``register windows'', so
that the register in which a function sees an arguments is not
necessarily the same as the one in which the caller passed the
argument.
-For such machines, @code{FUNCTION_ARG} computes the register in which
-the caller passes the value, and @code{FUNCTION_INCOMING_ARG} should
-be defined in a similar fashion to tell the function being called
-where the arguments will arrive.
+For such machines, @code{TARGET_FUNCTION_ARG} computes the register in
+which the caller passes the value, and
+@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar
+fashion to tell the function being called where the arguments will
+arrive.
-If @code{FUNCTION_INCOMING_ARG} is not defined, @code{FUNCTION_ARG}
-serves both purposes.
-@end defmac
+If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,
+@code{TARGET_FUNCTION_ARG} serves both purposes.
+@end deftypefn
@hook TARGET_ARG_PARTIAL_BYTES
This target hook returns the number of bytes at the beginning of an
@@ -4062,9 +4070,9 @@
in registers and the rest must be pushed. This macro tells the
compiler when this occurs, and how many bytes should go in registers.
-@code{FUNCTION_ARG} for these arguments should return the first
+@code{TARGET_FUNCTION_ARG} for these arguments should return the first
register to be used by the caller for this argument; likewise
-@code{FUNCTION_INCOMING_ARG}, for the called function.
+@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function.
@end deftypefn
@hook TARGET_PASS_BY_REFERENCE
@@ -4093,10 +4101,10 @@
@end deftypefn
@defmac CUMULATIVE_ARGS
-A C type for declaring a variable that is used as the first argument of
-@code{FUNCTION_ARG} and other related values. For some target machines,
-the type @code{int} suffices and can hold the number of bytes of
-argument so far.
+A C type for declaring a variable that is used as the first argument
+of @code{TARGET_FUNCTION_ARG} and other related values. For some
+target machines, the type @code{int} suffices and can hold the number
+of bytes of argument so far.
There is no need to record in @code{CUMULATIVE_ARGS} anything about the
arguments that have been passed on the stack. The compiler has other
@@ -4158,17 +4166,17 @@
@c --mew 5feb93 i switched the order of the sentences. --mew 10feb93
@end defmac
-@defmac FUNCTION_ARG_ADVANCE (@var{cum}, @var{mode}, @var{type}, @var{named})
-A C statement (sans semicolon) to update the summarizer variable
-@var{cum} to advance past an argument in the argument list. The
-values @var{mode}, @var{type} and @var{named} describe that argument.
-Once this is done, the variable @var{cum} is suitable for analyzing
-the @emph{following} argument with @code{FUNCTION_ARG}, etc.
+@hook TARGET_FUNCTION_ARG_ADVANCE
+This hook updates the summarizer variable pointed to by @var{ca} to
+advance past an argument in the argument list. The values @var{mode},
+@var{type} and @var{named} describe that argument. Once this is done,
+the variable @var{cum} is suitable for analyzing the @emph{following}
+argument with @code{TARGET_FUNCTION_ARG}, etc.
-This macro need not do anything if the argument in question was passed
+This hook need not do anything if the argument in question was passed
on the stack. The compiler knows how to track the amount of stack space
used for arguments without any special help.
-@end defmac
+@end deftypefn
@defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type})
If defined, a C expression that is the number of bytes to add to the
@@ -4184,9 +4192,9 @@
@code{enum direction}: either @code{upward} to pad above the argument,
@code{downward} to pad below, or @code{none} to inhibit padding.
-The @emph{amount} of padding is always just enough to reach the next
-multiple of @code{TARGET_FUNCTION_ARG_BOUNDARY}; this macro does not
-control it.
+The @emph{amount} of padding is not controlled by this macro, but by the
+target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}. It is
+always just enough to reach the next multiple of that boundary.
This macro has a default definition which is right for most systems.
For little-endian machines, the default is to pad upward. For
@@ -4219,6 +4227,8 @@
@code{PARM_BOUNDARY} for all arguments.
@end deftypefn
+@hook TARGET_FUNCTION_ARG_ROUND_BOUNDARY
+
@defmac FUNCTION_ARG_REGNO_P (@var{regno})
A C expression that is nonzero if @var{regno} is the number of a hard
register in which function arguments are sometimes passed. This does
@@ -4305,6 +4315,8 @@
must have move patterns for this mode.
@end deftypefn
+@hook TARGET_ARRAY_MODE_SUPPORTED_P
+
@hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
Define this to return nonzero for machine modes for which the port has
small register classes. If this target hook returns nonzero for a given
@@ -4364,7 +4376,7 @@
place regardless of mode.) The value of the expression is usually a
@code{reg} RTX for the hard register where the return value is stored.
The value can also be a @code{parallel} RTX, if the return value is in
-multiple places. See @code{FUNCTION_ARG} for an explanation of the
+multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the
@code{parallel} form. Note that the callee will populate every
location specified in the @code{parallel}, but if the first element of
the @code{parallel} contains the whole return value, callers will use
@@ -4409,10 +4421,10 @@
@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.
@@ -5049,7 +5061,7 @@
Define this hook to return @code{true} if the location where a function
argument is passed depends on whether or not it is a named argument.
-This hook controls how the @var{named} argument to @code{FUNCTION_ARG}
+This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}
is set for varargs and stdarg functions. If this hook returns
@code{true}, the @var{named} argument is always true for named
arguments, and false for unnamed arguments. If it returns @code{false},
@@ -5135,12 +5147,12 @@
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
@@ -5175,19 +5187,6 @@
@var{end} are both pointer expressions.
@end defmac
-The operating system may also require the stack to be made executable
-before calling the trampoline. To implement this requirement, define
-the following macro.
-
-@defmac ENABLE_EXECUTE_STACK
-Define this macro if certain operations must be performed before executing
-code located on the stack. The macro should expand to a series of C
-file-scope constructs (e.g.@: functions) and provide a unique entry point
-named @code{__enable_execute_stack}. The target is responsible for
-emitting calls to the entry point in the code, for example from the
-@code{TARGET_TRAMPOLINE_INIT} hook.
-@end defmac
-
To use a standard subroutine, define the following macro. In addition,
you must make sure that the instructions in a trampoline fill an entire
cache line with identical instructions, or else ensure that the
@@ -5235,6 +5234,8 @@
The default is to do nothing. Most ports don't need to define this hook.
@end deftypefn
+@hook TARGET_LIBFUNC_GNU_PREFIX
+
@defmac FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
This macro should return @code{true} if the library routine that
implements the floating point comparison operator @var{comparison} in
@@ -5344,7 +5345,7 @@
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})
@@ -5555,14 +5556,14 @@
@code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
@end defmac
-@defmac LEGITIMATE_CONSTANT_P (@var{x})
-A C expression that is nonzero if @var{x} is a legitimate constant for
-an immediate operand on the target machine. You can assume that
-@var{x} satisfies @code{CONSTANT_P}, so you need not check this. In fact,
-@samp{1} is a suitable definition for this macro on machines where
-anything @code{CONSTANT_P} is valid.
-@end defmac
+@hook TARGET_LEGITIMATE_CONSTANT_P
+This hook returns true if @var{x} is a legitimate constant for a
+@var{mode}-mode immediate operand on the target machine. You can assume that
+@var{x} satisfies @code{CONSTANT_P}, so you need not check this.
+The default definition returns true.
+@end deftypefn
+
@hook TARGET_DELEGITIMIZE_ADDRESS
This hook is used to undo the possibly obfuscating effects of the
@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target
@@ -5575,9 +5576,11 @@
@hook TARGET_CANNOT_FORCE_CONST_MEM
This hook should return true if @var{x} is of a form that cannot (or
-should not) be spilled to the constant pool. The default version of
-this hook returns false.
+should not) be spilled to the constant pool. @var{mode} is the mode
+of @var{x}.
+The default version of this hook returns false.
+
The primary reason to define this hook is to prevent reload from
deciding that a non-legitimate constant would be better reloaded
from the constant pool instead of spilling and reloading a register
@@ -5656,7 +5659,7 @@
@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
@@ -6254,7 +6257,7 @@
@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.
@@ -6266,8 +6269,8 @@
@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}.
@@ -6345,11 +6348,16 @@
This target hook describes the relative costs of RTL expressions.
The cost may depend on the precise form of the expression, which is
-available for examination in @var{x}, and the rtx code of the expression
-in which it is contained, found in @var{outer_code}. @var{code} is the
-expression code---redundant, since it can be obtained with
-@code{GET_CODE (@var{x})}.
+available for examination in @var{x}, and the fact that @var{x} appears
+as operand @var{opno} of an expression with rtx code @var{outer_code}.
+That is, the hook can assume that there is some rtx @var{y} such
+that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that
+either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or
+(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}.
+@var{code} is @var{x}'s expression code---redundant, since it can be
+obtained with @code{GET_CODE (@var{x})}.
+
In implementing this hook, you can use the construct
@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast
instructions.
@@ -6764,6 +6772,10 @@
in its second parameter.
@end deftypefn
+@hook TARGET_SCHED_EXPOSED_PIPELINE
+
+@hook TARGET_SCHED_REASSOCIATION_WIDTH
+
@node Sections
@section Dividing the Output into Sections (Texts, Data, @dots{})
@c the above section title is WAY too long. maybe cut the part between
@@ -6841,8 +6853,8 @@
@defmac BSS_SECTION_ASM_OP
If defined, a C expression whose value is a string, including spacing,
containing the assembler operation to identify the following data as
-uninitialized global data. If not defined, and neither
-@code{ASM_OUTPUT_BSS} nor @code{ASM_OUTPUT_ALIGNED_BSS} are defined,
+uninitialized global data. If not defined, and
+@code{ASM_OUTPUT_ALIGNED_BSS} not defined,
uninitialized global data will be output in the data section if
@option{-fno-common} is passed, otherwise @code{ASM_OUTPUT_COMMON} will be
used.
@@ -7005,6 +7017,8 @@
otherwise.
@end deftypefn
+@hook TARGET_ASM_MERGEABLE_RODATA_PREFIX
+
@hook TARGET_ASM_SELECT_RTX_SECTION
Return the section into which a constant @var{x}, of mode @var{mode},
should be placed. You can assume that @var{x} is some kind of
@@ -7113,7 +7127,7 @@
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
@@ -7297,7 +7311,7 @@
@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).
@@ -7606,20 +7620,19 @@
the variable's decl in order to chose what to output.
@end defmac
-@defmac ASM_OUTPUT_BSS (@var{stream}, @var{decl}, @var{name}, @var{size},
@var{rounded})
+@defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name},
@var{size}, @var{alignment})
A C statement (sans semicolon) to output to the stdio stream
@var{stream} the assembler definition of uninitialized global @var{decl} named
-@var{name} whose size is @var{size} bytes. The variable @var{rounded}
-is the size rounded up to whatever alignment the caller wants.
+@var{name} whose size is @var{size} bytes. The variable @var{alignment}
+is the alignment specified as the number of bits.
-Try to use function @code{asm_output_bss} defined in @file{varasm.c} when
-defining this macro. If unable, use the expression
+Try to use function @code{asm_output_aligned_bss} defined in file
+@file{varasm.c} when defining this macro. If unable, use the expression
@code{assemble_name (@var{stream}, @var{name})} to output the name itself;
before and after that, output the additional assembler syntax for defining
the name, and a newline.
-There are two ways of handling global BSS@. One is to define either
-this macro or its aligned counterpart, @code{ASM_OUTPUT_ALIGNED_BSS}.
+There are two ways of handling global BSS@. One is to define this macro.
The other is to have @code{TARGET_ASM_SELECT_SECTION} return a
switchable BSS section (@pxref{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS}).
You do not need to do both.
@@ -7631,17 +7644,6 @@
common in order to save space in the object file.
@end defmac
-@defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name},
@var{size}, @var{alignment})
-Like @code{ASM_OUTPUT_BSS} except takes the required alignment as a
-separate, explicit argument. If you define this macro, it is used in
-place of @code{ASM_OUTPUT_BSS}, and gives you more flexibility in
-handling the required alignment of the variable. The alignment is specified
-as the number of bits.
-
-Try to use function @code{asm_output_aligned_bss} defined in file
-@file{varasm.c} when defining this macro.
-@end defmac
-
@defmac ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size}, @var{rounded})
A C statement (sans semicolon) to output to the stdio stream
@var{stream} the assembler definition of a local-common-label named
@@ -9388,6 +9390,10 @@
@hook TARGET_WANT_DEBUG_PUB_SECTIONS
+@hook TARGET_DELAY_SCHED2
+
+@hook TARGET_DELAY_VARTRACK
+
@defmac ASM_OUTPUT_DWARF_DELTA (@var{stream}, @var{size}, @var{label1},
@var{label2})
A C statement to issue assembly directives that create a difference
@var{lab1} minus @var{lab2}, using an integer of the given @var{size}.
@@ -10507,14 +10513,14 @@
@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.
@@ -10547,7 +10553,7 @@
@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}.
@@ -10821,7 +10827,7 @@
To create a built-in function, call the function
@code{lang_hooks.builtin_function}
which is defined by the language front end. You can use any type nodes set
-up by @code{build_common_tree_nodes} and @code{build_common_tree_nodes_2};
+up by @code{build_common_tree_nodes};
only language front ends that use those two functions will call
@samp{TARGET_INIT_BUILTINS}.
@end deftypefn
@@ -10932,7 +10938,7 @@
@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
@@ -11146,21 +11152,21 @@
@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.
@@ -11168,10 +11174,10 @@
@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
@@ -11189,7 +11195,7 @@
@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
Index: contrib.texi
===================================================================
--- contrib.texi (revision 170935)
+++ contrib.texi (revision 179462)
@@ -1,5 +1,5 @@
@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000,
-@c 2001,2002,2003,2004,2005,2006,2007,2008,2009, 2010
+@c 2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@@ -806,8 +806,8 @@
@item
Bernd Schmidt for various code generation improvements and major
-work in the reload pass as well a serving as release manager for
-GCC 2.95.3.
+work in the reload pass, serving as release manager for
+GCC 2.95.3, and work on the Blackfin and C6X ports.
@item
Peter Schmid for constant testing of libstdc++---especially application
@@ -868,6 +868,10 @@
@code{LOGICAL*1}.
@item
+Zdenek Sojka for running automated regression testing of GCC and reporting
+numerous bugs.
+
+@item
Brad Spencer for contributions to the GLIBCPP_FORCE_NEW technique.
@item
@@ -934,8 +938,8 @@
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
Index: md.texi
===================================================================
--- md.texi (revision 170935)
+++ md.texi (revision 179462)
@@ -1773,37 +1773,9 @@
@item Q
A memory address based on Y or Z pointer with displacement.
-@end table
-@item CRX Architecture---@file{config/crx/crx.h}
-@table @code
-
-@item b
-Registers from r0 to r14 (registers without stack pointer)
-
-@item l
-Register r16 (64-bit accumulator lo register)
-
-@item h
-Register r17 (64-bit accumulator hi register)
-
-@item k
-Register pair r16-r17. (64-bit accumulator lo-hi pair)
-
-@item I
-Constant that fits in 3 bits
-
-@item J
-Constant that fits in 4 bits
-
-@item K
-Constant that fits in 5 bits
-
-@item L
-Constant that is one of @minus{}1, 4, @minus{}4, 7, 8, 12, 16, 20, 32, 48
-
-@item G
-Floating point constant that is legal for store immediate
+@item C04
+Constant integer 4
@end table
@item Hewlett-Packard PA-RISC---@file{config/pa/pa.h}
@@ -1998,7 +1970,7 @@
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
@@ -2173,7 +2145,7 @@
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
@@ -2868,64 +2840,6 @@
@end table
-@item Motorola 68HC11 & 68HC12 families---@file{config/m68hc11/m68hc11.h}
-@table @code
-@item a
-Register `a'
-
-@item b
-Register `b'
-
-@item d
-Register `d'
-
-@item q
-An 8-bit register
-
-@item t
-Temporary soft register _.tmp
-
-@item u
-A soft register _.d1 to _.d31
-
-@item w
-Stack pointer register
-
-@item x
-Register `x'
-
-@item y
-Register `y'
-
-@item z
-Pseudo register `z' (replaced by `x' or `y' at the end)
-
-@item A
-An address register: x, y or z
-
-@item B
-An address register: x or y
-
-@item D
-Register pair (x:d) to form a 32-bit value
-
-@item L
-Constants in the range @minus{}65536 to 65535
-
-@item M
-Constants whose 16-bit low part is zero
-
-@item N
-Constant integer 1 or @minus{}1
-
-@item O
-Constant integer 16
-
-@item P
-Constants in the range @minus{}8 to 2
-
-@end table
-
@item Moxie---@file{config/moxie/constraints.md}
@table @code
@item A
@@ -3111,70 +3025,70 @@
@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
@@ -3390,6 +3304,89 @@
@end table
+@item TI C6X family---@file{config/c6x/constraints.md}
+@table @code
+@item a
+Register file A (A0--A31).
+
+@item b
+Register file B (B0--B31).
+
+@item A
+Predicate registers in register file A (A0--A2 on C64X and
+higher, A1 and A2 otherwise).
+
+@item B
+Predicate registers in register file B (B0--B2).
+
+@item C
+A call-used register in register file B (B0--B9, B16--B31).
+
+@item Da
+Register file A, excluding predicate registers (A3--A31,
+plus A0 if not C64X or higher).
+
+@item Db
+Register file B, excluding predicate registers (B3--B31).
+
+@item Iu4
+Integer constant in the range 0 @dots{} 15.
+
+@item Iu5
+Integer constant in the range 0 @dots{} 31.
+
+@item In5
+Integer constant in the range @minus{}31 @dots{} 0.
+
+@item Is5
+Integer constant in the range @minus{}16 @dots{} 15.
+
+@item I5x
+Integer constant that can be the operand of an ADDA or a SUBA insn.
+
+@item IuB
+Integer constant in the range 0 @dots{} 65535.
+
+@item IsB
+Integer constant in the range @minus{}32768 @dots{} 32767.
+
+@item IsC
+Integer constant in the range @math{-2^{20}} @dots{} @math{2^{20} - 1}.
+
+@item Jc
+Integer constant that is a valid mask for the clr instruction.
+
+@item Js
+Integer constant that is a valid mask for the set instruction.
+
+@item Q
+Memory location with A base register.
+
+@item R
+Memory location with B base register.
+
+@ifset INTERNALS
+@item S0
+On C64x+ targets, a GP-relative small data reference.
+
+@item S1
+Any kind of @code{SYMBOL_REF}, for use in a call address.
+
+@item Si
+Any kind of immediate operand, unless it matches the S0 constraint.
+
+@item T
+Memory location with B base register, but not using a long offset.
+
+@item W
+A memory operand with an address that can't be used in an unaligned access.
+
+@end ifset
+@item Z
+Register B14 (aka DP).
+
+@end table
+
@item Xtensa---@file{config/xtensa/constraints.md}
@table @code
@item a
@@ -3524,7 +3521,7 @@
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
@@ -3935,6 +3932,48 @@
consecutive memory locations, operand 1 is the first register, and
operand 2 is a constant: the number of consecutive registers.
+@cindex @code{vec_load_lanes@var{m}@var{n}} instruction pattern
+@item @samp{vec_load_lanes@var{m}@var{n}}
+Perform an interleaved load of several vectors from memory operand 1
+into register operand 0. Both operands have mode @var{m}. The register
+operand is viewed as holding consecutive vectors of mode @var{n},
+while the memory operand is a flat array that contains the same number
+of elements. The operation is equivalent to:
+
+@smallexample
+int c = GET_MODE_SIZE (@var{m}) / GET_MODE_SIZE (@var{n});
+for (j = 0; j < GET_MODE_NUNITS (@var{n}); j++)
+ for (i = 0; i < c; i++)
+ operand0[i][j] = operand1[j * c + i];
+@end smallexample
+
+For example, @samp{vec_load_lanestiv4hi} loads 8 16-bit values
+from memory into a register of mode @samp{TI}@. The register
+contains two consecutive vectors of mode @samp{V4HI}@.
+
+This pattern can only be used if:
+@smallexample
+TARGET_ARRAY_MODE_SUPPORTED_P (@var{n}, @var{c})
+@end smallexample
+is true. GCC assumes that, if a target supports this kind of
+instruction for some mode @var{n}, it also supports unaligned
+loads for vectors of mode @var{n}.
+
+@cindex @code{vec_store_lanes@var{m}@var{n}} instruction pattern
+@item @samp{vec_store_lanes@var{m}@var{n}}
+Equivalent to @samp{vec_load_lanes@var{m}@var{n}}, with the memory
+and register operands reversed. That is, the instruction is
+equivalent to:
+
+@smallexample
+int c = GET_MODE_SIZE (@var{m}) / GET_MODE_SIZE (@var{n});
+for (j = 0; j < GET_MODE_NUNITS (@var{n}); j++)
+ for (i = 0; i < c; i++)
+ operand0[j * c + i] = operand1[i][j];
+@end smallexample
+
+for a memory operand 0 and register operand 1.
+
@cindex @code{vec_set@var{m}} instruction pattern
@item @samp{vec_set@var{m}}
Set given field in the vector value. Operand 0 is the vector to modify,
@@ -3947,15 +3986,15 @@
@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.
@@ -3970,7 +4009,7 @@
@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
@@ -3978,6 +4017,17 @@
Initialize the vector to given values. Operand 0 is the vector to initialize
and operand 1 is parallel containing values for individual fields.
+@cindex @code{vcond@var{m}@var{n}} instruction pattern
+@item @samp{vcond@var{m}@var{n}}
+Output a conditional vector move. Operand 0 is the destination to
+receive a combination of operand 1 and operand 2, which are of mode @var{m},
+dependent on the outcome of the predicate in operand 3 which is a
+vector comparison with operands of mode @var{n} in operands 4 and 5. The
+modes @var{m} and @var{n} should have the same size. Operand 0
+will be set to the value @var{op1} & @var{msk} | @var{op2} & ~@var{msk}
+where @var{msk} is computed by element-wise evaluation of the vector
+comparison with a truth value of all-ones and a false value of all-zeros.
+
@cindex @code{push@var{m}1} instruction pattern
@item @samp{push@var{m}1}
Output a push instruction. Operand 0 is value to push. Used only when
@@ -4100,17 +4150,17 @@
@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.)
@@ -4641,8 +4691,9 @@
string. The instruction is not allowed to prefetch more than one byte
at a time since either string may end in the first byte and reading past
that may access an invalid page or segment and cause a fault. The
-effect of the instruction is to store a value in operand 0 whose sign
-indicates the result of the comparison.
+comparison terminates early if the fetched bytes are different or if
+they are equal to zero. The effect of the instruction is to store a
+value in operand 0 whose sign indicates the result of the comparison.
@cindex @code{cmpstr@var{m}} instruction pattern
@item @samp{cmpstr@var{m}}
@@ -4660,8 +4711,10 @@
order starting at the beginning of each string. The instruction is not allowed
to prefetch more than one byte at a time since either string may end in the
first byte and reading past that may access an invalid page or segment and
-cause a fault. The effect of the instruction is to store a value in operand 0
-whose sign indicates the result of the comparison.
+cause a fault. The comparison will terminate when the fetched bytes
+are different or if they are equal to zero. The effect of the
+instruction is to store a value in operand 0 whose sign indicates the
+result of the comparison.
@cindex @code{cmpmem@var{m}} instruction pattern
@item @samp{cmpmem@var{m}}
@@ -4669,9 +4722,10 @@
of @samp{cmpstr@var{m}}. The two memory blocks specified are compared
byte by byte in lexicographic order starting at the beginning of each
block. Unlike @samp{cmpstr@var{m}} the instruction can prefetch
-any bytes in the two memory blocks. The effect of the instruction is
-to store a value in operand 0 whose sign indicates the result of the
-comparison.
+any bytes in the two memory blocks. Also unlike @samp{cmpstr@var{m}}
+the comparison will not stop if both bytes are zero. The effect of
+the instruction is to store a value in operand 0 whose sign indicates
+the result of the comparison.
@cindex @code{strlen@var{m}} instruction pattern
@item @samp{strlen@var{m}}
@@ -4949,6 +5003,20 @@
return. Normally, the applicable functions are those which do not need
to save any registers or allocate stack space.
+It is valid for this pattern to expand to an instruction using
+@code{simple_return} if no epilogue is required.
+
+@cindex @code{simple_return} instruction pattern
+@item @samp{simple_return}
+Subroutine return instruction. This instruction pattern name should be
+defined only if a single instruction can do all the work of returning
+from a function on a path where no epilogue is required. This pattern
+is very similar to the @code{return} instruction pattern, but it is emitted
+only by the shrink-wrapping optimization on paths where the function
+prologue has not been executed, and a function return should occur without
+any of the effects of the epilogue. Additional uses may be introduced on
+paths where both the prologue and the epilogue have executed.
+
@findex reload_completed
@findex leaf_function_p
For such machines, the condition specified in this pattern should only
@@ -5294,6 +5362,14 @@
The @code{prologue} pattern is particularly useful for targets which perform
instruction scheduling.
+@cindex @code{window_save} instruction pattern
+@anchor{window_save instruction pattern}
+@item @samp{window_save}
+This pattern, if defined, emits RTL for a register window save. It should
+be defined if the target machine has register windows but the window events
+are decoupled from calls to subroutines. The canonical example is the SPARC
+architecture.
+
@cindex @code{epilogue} instruction pattern
@anchor{epilogue instruction pattern}
@item @samp{epilogue}
@@ -5510,7 +5586,7 @@
@cindex @code{stack_protect_set} instruction pattern
@item @samp{stack_protect_set}
-This pattern, if defined, moves a @code{Pmode} value from the memory
+This pattern, if defined, moves a @code{ptr_mode} value from the memory
in operand 1 to the memory in operand 0 without leaving the value in
a register afterward. This is to avoid leaking the value some place
that an attacker might use to rewrite the stack guard slot after
@@ -5521,7 +5597,7 @@
@cindex @code{stack_protect_test} instruction pattern
@item @samp{stack_protect_test}
-This pattern, if defined, compares a @code{Pmode} value from the
+This pattern, if defined, compares a @code{ptr_mode} value from the
memory in operand 1 with the memory in operand 0 without leaving the
value in a register afterward and branches to operand 2 if the values
weren't equal.
@@ -5887,6 +5963,23 @@
will be written using @code{zero_extract} rather than the equivalent
@code{and} or @code{sign_extract} operations.
+@cindex @code{mult}, canonicalization of
+@item
+@code{(sign_extend:@var{m1} (mult:@var{m2} (sign_extend:@var{m2} @var{x})
+(sign_extend:@var{m2} @var{y})))} is converted to @code{(mult:@var{m1}
+(sign_extend:@var{m1} @var{x}) (sign_extend:@var{m1} @var{y}))}, and likewise
+for @code{zero_extend}.
+
+@item
+@code{(sign_extend:@var{m1} (mult:@var{m2} (ashiftrt:@var{m2}
+@var{x} @var{s}) (sign_extend:@var{m2} @var{y})))} is converted
+to @code{(mult:@var{m1} (sign_extend:@var{m1} (ashiftrt:@var{m2}
+@var{x} @var{s})) (sign_extend:@var{m1} @var{y}))}, and likewise for
+patterns using @code{zero_extend} and @code{lshiftrt}. If the second
+operand of @code{mult} is also a shift, then that is extended also.
+This transformation is only applied when it can be proven that the
+original operation had sufficient precision to prevent overflow.
+
@end itemize
Further canonicalization rules are defined in the function
@@ -6775,6 +6868,14 @@
@end smallexample
@var{name} is a string specifying the name of the attribute being defined.
+Some attributes are used in a special way by the rest of the compiler. The
+@code{enabled} attribute can be used to conditionally enable or disable
+insn alternatives (@pxref{Disable Insn Alternatives}). The @code{predicable}
+attribute, together with a suitable @code{define_cond_exec}
+(@pxref{Conditional Execution}), can be used to automatically generate
+conditional variants of instruction patterns. The compiler internally uses
+the names @code{ce_enabled} and @code{nonce_enabled}, so they should not be
+used elsewhere as alternative names.
@var{list-of-values} is either a string that specifies a comma-separated
list of values that can be assigned to the attribute, or a null string to
@@ -6955,6 +7056,30 @@
The @var{constraints} operand is ignored and should be the null string.
+@cindex @code{match_test} and attributes
+@item (match_test @var{c-expr})
+The test is true if C expression @var{c-expr} is true. In non-constant
+attributes, @var{c-expr} has access to the following variables:
+
+@table @var
+@item insn
+The rtl instruction under test.
+@item which_alternative
+The @code{define_insn} alternative that @var{insn} matches.
+@xref{Output Statement}.
+@item operands
+An array of @var{insn}'s rtl operands.
+@end table
+
+@var{c-expr} behaves like the condition in a C @code{if} statement,
+so there is no need to explicitly convert the expression into a boolean
+0 or 1 value. For example, the following two tests are equivalent:
+
+@smallexample
+(match_test "x & 2")
+(match_test "(x & 2) != 0")
+@end smallexample
+
@cindex @code{le} and attributes
@cindex @code{leu} and attributes
@cindex @code{lt} and attributes
@@ -7711,8 +7836,16 @@
@var{number} defines when the result generated by the instructions
given in string @var{out_insn_names} will be ready for the
-instructions given in string @var{in_insn_names}. The instructions in
-the string are separated by commas.
+instructions given in string @var{in_insn_names}. Each of these
+strings is a comma-separated list of filename-style globs and
+they refer to the names of @code{define_insn_reservation}s.
+For example:
+@smallexample
+(define_bypass 1 "cpu1_load_*, cpu1_store_*" "cpu1_load_*")
+@end smallexample
+defines a bypass between instructions that start with
+@samp{cpu1_load_} or @samp{cpu1_store_} and those that start with
+@samp{cpu1_load_}.
@var{guard} is an optional string giving the name of a C function which
defines an additional guard for the bypass. The function will get the
@@ -7808,7 +7941,7 @@
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:
@@ -7870,6 +8003,13 @@
non-critical errors.
@item
+@dfn{no-comb-vect} prevents the automaton generator from generating
+two data structures and comparing them for space efficiency. Using
+a comb vector to represent transitions may be better, but it can be
+very expensive to construct. This option is useful if the build
+process spends an unacceptably long time in genautomata.
+
+@item
@dfn{ndfa} makes nondeterministic finite state automata. This affects
the treatment of operator @samp{|} in the regular expressions. The
usual treatment of the operator is to try the first alternative and,
@@ -7878,6 +8018,16 @@
may be rejected by reservations in the subsequent insns.
@item
+@dfn{collapse-ndfa} modifies the behaviour of the generator when
+producing an automaton. An additional state transition to collapse a
+nondeterministic @acronym{NDFA} state to a deterministic @acronym{DFA}
+state is generated. It can be triggered by passing @code{const0_rtx} to
+state_transition. In such an automaton, cycle advance transitions are
+available only for these collapsed states. This option is useful for
+ports that want to use the @code{ndfa} option, but also want to use
+@code{define_query_cpu_unit} to assign units to insns issued in a cycle.
+
+@item
@dfn{progress} means output of a progress bar showing how many states
were generated so far for automaton being processed. This is useful
during debugging a @acronym{DFA} description. If you see too many
@@ -7984,11 +8134,14 @@
When @code{define_cond_exec} is used, an implicit reference to
the @code{predicable} instruction attribute is made.
-@xref{Insn Attributes}. This attribute must be boolean (i.e.@: have
-exactly two elements in its @var{list-of-values}). Further, it must
-not be used with complex expressions. That is, the default and all
-uses in the insns must be a simple constant, not dependent on the
-alternative or anything else.
+@xref{Insn Attributes}. This attribute must be a boolean (i.e.@: have
+exactly two elements in its @var{list-of-values}), with the possible
+values being @code{no} and @code{yes}. The default and all uses in
+the insns must be a simple constant, not a complex expressions. It
+may, however, depend on the alternative, by using a comma-separated
+list of values. If that is the case, the port should also define an
+@code{enabled} attribute (@pxref{Disable Insn Alternatives}), which
+should also allow only @code{no} and @code{yes} as its values.
For each @code{define_insn} for which the @code{predicable}
attribute is true, a new @code{define_insn} pattern will be
Index: rtl.texi
===================================================================
--- rtl.texi (revision 170935)
+++ rtl.texi (revision 179462)
@@ -1,5 +1,5 @@
@c Copyright (C) 1988, 1989, 1992, 1994, 1997, 1998, 1999, 2000, 2001, 2002,
-@c 2003, 2004, 2005, 2006, 2007, 2008, 2010
+@c 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2011
@c Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
@@ -409,15 +409,27 @@
or another @code{COMPONENT_REF}, or null if there is no compile-time
object associated with the reference.
+@findex MEM_OFFSET_KNOWN_P
+@item MEM_OFFSET_KNOWN_P (@var{x})
+True if the offset of the memory reference from @code{MEM_EXPR} is known.
+@samp{MEM_OFFSET (@var{x})} provides the offset if so.
+
@findex MEM_OFFSET
@item MEM_OFFSET (@var{x})
-The offset from the start of @code{MEM_EXPR} as a @code{CONST_INT} rtx.
+The offset from the start of @code{MEM_EXPR}. The value is only valid if
+@samp{MEM_OFFSET_KNOWN_P (@var{x})} is true.
+@findex MEM_SIZE_KNOWN_P
+@item MEM_SIZE_KNOWN_P (@var{x})
+True if the size of the memory reference is known.
+@samp{MEM_SIZE (@var{x})} provides its size if so.
+
@findex MEM_SIZE
@item MEM_SIZE (@var{x})
-The size in bytes of the memory reference as a @code{CONST_INT} rtx.
+The size in bytes of the memory reference.
This is mostly relevant for @code{BLKmode} references as otherwise
-the size is implied by the mode.
+the size is implied by the mode. The value is only valid if
+@samp{MEM_SIZE_KNOWN_P (@var{x})} is true.
@findex MEM_ALIGN
@item MEM_ALIGN (@var{x})
@@ -1394,7 +1406,7 @@
@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}.
@@ -1755,7 +1767,7 @@
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}:
@@ -1812,7 +1824,7 @@
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:
@@ -1849,7 +1861,7 @@
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}.
@@ -1898,7 +1910,7 @@
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)
@@ -2396,10 +2408,17 @@
@item (ffs:@var{m} @var{x})
Represents one plus the index of the least significant 1-bit in
@var{x}, represented as an integer of mode @var{m}. (The value is
-zero if @var{x} is zero.) The mode of @var{x} need not be @var{m};
-depending on the target machine, various mode combinations may be
-valid.
+zero if @var{x} is zero.) The mode of @var{x} must be @var{m}
+or @code{VOIDmode}.
+@findex clrsb
+@item (clrsb:@var{m} @var{x})
+Represents the number of redundant leading sign bits in @var{x},
+represented as an integer of mode @var{m}, starting at the most
+significant bit position. This is one less than the number of leading
+sign bits (either 0 or 1), with no special cases. The mode of @var{x}
+must be @var{m} or @code{VOIDmode}.
+
@findex clz
@item (clz:@var{m} @var{x})
Represents the number of leading 0-bits in @var{x}, represented as an
@@ -2407,7 +2426,7 @@
If @var{x} is zero, the value is determined by
@code{CLZ_DEFINED_VALUE_AT_ZERO} (@pxref{Misc}). Note that this is one of
the few expressions that is not invariant under widening. The mode of
-@var{x} will usually be an integer mode.
+@var{x} must be @var{m} or @code{VOIDmode}.
@findex ctz
@item (ctz:@var{m} @var{x})
@@ -2416,23 +2435,24 @@
If @var{x} is zero, the value is determined by
@code{CTZ_DEFINED_VALUE_AT_ZERO} (@pxref{Misc}). Except for this case,
@code{ctz(x)} is equivalent to @code{ffs(@var{x}) - 1}. The mode of
-@var{x} will usually be an integer mode.
+@var{x} must be @var{m} or @code{VOIDmode}.
@findex popcount
@item (popcount:@var{m} @var{x})
Represents the number of 1-bits in @var{x}, represented as an integer of
-mode @var{m}. The mode of @var{x} will usually be an integer mode.
+mode @var{m}. The mode of @var{x} must be @var{m} or @code{VOIDmode}.
@findex parity
@item (parity:@var{m} @var{x})
Represents the number of 1-bits modulo 2 in @var{x}, represented as an
-integer of mode @var{m}. The mode of @var{x} will usually be an integer
-mode.
+integer of mode @var{m}. The mode of @var{x} must be @var{m} or
+@code{VOIDmode}.
@findex bswap
@item (bswap:@var{m} @var{x})
Represents the value @var{x} with the order of bytes reversed, carried out
in mode @var{m}, which must be a fixed-point machine mode.
+The mode of @var{x} must be @var{m} or @code{VOIDmode}.
@end table
@node Comparisons
@@ -2624,9 +2644,9 @@
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
@@ -2895,6 +2915,13 @@
Note that an insn pattern of @code{(return)} is logically equivalent to
@code{(set (pc) (return))}, but the latter form is never used.
+@findex simple_return
+@item (simple_return)
+Like @code{(return)}, but truly represents only a function return, while
+@code{(return)} may represent an insn that also performs other functions
+of the function epilogue. Like @code{(return)}, this may also occur in
+conditional jumps.
+
@findex call
@item (call @var{function} @var{nargs})
Represents a function call. @var{function} is a @code{mem} expression
@@ -3024,7 +3051,7 @@
brackets stand for a vector; the operand of @code{parallel} is a
vector of expressions. @var{x0}, @var{x1} and so on are individual
side effect expressions---expressions of code @code{set}, @code{call},
-@code{return}, @code{clobber} or @code{use}.
+@code{return}, @code{simple_return}, @code{clobber} or @code{use}.
``In parallel'' means that first all the values used in the individual
side-effects are computed, and second all the actual side-effects are
@@ -3663,14 +3690,16 @@
@table @code
@findex PATTERN
@item PATTERN (@var{i})
-An expression for the side effect performed by this insn. This must be
-one of the following codes: @code{set}, @code{call}, @code{use},
-@code{clobber}, @code{return}, @code{asm_input}, @code{asm_output},
-@code{addr_vec}, @code{addr_diff_vec}, @code{trap_if}, @code{unspec},
-@code{unspec_volatile}, @code{parallel}, @code{cond_exec}, or @code{sequence}.
If it is a @code{parallel},
-each element of the @code{parallel} must be one these codes, except that
-@code{parallel} expressions cannot be nested and @code{addr_vec} and
-@code{addr_diff_vec} are not permitted inside a @code{parallel} expression.
+An expression for the side effect performed by this insn. This must
+be one of the following codes: @code{set}, @code{call}, @code{use},
+@code{clobber}, @code{return}, @code{simple_return}, @code{asm_input},
+@code{asm_output}, @code{addr_vec}, @code{addr_diff_vec},
+@code{trap_if}, @code{unspec}, @code{unspec_volatile},
+@code{parallel}, @code{cond_exec}, or @code{sequence}. If it is a
+@code{parallel}, each element of the @code{parallel} must be one these
+codes, except that @code{parallel} expressions cannot be nested and
+@code{addr_vec} and @code{addr_diff_vec} are not permitted inside a
+@code{parallel} expression.
@findex INSN_CODE
@item INSN_CODE (@var{i})
@@ -3697,7 +3726,7 @@
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})
@@ -3808,8 +3837,8 @@
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
Index: hostconfig.texi
===================================================================
--- hostconfig.texi (revision 170935)
+++ hostconfig.texi (revision 179462)
@@ -214,15 +214,15 @@
@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
Index: gty.texi
===================================================================
--- gty.texi (revision 170935)
+++ gty.texi (revision 179462)
@@ -371,7 +371,7 @@
@};
@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);
@@ -383,6 +383,51 @@
size_t size = sizeof (struct sorted_fields_type) + n * sizeof (tree);
@end smallexample
+@findex atomic
+@item atomic
+
+The @code{atomic} option can only be used with pointers. It informs
+the GC machinery that the memory that the pointer points to does not
+contain any pointers, and hence it should be treated by the GC and PCH
+machinery as an ``atomic'' block of memory that does not need to be
+examined when scanning memory for pointers. In particular, the
+machinery will not scan that memory for pointers to mark them as
+reachable (when marking pointers for GC) or to relocate them (when
+writing a PCH file).
+
+The @code{atomic} option differs from the @code{skip} option.
+@code{atomic} keeps the memory under Garbage Collection, but makes the
+GC ignore the contents of the memory. @code{skip} is more drastic in
+that it causes the pointer and the memory to be completely ignored by
+the Garbage Collector. So, memory marked as @code{atomic} is
+automatically freed when no longer reachable, while memory marked as
+@code{skip} is not.
+
+The @code{atomic} option must be used with great care, because all
+sorts of problem can occur if used incorrectly, that is, if the memory
+the pointer points to does actually contain a pointer.
+
+Here is an example of how to use it:
+@smallexample
+struct GTY(()) my_struct @{
+ int number_of_elements;
+ unsigned int GTY ((atomic)) * elements;
+@};
+@end smallexample
+In this case, @code{elements} is a pointer under GC, and the memory it
+points to needs to be allocated using the Garbage Collector, and will
+be freed automatically by the Garbage Collector when it is no longer
+referenced. But the memory that the pointer points to is an array of
+@code{unsigned int} elements, and the GC must not try to scan it to
+find pointers to mark or relocate, which is why it is marked with the
+@code{atomic} option.
+
+Note that, currently, global variables can not be marked with
+@code{atomic}; only fields of a struct can. This is a known
+limitation. It would be useful to be able to mark global pointers
+with @code{atomic} to make the PCH machinery aware of them so that
+they are saved and restored correctly to PCH files.
+
@findex special
@item special ("@var{name}")
Other related posts:
