On Sun, Jun 6, 2021 at 7:13 PM Martin Liška <mli...@suse.cz> wrote:
>
> Hello.
>
> I'll need to parse output of tm.texi when converted to Sphinx for the future
> conversion. So that I split DEFHOOK documentation entries with newlines.
>
> I'll install the patch if there are no comments?
Hmm, what's the problem with parsing the strings? The newlines are
only because of our line length limits and hard-coding them looks both
error-prone and ugly.
Richard.
> Thanks,
> Martin
>
> gcc/c-family/ChangeLog:
>
> * c-target.def: Split long lines and replace them
> with '\n\'.
>
> gcc/ChangeLog:
>
> * common/common-target.def: Split long lines and replace them
> with '\n\'.
> * target.def: Likewise.
> * doc/tm.texi: Re-generated.
> ---
> gcc/c-family/c-target.def | 70 ++---
> gcc/common/common-target.def | 32 +--
> gcc/doc/tm.texi | 364 +++++++++++++++++++++-----
> gcc/target.def | 485 +++++++++++++++++++----------------
> 4 files changed, 612 insertions(+), 339 deletions(-)
>
> diff --git a/gcc/c-family/c-target.def b/gcc/c-family/c-target.def
> index f2a1b7ef7c5..164f1b31694 100644
> --- a/gcc/c-family/c-target.def
> +++ b/gcc/c-family/c-target.def
> @@ -43,73 +43,73 @@ DEFHOOK
>
> DEFHOOK
> (objc_construct_string_object,
> - "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\
> + "Targets may provide a string object type that can be used within\n\
> +and between C, C++ and their respective Objective-C dialects.\n\
> +A string object might, for example, embed encoding and length information.\n\
> +These objects are considered opaque to the compiler and handled as
> references.\n\
> +An ideal implementation makes the composition of the string object\n\
> +match that of the Objective-C @code{NSString} (@code{NXString} for
> GNUStep),\n\
> +allowing efficient interworking between C-only and Objective-C code.\n\
> +If a target implements string objects then this hook should return a\n\
> +reference to such an object constructed from the normal `C' string\n\
> +representation provided in @var{string}.\n\
> +At present, the hook is used by Objective-C only, to obtain a\n\
> common-format string object when the target provides one.",
> tree, (tree string),
> NULL)
>
> DEFHOOK
> (objc_declare_unresolved_class_reference,
> - "Declare that Objective C class @var{classname} is referenced\
> - by the current TU.",
> + "Declare that Objective C class @var{classname} is referenced\n\
> +by the current TU.",
> void, (const char *classname),
> NULL)
>
> DEFHOOK
> (objc_declare_class_definition,
> - "Declare that Objective C class @var{classname} is defined\
> - by the current TU.",
> + "Declare that Objective C class @var{classname} is defined\n\
> +by the current TU.",
> void, (const char *classname),
> NULL)
>
> DEFHOOK
> (string_object_ref_type_p,
> - "If a target implements string objects then this hook should return\
> - @code{true} if @var{stringref} is a valid reference to such an object.",
> + "If a target implements string objects then this hook should return\n\
> +@code{true} if @var{stringref} is a valid reference to such an object.",
> bool, (const_tree stringref),
> hook_bool_const_tree_false)
>
> DEFHOOK
> (check_string_object_format_arg,
> - "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.",
> + "If a target implements string objects then this hook should should\n\
> +provide a facility to check the function arguments in @var{args_list}\n\
> +against the format specifiers in @var{format_arg} where the type of\n\
> +@var{format_arg} is one recognized as a valid string reference type.",
> void, (tree format_arg, tree args_list),
> NULL)
>
> DEFHOOK
> (c_preinclude,
> - "Define this hook to return the name of a header file to be included at\
> - the start of all compilations, as if it had been included with\
> - @code{#include <@var{file}>}. If this hook returns @code{NULL}, or is\
> - not defined, or the header is not found, or if the user specifies\
> - @option{-ffreestanding} or @option{-nostdinc}, no header is included.\n\
> + "Define this hook to return the name of a header file to be included at\n\
> +the start of all compilations, as if it had been included with\n\
> +@code{#include <@var{file}>}. If this hook returns @code{NULL}, or is\n\
> +not defined, or the header is not found, or if the user specifies\n\
> +@option{-ffreestanding} or @option{-nostdinc}, no header is included.\n\
> \n\
> - This hook can be used together with a header provided by the system C\
> - library to implement ISO C requirements for certain macros to be\
> - predefined that describe properties of the whole implementation rather\
> - than just the compiler.",
> +This hook can be used together with a header provided by the system C\n\
> +library to implement ISO C requirements for certain macros to be\n\
> +predefined that describe properties of the whole implementation rather\n\
> +than just the compiler.",
> const char *, (void),
> hook_constcharptr_void_null)
>
> DEFHOOK
> (cxx_implicit_extern_c,
> - "Define this hook to add target-specific C++ implicit extern C functions.\
> - If this function returns true for the name of a file-scope function, that\
> - function implicitly gets extern \"C\" linkage rather than whatever language\
> - linkage the declaration would normally have. An example of such function\
> - is WinMain on Win32 targets.",
> + "Define this hook to add target-specific C++ implicit extern C functions.\n\
> +If this function returns true for the name of a file-scope function, that\n\
> +function implicitly gets extern \"C\" linkage rather than whatever
> language\n\
> +linkage the declaration would normally have. An example of such function\n\
> +is WinMain on Win32 targets.",
> bool, (const char*),
> NULL)
>
> diff --git a/gcc/common/common-target.def b/gcc/common/common-target.def
> index 1e10d4fc398..f54590a2a54 100644
> --- a/gcc/common/common-target.def
> +++ b/gcc/common/common-target.def
> @@ -64,23 +64,23 @@ DEFHOOK
>
> DEFHOOK
> (supports_split_stack,
> - "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",
> + "Whether this target supports splitting the stack when the options\n\
> +described in @var{opts} have been passed. This is called\n\
> +after options have been parsed, so the target may reject splitting\n\
> +the stack in some configurations. The default version of this hook\n\
> +returns false. If @var{report} is true, this function may issue a warning\n\
> +or error; if @var{report} is false, it must simply return a value",
> bool, (bool report, struct gcc_options *opts),
> hook_bool_bool_gcc_optionsp_false)
>
> DEFHOOK
> (get_valid_option_values,
> -"The hook is used for options that have a non-trivial list of\
> - possible option values. OPTION_CODE is option code of opt_code\
> - enum type. PREFIX is used for bash completion and allows an implementation\
> - to return more specific completion based on the prefix. All string values\
> - should be allocated from heap memory and consumers should release them. \
> - The result will be pruned to cases with PREFIX if not NULL.",
> +"The hook is used for options that have a non-trivial list of\n\
> +possible option values. OPTION_CODE is option code of opt_code\n\
> +enum type. PREFIX is used for bash completion and allows an
> implementation\n\
> +to return more specific completion based on the prefix. All string values\n\
> +should be allocated from heap memory and consumers should release them.\n\
> +The result will be pruned to cases with PREFIX if not NULL.",
> vec<const char *>, (int option_code, const char *prefix),
> default_get_valid_option_values)
>
> @@ -100,10 +100,10 @@ DEFHOOKPOD
>
> DEFHOOKPOD
> (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.",
> + "True if @file{..} components should always be removed from directory
> names\n\
> +computed relative to GCC's internal directories, false (default) if such\n\
> +components should be preserved and directory names containing them passed\n\
> +to other tools such as the linker.",
> bool, false)
>
> HOOK_VECTOR_END (C90_EMPTY_HACK)
> diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
> index e3a080e4a7c..0a6ae0b683e 100644
> --- a/gcc/doc/tm.texi
> +++ b/gcc/doc/tm.texi
> @@ -400,7 +400,10 @@ the effect you need. Overriding this macro may be
> avoidable by overriding
> @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.
> +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
> @@ -703,23 +706,40 @@ should use @code{TARGET_HANDLE_C_OPTION} instead.
> @end deftypefn
>
> @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.
> +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 {C Target Hook} void
> TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE (const char *@var{classname})
> -Declare that Objective C class @var{classname} is referenced by the current
> TU.
> +Declare that Objective C class @var{classname} is referenced
> +by the current TU.
> @end deftypefn
>
> @deftypefn {C Target Hook} void TARGET_OBJC_DECLARE_CLASS_DEFINITION (const
> char *@var{classname})
> -Declare that Objective C class @var{classname} is defined by the current TU.
> +Declare that Objective C class @var{classname} is defined
> +by the current TU.
> @end deftypefn
>
> @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.
> +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 {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.
> +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
>
> @deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
> @@ -778,7 +798,13 @@ is 0.
> @end defmac
>
> @deftypefn {Target Hook} bool TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P
> (void)
> -Returns true if the target supports IEEE 754 floating-point exceptions and
> rounding modes, false otherwise. This is intended to relate to the
> @code{float} and @code{double} types, but not necessarily @code{long double}.
> By default, returns true if the @code{adddf3} instruction pattern is
> available and false otherwise, on the assumption that hardware floating point
> supports exceptions and rounding modes but software floating point does not.
> +Returns true if the target supports IEEE 754 floating-point exceptions
> +and rounding modes, false otherwise. This is intended to relate to the
> +@code{float} and @code{double} types, but not necessarily @code{long double}.
> +By default, returns true if the @code{adddf3} instruction pattern is
> +available and false otherwise, on the assumption that hardware floating
> +point supports exceptions and rounding modes but software floating point
> +does not.
> @end deftypefn
>
> @node Per-Function Data
> @@ -953,7 +979,22 @@ Do not define this macro if it would never modify
> @var{m}.
> @end defmac
>
> @deftypefn {Target Hook} {enum flt_eval_method} TARGET_C_EXCESS_PRECISION
> (enum excess_precision_type @var{type})
> -Return a value, with the same meaning as the C99 macro
> @code{FLT_EVAL_METHOD} that describes which excess precision should be
> applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},
> @code{EXCESS_PRECISION_TYPE_FAST}, or @code{EXCESS_PRECISION_TYPE_STANDARD}.
> For @code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which
> precision and range operations will be implictly evaluated in regardless of
> the excess precision explicitly added. For
> @code{EXCESS_PRECISION_TYPE_STANDARD} and @code{EXCESS_PRECISION_TYPE_FAST},
> the target should return the explicit excess precision that should be added
> depending on the value set for
> @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}. Note that
> unpredictable explicit excess precision does not make sense, so a target
> should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE} when @var{type} is
> @code{EXCESS_PRECISION_TYPE_STANDARD} or @code{EXCESS_PRECISION_TYPE_FAST}.
> +Return a value, with the same meaning as the C99 macro
> +@code{FLT_EVAL_METHOD} that describes which excess precision should be
> +applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},
> +@code{EXCESS_PRECISION_TYPE_FAST}, or
> +@code{EXCESS_PRECISION_TYPE_STANDARD}. For
> +@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which
> +precision and range operations will be implictly evaluated in regardless
> +of the excess precision explicitly added. For
> +@code{EXCESS_PRECISION_TYPE_STANDARD} and
> +@code{EXCESS_PRECISION_TYPE_FAST}, the target should return the
> +explicit excess precision that should be added depending on the
> +value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}.
> +Note that unpredictable explicit excess precision does not make sense,
> +so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}
> +when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or
> +@code{EXCESS_PRECISION_TYPE_FAST}.
> @end deftypefn
>
> @deftypefn {Target Hook} machine_mode TARGET_PROMOTE_FUNCTION_MODE
> (const_tree @var{type}, machine_mode @var{mode}, int *@var{punsignedp},
> const_tree @var{funtype}, int @var{for_return})
> @@ -2538,7 +2579,16 @@ only if neither labeling works.
> @end defmac
>
> @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RENAME_CLASS
> (reg_class_t @var{rclass})
> -A target hook that places additional preference on the register class to use
> when it is necessary to rename a register in class @var{rclass} to another
> class, or perhaps @var{NO_REGS}, if no preferred register class is found or
> hook @code{preferred_rename_class} is not implemented. Sometimes returning a
> more restrictive class makes better code. For example, on ARM, thumb-2
> instructions using @code{LO_REGS} may be smaller than instructions using
> @code{GENERIC_REGS}. By returning @code{LO_REGS} from
> @code{preferred_rename_class}, code size can be reduced.
> +A target hook that places additional preference on the register
> +class to use when it is necessary to rename a register in class
> +@var{rclass} to another class, or perhaps @var{NO_REGS}, if no
> +preferred register class is found or hook @code{preferred_rename_class}
> +is not implemented.
> +Sometimes returning a more restrictive class makes better code. For
> +example, on ARM, thumb-2 instructions using @code{LO_REGS} may be
> +smaller than instructions using @code{GENERIC_REGS}. By returning
> +@code{LO_REGS} from @code{preferred_rename_class}, code size can
> +be reduced.
> @end deftypefn
>
> @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RELOAD_CLASS (rtx
> @var{x}, reg_class_t @var{rclass})
> @@ -2922,19 +2972,44 @@ A target hook which can change allocno class for
> given pseudo from
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_LRA_P (void)
> -A target hook which returns true if we use LRA instead of reload pass.
> The default version of this target hook returns true. New ports should use
> LRA, and existing ports are encouraged to convert.
> +A target hook which returns true if we use LRA instead of reload pass.
> +
> +The default version of this target hook returns true. New ports
> +should use LRA, and existing ports are encouraged to convert.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_REGISTER_PRIORITY (int)
> -A target hook which returns the register priority number to which the
> register @var{hard_regno} belongs to. The bigger the number, the more
> preferable the hard register usage (when all other conditions are the same).
> This hook can be used to prefer some hard register over others in LRA. For
> example, some x86-64 register usage needs additional prefix which makes
> instructions longer. The hook can return lower priority number for such
> registers make them less favorable and as result making the generated code
> smaller. The default version of this target hook returns always zero.
> +A target hook which returns the register priority number to which the
> +register @var{hard_regno} belongs to. The bigger the number, the
> +more preferable the hard register usage (when all other conditions are
> +the same). This hook can be used to prefer some hard register over
> +others in LRA. For example, some x86-64 register usage needs
> +additional prefix which makes instructions longer. The hook can
> +return lower priority number for such registers make them less favorable
> +and as result making the generated code smaller.
> +
> +The default version of this target hook returns always zero.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_REGISTER_USAGE_LEVELING_P (void)
> -A target hook which returns true if we need register usage leveling. That
> means if a few hard registers are equally good for the assignment, we choose
> the least used hard register. The register usage leveling may be profitable
> for some targets. Don't use the usage leveling for targets with conditional
> execution or targets with big register files as it hurts if-conversion and
> cross-jumping optimizations. The default version of this target hook
> returns always false.
> +A target hook which returns true if we need register usage leveling.
> +That means if a few hard registers are equally good for the
> +assignment, we choose the least used hard register. The register
> +usage leveling may be profitable for some targets. Don't use the
> +usage leveling for targets with conditional execution or targets
> +with big register files as it hurts if-conversion and cross-jumping
> +optimizations.
> +
> +The default version of this target hook returns always false.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_DIFFERENT_ADDR_DISPLACEMENT_P (void)
> -A target hook which returns true if an address with the same structure can
> have different maximal legitimate displacement. For example, the
> displacement can depend on memory mode or on operand combinations in the
> insn. The default version of this target hook returns always false.
> +A target hook which returns true if an address with the same structure
> +can have different maximal legitimate displacement. For example, the
> +displacement can depend on memory mode or on operand combinations in
> +the insn.
> +
> +The default version of this target hook returns always false.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P (rtx
> @var{subst})
> @@ -2960,19 +3035,34 @@ from the anchor in @var{offset2}. The default
> implementation returns false.
> @end deftypefn
>
> @deftypefn {Target Hook} reg_class_t TARGET_SPILL_CLASS (reg_class_t,
> @var{machine_mode})
> -This hook defines a class of registers which could be used for spilling
> pseudos of the given mode and class, or @code{NO_REGS} if only memory should
> be used. Not defining this hook is equivalent to returning @code{NO_REGS}
> for all inputs.
> +This hook defines a class of registers which could be used for spilling
> +pseudos of the given mode and class, or @code{NO_REGS} if only memory
> +should be used. Not defining this hook is equivalent to returning
> +@code{NO_REGS} for all inputs.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_ADDITIONAL_ALLOCNO_CLASS_P
> (reg_class_t)
> -This hook should return @code{true} if given class of registers should be
> an allocno class in any way. Usually RA uses only one register class from
> all classes containing the same register set. In some complicated cases,
> you need to have two or more such classes as allocno ones for RA correct
> work. Not defining this hook is equivalent to returning @code{false} for
> all inputs.
> +This hook should return @code{true} if given class of registers should
> +be an allocno class in any way. Usually RA uses only one register
> +class from all classes containing the same register set. In some
> +complicated cases, you need to have two or more such classes as
> +allocno ones for RA correct work. Not defining this hook is
> +equivalent to returning @code{false} for all inputs.
> @end deftypefn
>
> @deftypefn {Target Hook} scalar_int_mode TARGET_CSTORE_MODE (enum insn_code
> @var{icode})
> -This hook defines the machine mode to use for the boolean result of
> conditional store patterns. The ICODE argument is the instruction code for
> the cstore being performed. Not definiting this hook is the same as
> accepting the mode encoded into operand 0 of the cstore expander patterns.
> +This hook defines the machine mode to use for the boolean result of
> +conditional store patterns. The ICODE argument is the instruction code
> +for the cstore being performed. Not definiting this hook is the same
> +as accepting the mode encoded into operand 0 of the cstore expander
> +patterns.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_COMPUTE_PRESSURE_CLASSES (enum
> reg_class *@var{pressure_classes})
> -A target hook which lets a backend compute the set of pressure classes to
> be used by those optimization passes which take register pressure into
> account, as opposed to letting IRA compute them. It returns the number of
> register classes stored in the array @var{pressure_classes}.
> +A target hook which lets a backend compute the set of pressure classes to
> +be used by those optimization passes which take register pressure into
> +account, as opposed to letting IRA compute them. It returns the number of
> +register classes stored in the array @var{pressure_classes}.
> @end deftypefn
>
> @node Stack and Calling
> @@ -3505,9 +3595,12 @@ normally not need to override that default.
>
> @deftypefn {Target Hook} HOST_WIDE_INT
> TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE (void)
> Some targets have an ABI defined interval for which no probing needs to be
> done.
> -When a probe does need to be done this same interval is used as the probe
> distance up when doing stack clash protection for alloca.
> +When a probe does need to be done this same interval is used as the probe
> distance
> +up when doing stack clash protection for alloca.
> On such targets this value can be set to override the default probing up
> interval.
> -Define this variable to return nonzero if such a probe range is required or
> zero otherwise. Defining this hook also requires your functions which make
> use of alloca to have at least 8 byesof outgoing arguments. If this is not
> the case the stack will be corrupted.
> +Define this variable to return nonzero if such a probe range is required or
> zero otherwise.
> +Defining this hook also requires your functions which make use of alloca to
> have at least 8 byes
> +of outgoing arguments. If this is not the case the stack will be corrupted.
> You need not define this macro if it would always have the value zero.
> @end deftypefn
>
> @@ -4300,7 +4393,11 @@ hook returns true for both @code{ptr_mode} and
> @code{Pmode}.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_REF_MAY_ALIAS_ERRNO (ao_ref *@var{ref})
> -Define this to return nonzero if the memory reference @var{ref} may alias
> with the system C library errno location. The default version of this hook
> assumes the system C library errno location is either a declaration of type
> int or accessed by dereferencing a pointer to int.
> +Define this to return nonzero if the memory reference @var{ref}
> +may alias with the system C library errno location. The default
> +version of this hook assumes the system C library errno location
> +is either a declaration of type int or accessed by dereferencing
> +a pointer to int.
> @end deftypefn
>
> @deftypefn {Target Hook} machine_mode TARGET_TRANSLATE_MODE_ATTRIBUTE
> (machine_mode @var{mode})
> @@ -4686,11 +4783,15 @@ nothing when you use @option{-freg-struct-return}
> mode.
> @end defmac
>
> @deftypefn {Target Hook} fixed_size_mode TARGET_GET_RAW_RESULT_MODE (int
> @var{regno})
> -This target hook returns the mode to be used when accessing raw return
> registers in @code{__builtin_return}. Define this macro if the value in
> @var{reg_raw_mode} is not correct.
> +This target hook returns the mode to be used when accessing raw return
> +registers in @code{__builtin_return}. Define this macro if the value
> +in @var{reg_raw_mode} is not correct.
> @end deftypefn
>
> @deftypefn {Target Hook} fixed_size_mode TARGET_GET_RAW_ARG_MODE (int
> @var{regno})
> -This target hook returns the mode to be used when accessing raw argument
> registers in @code{__builtin_apply_args}. Define this macro if the value in
> @var{reg_raw_mode} is not correct.
> +This target hook returns the mode to be used when accessing raw argument
> +registers in @code{__builtin_apply_args}. Define this macro if the value
> +in @var{reg_raw_mode} is not correct.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_EMPTY_RECORD_P (const_tree @var{type})
> @@ -4994,7 +5095,11 @@ the function prologue. Normally, the profiling code
> comes after.
> @end defmac
>
> @deftypefn {Target Hook} bool TARGET_KEEP_LEAF_WHEN_PROFILED (void)
> -This target hook returns true if the target wants the leaf flag for the
> current function to stay true even if it calls mcount. This might make sense
> for targets using the leaf flag only to determine whether a stack frame needs
> to be generated or not and for which the call to mcount is generated before
> the function prologue.
> +This target hook returns true if the target wants the leaf flag for
> +the current function to stay true even if it calls mcount. This might
> +make sense for targets using the leaf flag only to determine whether a
> +stack frame needs to be generated or not and for which the call to
> +mcount is generated before the function prologue.
> @end deftypefn
>
> @node Tail Calls
> @@ -5024,11 +5129,14 @@ FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the
> PIC_OFFSET_TABLE_REGNUM.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_SET_UP_BY_PROLOGUE (struct
> hard_reg_set_container *@var{})
> -This hook should add additional registers that are computed by the prologue
> to the hard regset for shrink-wrapping optimization purposes.
> +This hook should add additional registers that are computed by the prologue
> +to the hard regset for shrink-wrapping optimization purposes.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_WARN_FUNC_RETURN (tree)
> -True if a function's return statements should be checked for matching the
> function's return type. This includes checking for falling off the end of a
> non-void function. Return false if no such check should be made.
> +True if a function's return statements should be checked for matching
> +the function's return type. This includes checking for falling off the end
> +of a non-void function. Return false if no such check should be made.
> @end deftypefn
>
> @node Shrink-wrapping separate components
> @@ -5119,15 +5227,26 @@ normally defined in @file{libgcc2.c}.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_STACK_PROTECT_RUNTIME_ENABLED_P (void)
> -Returns true if the target wants GCC's default stack protect runtime
> support, otherwise return false. The default implementation always returns
> true.
> +Returns true if the target wants GCC's default stack protect runtime support,
> +otherwise return false. The default implementation always returns true.
> @end deftypefn
>
> @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
> +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
>
> @deftypefn {Common Target Hook} {vec<const char *>}
> TARGET_GET_VALID_OPTION_VALUES (int @var{option_code}, const char
> *@var{prefix})
> -The hook is used for options that have a non-trivial list of possible option
> values. OPTION_CODE is option code of opt_code enum type. PREFIX is used
> for bash completion and allows an implementation to return more specific
> completion based on the prefix. All string values should be allocated from
> heap memory and consumers should release them. The result will be pruned to
> cases with PREFIX if not NULL.
> +The hook is used for options that have a non-trivial list of
> +possible option values. OPTION_CODE is option code of opt_code
> +enum type. PREFIX is used for bash completion and allows an implementation
> +to return more specific completion based on the prefix. All string values
> +should be allocated from heap memory and consumers should release them.
> +The result will be pruned to cases with PREFIX if not NULL.
> @end deftypefn
>
> @node Miscellaneous Register Hooks
> @@ -5987,7 +6106,9 @@ correct for most targets.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
> (const_tree @var{type}, bool @var{is_packed})
> -Return true if vector alignment is reachable (by peeling N iterations) for
> the given scalar type @var{type}. @var{is_packed} is false if the scalar
> access using @var{type} is known to be naturally aligned.
> +Return true if vector alignment is reachable (by peeling N iterations)
> +for the given scalar type @var{type}. @var{is_packed} is false if the scalar
> +access using @var{type} is known to be naturally aligned.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_VECTORIZE_VEC_PERM_CONST (machine_mode
> @var{mode}, rtx @var{output}, rtx @var{in0}, rtx @var{in1}, const
> vec_perm_indices @var{&sel})
> @@ -6121,19 +6242,37 @@ all zeros. GCC can then try to branch around the
> instruction instead.
> @end deftypefn
>
> @deftypefn {Target Hook} {void *} TARGET_VECTORIZE_INIT_COST (class loop
> *@var{loop_info}, bool @var{costing_for_scalar})
> -This hook should initialize target-specific data structures in preparation
> for modeling the costs of vectorizing a loop or basic block. The default
> allocates three unsigned integers for accumulating costs for the prologue,
> body, and epilogue of the loop or basic block. If @var{loop_info} is
> non-NULL, it identifies the loop being vectorized; otherwise a single block
> is being vectorized. If @var{costing_for_scalar} is true, it indicates the
> current cost model is for the scalar version of a loop or block; otherwise it
> is for the vector version.
> +This hook should initialize target-specific data structures in preparation
> +for modeling the costs of vectorizing a loop or basic block. The default
> +allocates three unsigned integers for accumulating costs for the prologue,
> +body, and epilogue of the loop or basic block. If @var{loop_info} is
> +non-NULL, it identifies the loop being vectorized; otherwise a single block
> +is being vectorized. If @var{costing_for_scalar} is true, it indicates the
> +current cost model is for the scalar version of a loop or block; otherwise
> +it is for the vector version.
> @end deftypefn
>
> @deftypefn {Target Hook} unsigned TARGET_VECTORIZE_ADD_STMT_COST (class
> vec_info *@var{}, void *@var{data}, int @var{count}, enum vect_cost_for_stmt
> @var{kind}, class _stmt_vec_info *@var{stmt_info}, tree @var{vectype}, int
> @var{misalign}, enum vect_cost_model_location @var{where})
> -This hook should update the target-specific @var{data} in response to adding
> @var{count} copies of the given @var{kind} of statement to a loop or basic
> block. The default adds the builtin vectorizer cost for the copies of the
> statement to the accumulator specified by @var{where}, (the prologue, body,
> or epilogue) and returns the amount added. The return value should be viewed
> as a tentative cost that may later be revised.
> +This hook should update the target-specific @var{data} in response to
> +adding @var{count} copies of the given @var{kind} of statement to a
> +loop or basic block. The default adds the builtin vectorizer cost for
> +the copies of the statement to the accumulator specified by @var{where},
> +(the prologue, body, or epilogue) and returns the amount added. The
> +return value should be viewed as a tentative cost that may later be
> +revised.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_VECTORIZE_FINISH_COST (void
> *@var{data}, unsigned *@var{prologue_cost}, unsigned *@var{body_cost},
> unsigned *@var{epilogue_cost})
> -This hook should complete calculations of the cost of vectorizing a loop or
> basic block based on @var{data}, and return the prologue, body, and epilogue
> costs as unsigned integers. The default returns the value of the three
> accumulators.
> +This hook should complete calculations of the cost of vectorizing a loop
> +or basic block based on @var{data}, and return the prologue, body, and
> +epilogue costs as unsigned integers. The default returns the value of
> +the three accumulators.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_VECTORIZE_DESTROY_COST_DATA (void
> *@var{data})
> -This hook should release @var{data} and any related data structures
> allocated by TARGET_VECTORIZE_INIT_COST. The default releases the
> accumulator.
> +This hook should release @var{data} and any related data structures
> +allocated by TARGET_VECTORIZE_INIT_COST. The default releases the
> +accumulator.
> @end deftypefn
>
> @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_GATHER (const_tree
> @var{mem_vectype}, const_tree @var{index_type}, int @var{scale})
> @@ -7711,7 +7850,8 @@ the string if a different section name should be used.
> @end deftypevr
>
> @deftypefn {Target Hook} {section *} TARGET_ASM_TM_CLONE_TABLE_SECTION
> (void)
> -Return the section that should be used for transactional memory clone
> tables.
> +Return the section that should be used for transactional memory clone
> +tables.
> @end deftypefn
>
> @deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_RTX_SECTION
> (machine_mode @var{mode}, rtx @var{x}, unsigned HOST_WIDE_INT @var{align})
> @@ -7985,13 +8125,18 @@ for the file format in use is appropriate.
> @end defmac
>
> @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_SOURCE_FILENAME (FILE
> *@var{file}, const char *@var{name})
> -Output DWARF debugging information which indicates that filename @var{name}
> is the current source file to the stdio stream @var{file}.
> -
> - This target hook need not be defined if the standard form of output for the
> file format in use is appropriate.
> +Output DWARF debugging information which indicates that filename
> +@var{name} is the current source file to the stdio stream @var{file}.
> +
> +This target hook need not be defined if the standard form of output
> +for the file format in use is appropriate.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_IDENT (const char
> *@var{name})
> -Output a string based on @var{name}, suitable for the @samp{#ident}
> directive, or the equivalent directive or pragma in non-C-family languages.
> If this hook is not defined, nothing is output for the @samp{#ident}
> directive.
> +Output a string based on @var{name}, suitable for the @samp{#ident}
> +directive, or the equivalent directive or pragma in non-C-family languages.
> +If this hook is not defined, nothing is output for the @samp{#ident}
> +directive.
> @end deftypefn
>
> @defmac OUTPUT_QUOTED_STRING (@var{stream}, @var{string})
> @@ -8033,7 +8178,11 @@ Return NULL if function should go to default text
> section.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS
> (FILE *@var{file}, tree @var{decl}, bool @var{new_is_cold})
> -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}.
> +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 {Common Target Hook} bool TARGET_HAVE_NAMED_SECTIONS
> @@ -8735,7 +8884,11 @@ systems. This macro is used in @code{assemble_name}.
> @end defmac
>
> @deftypefn {Target Hook} tree TARGET_MANGLE_ASSEMBLER_NAME (const char
> *@var{name})
> -Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s
> @code{assemble_name}, but in memory rather than to a file stream, returning
> result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The
> default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and
> then prepends the @code{USER_LABEL_PREFIX}, if any.
> +Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s
> +@code{assemble_name}, but in memory rather than to a file stream, returning
> +result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs. The
> +default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and
> +then prepends the @code{USER_LABEL_PREFIX}, if any.
> @end deftypefn
>
> @defmac ASM_OUTPUT_SYMBOL_REF (@var{stream}, @var{sym})
> @@ -9501,7 +9654,9 @@ The default is that no label is emitted.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_ASM_EMIT_EXCEPT_PERSONALITY (rtx
> @var{personality})
> -If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be
> used to emit a directive to install a personality hook into the unwind info.
> This hook should not be used if dwarf2 unwind info is used.
> +If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be
> +used to emit a directive to install a personality hook into the unwind
> +info. This hook should not be used if dwarf2 unwind info is used.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_ASM_UNWIND_EMIT (FILE *@var{stream},
> rtx_insn *@var{insn})
> @@ -9511,15 +9666,25 @@ returns @code{UI_TARGET}.
> @end deftypefn
>
> @deftypefn {Target Hook} rtx TARGET_ASM_MAKE_EH_SYMBOL_INDIRECT (rtx
> @var{origsymbol}, bool @var{pubvis})
> -If necessary, modify personality and LSDA references to handle indirection.
> The original symbol is in @code{origsymbol} and if @code{pubvis} is true the
> symbol is visible outside the TU.
> +If necessary, modify personality and LSDA references to handle indirection.
> +The original symbol is in @code{origsymbol} and if @code{pubvis} is true
> +the symbol is visible outside the TU.
> @end deftypefn
>
> @deftypevr {Target Hook} bool TARGET_ASM_UNWIND_EMIT_BEFORE_INSN
> -True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before the
> assembly for @var{insn} has been emitted, false if the hook should be called
> afterward.
> +True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before
> +the assembly for @var{insn} has been emitted, false if the hook should
> +be called afterward.
> @end deftypevr
>
> @deftypefn {Target Hook} bool TARGET_ASM_SHOULD_RESTORE_CFA_STATE (void)
> -For DWARF-based unwind frames, two CFI instructions provide for save and
> restore of register state. GCC maintains the current frame address (CFA)
> separately from the register bank but the unwinder in libgcc preserves this
> state along with the registers (and this is expected by the code that writes
> the unwind frames). This hook allows the target to specify that the CFA data
> is not saved/restored along with the registers by the target unwinder so that
> suitable additional instructions should be emitted to restore it.
> +For DWARF-based unwind frames, two CFI instructions provide for save and
> +restore of register state. GCC maintains the current frame address (CFA)
> +separately from the register bank but the unwinder in libgcc preserves this
> +state along with the registers (and this is expected by the code that writes
> +the unwind frames). This hook allows the target to specify that the CFA data
> +is not saved/restored along with the registers by the target unwinder so that
> +suitable additional instructions should be emitted to restore it.
> @end deftypefn
>
> @node Exception Region Output
> @@ -10124,7 +10289,9 @@ If insn length is to be regarded as reliable, set the
> hook to
> @end deftypefn
>
> @deftypevr {Target Hook} bool TARGET_WANT_DEBUG_PUB_SECTIONS
> -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.
> +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
> @@ -10307,27 +10474,52 @@ switch is needed / supplied.
> @end defmac
>
> @deftypefn {Target Hook} void TARGET_MODE_EMIT (int @var{entity}, int
> @var{mode}, int @var{prev_mode}, HARD_REG_SET @var{regs_live})
> -Generate one or more insns to set @var{entity} to @var{mode}.
> @var{hard_reg_live} is the set of hard registers live at the point where the
> insn(s) are to be inserted. @var{prev_moxde} indicates the mode to switch
> from. Sets of a lower numbered entity will be emitted before sets of a higher
> numbered entity to a mode of the same or lower priority.
> +Generate one or more insns to set @var{entity} to @var{mode}.
> +@var{hard_reg_live} is the set of hard registers live at the point where
> +the insn(s) are to be inserted. @var{prev_moxde} indicates the mode
> +to switch from. Sets of a lower numbered entity will be emitted before
> +sets of a higher numbered entity to a mode of the same or lower priority.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_MODE_NEEDED (int @var{entity}, rtx_insn
> *@var{insn})
> -@var{entity} is an integer specifying a mode-switched entity. If
> @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro to
> return an integer value not larger than the corresponding element in
> @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that @var{entity}
> must be switched into prior to the execution of @var{insn}.
> +@var{entity} is an integer specifying a mode-switched entity.
> +If @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro
> +to return an integer value not larger than the corresponding element
> +in @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that @var{entity}
> +must be switched into prior to the execution of @var{insn}.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_MODE_AFTER (int @var{entity}, int
> @var{mode}, rtx_insn *@var{insn})
> -@var{entity} is an integer specifying a mode-switched entity. If this macro
> is defined, it is evaluated for every @var{insn} during mode switching. It
> determines the mode that an insn results in (if different from the incoming
> mode).
> +@var{entity} is an integer specifying a mode-switched entity.
> +If this macro is defined, it is evaluated for every @var{insn} during mode
> +switching. It determines the mode that an insn results
> +in (if different from the incoming mode).
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_MODE_ENTRY (int @var{entity})
> -If this macro is defined, it is evaluated for every @var{entity} that needs
> mode switching. It should evaluate to an integer, which is a mode that
> @var{entity} is assumed to be switched to at function entry. If
> @code{TARGET_MODE_ENTRY} is defined then @code{TARGET_MODE_EXIT} must be
> defined.
> +If this macro is defined, it is evaluated for every @var{entity} that
> +needs mode switching. It should evaluate to an integer, which is a mode
> +that @var{entity} is assumed to be switched to at function entry.
> +If @code{TARGET_MODE_ENTRY} is defined then @code{TARGET_MODE_EXIT}
> +must be defined.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_MODE_EXIT (int @var{entity})
> -If this macro is defined, it is evaluated for every @var{entity} that needs
> mode switching. It should evaluate to an integer, which is a mode that
> @var{entity} is assumed to be switched to at function exit. If
> @code{TARGET_MODE_EXIT} is defined then @code{TARGET_MODE_ENTRY} must be
> defined.
> +If this macro is defined, it is evaluated for every @var{entity} that
> +needs mode switching. It should evaluate to an integer, which is a mode
> +that @var{entity} is assumed to be switched to at function exit.
> +If @code{TARGET_MODE_EXIT} is defined then @code{TARGET_MODE_ENTRY}
> +must be defined.
> @end deftypefn
>
> @deftypefn {Target Hook} int TARGET_MODE_PRIORITY (int @var{entity}, int
> @var{n})
> -This macro specifies the order in which modes for @var{entity} are
> processed. 0 is the highest priority,
> @code{NUM_MODES_FOR_MODE_SWITCHING[@var{entity}] - 1} the lowest. The value
> of the macro should be an integer designating a mode for @var{entity}. For
> any fixed @var{entity}, @code{mode_priority} (@var{entity}, @var{n}) shall be
> a bijection in 0 @dots{} @code{num_modes_for_mode_switching[@var{entity}] -
> 1}.
> +This macro specifies the order in which modes for @var{entity}
> +are processed. 0 is the highest priority,
> +@code{NUM_MODES_FOR_MODE_SWITCHING[@var{entity}] - 1} the lowest.
> +The value of the macro should be an integer designating a mode
> +for @var{entity}. For any fixed @var{entity}, @code{mode_priority}
> +(@var{entity}, @var{n}) shall be a bijection in 0 @dots{}
> +@code{num_modes_for_mode_switching[@var{entity}] - 1}.
> @end deftypefn
>
> @node Target Attributes
> @@ -10401,7 +10593,9 @@ to perform initial processing of the @samp{dllimport}
> and
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P
> (const_tree @var{decl})
> -@var{decl} is a variable or function with @code{__attribute__((dllimport))}
> specified. Use this hook if the target needs to add extra validation checks
> to @code{handle_dll_attribute}.
> +@var{decl} is a variable or function with @code{__attribute__((dllimport))}
> +specified. Use this hook if the target needs to add extra validation
> +checks to @code{handle_dll_attribute}.
> @end deftypefn
>
> @defmac TARGET_DECLSPEC
> @@ -10516,7 +10710,9 @@ specific target options and the caller does not use
> the same options.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_RELAYOUT_FUNCTION (tree @var{fndecl})
> -This target hook fixes function @var{fndecl} after attributes are processed.
> Default does nothing. On ARM, the default function's alignment is updated
> with the attribute target.
> +This target hook fixes function @var{fndecl} after attributes are processed.
> +Default does nothing. On ARM, the default function's alignment is updated
> +with the attribute target.
> @end deftypefn
>
> @node Emulated TLS
> @@ -10720,7 +10916,12 @@ method. The default is to return @code{true}.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
> (tree @var{decl})
> -@var{decl} is a virtual table, virtual table table, typeinfo object, or
> other similar implicit class data object that will be emitted with external
> linkage in this translation unit. No ELF visibility has been explicitly
> specified. If the target needs to specify a visibility other than that of
> the containing class, use this hook to set @code{DECL_VISIBILITY} and
> @code{DECL_VISIBILITY_SPECIFIED}.
> +@var{decl} is a virtual table, virtual table table, typeinfo object,
> +or other similar implicit class data object that will be emitted with
> +external linkage in this translation unit. No ELF visibility has been
> +explicitly specified. If the target needs to specify a visibility
> +other than that of the containing class, use this hook to set
> +@code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT (void)
> @@ -10752,7 +10953,9 @@ unloaded. The default is to return false.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_CXX_ADJUST_CLASS_AT_DEFINITION (tree
> @var{type})
> -@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).
> +@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})
> @@ -11359,13 +11562,24 @@ files @code{__STDC__} will always expand to 1.
> @end defmac
>
> @deftypefn {C Target Hook} {const char *} TARGET_C_PREINCLUDE (void)
> -Define this hook to return the name of a header file to be included at the
> start of all compilations, as if it had been included with @code{#include
> <@var{file}>}. If this hook returns @code{NULL}, or is not defined, or the
> header is not found, or if the user specifies @option{-ffreestanding} or
> @option{-nostdinc}, no header is included.
> +Define this hook to return the name of a header file to be included at
> +the start of all compilations, as if it had been included with
> +@code{#include <@var{file}>}. If this hook returns @code{NULL}, or is
> +not defined, or the header is not found, or if the user specifies
> +@option{-ffreestanding} or @option{-nostdinc}, no header is included.
>
> - This hook can be used together with a header provided by the system C
> library to implement ISO C requirements for certain macros to be predefined
> that describe properties of the whole implementation rather than just the
> compiler.
> +This hook can be used together with a header provided by the system C
> +library to implement ISO C requirements for certain macros to be
> +predefined that describe properties of the whole implementation rather
> +than just the compiler.
> @end deftypefn
>
> @deftypefn {C Target Hook} bool TARGET_CXX_IMPLICIT_EXTERN_C (const
> char*@var{})
> -Define this hook to add target-specific C++ implicit extern C functions. If
> this function returns true for the name of a file-scope function, that
> function implicitly gets extern "C" linkage rather than whatever language
> linkage the declaration would normally have. An example of such function is
> WinMain on Win32 targets.
> +Define this hook to add target-specific C++ implicit extern C functions.
> +If this function returns true for the name of a file-scope function, that
> +function implicitly gets extern "C" linkage rather than whatever language
> +linkage the declaration would normally have. An example of such function
> +is WinMain on Win32 targets.
> @end deftypefn
>
> @defmac SYSTEM_IMPLICIT_EXTERN_C
> @@ -11763,11 +11977,17 @@ loops containing function calls or branch on table
> instructions.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_LEGITIMATE_COMBINED_INSN (rtx_insn
> *@var{insn})
> -Take an instruction in @var{insn} and return @code{false} if the instruction
> is not appropriate as a combination of two or more instructions. The default
> is to accept all instructions.
> +Take an instruction in @var{insn} and return @code{false} if the instruction
> +is not appropriate as a combination of two or more instructions. The
> +default is to accept all instructions.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_CAN_FOLLOW_JUMP (const rtx_insn
> *@var{follower}, const rtx_insn *@var{followee})
> -FOLLOWER and FOLLOWEE are JUMP_INSN instructions; return true if FOLLOWER
> may be modified to follow FOLLOWEE; false, if it can't. For example, on
> some targets, certain kinds of branches can't be made to follow through a
> hot/cold partitioning.
> +FOLLOWER and FOLLOWEE are JUMP_INSN instructions;
> +return true if FOLLOWER may be modified to follow FOLLOWEE;
> +false, if it can't.
> +For example, on some targets, certain kinds of branches can't be made to
> +follow through a hot/cold partitioning.
> @end deftypefn
>
> @deftypefn {Target Hook} bool TARGET_COMMUTATIVE_P (const_rtx @var{x}, int
> @var{outer_code})
> @@ -12107,7 +12327,9 @@ memory model bits are allowed.
> @end deftypefn
>
> @deftypevr {Target Hook} {unsigned char} TARGET_ATOMIC_TEST_AND_SET_TRUEVAL
> -This value should be set if the result written by @code{atomic_test_and_set}
> is not exactly 1, i.e.@: the @code{bool} @code{true}.
> +This value should be set if the result written by
> +@code{atomic_test_and_set} is not exactly 1, i.e.@: the
> +@code{bool} @code{true}.
> @end deftypevr
>
> @deftypefn {Target Hook} bool TARGET_HAS_IFUNC_P (void)
> @@ -12117,11 +12339,27 @@ The default value of this hook is based on target's
> libc.
> @end deftypefn
>
> @deftypefn {Target Hook} {unsigned int} TARGET_ATOMIC_ALIGN_FOR_MODE
> (machine_mode @var{mode})
> -If defined, this function returns an appropriate alignment in bits for an
> atomic object of machine_mode @var{mode}. If 0 is returned then the default
> alignment for the specified mode is used.
> +If defined, this function returns an appropriate alignment in bits for an
> +atomic object of machine_mode @var{mode}. If 0 is returned then the
> +default alignment for the specified mode is used.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_ATOMIC_ASSIGN_EXPAND_FENV (tree
> *@var{hold}, tree *@var{clear}, tree *@var{update})
> -ISO C11 requires atomic compound assignments that may raise floating-point
> exceptions to raise exceptions corresponding to the arithmetic operation
> whose result was successfully stored in a compare-and-exchange sequence.
> This requires code equivalent to calls to @code{feholdexcept},
> @code{feclearexcept} and @code{feupdateenv} to be generated at appropriate
> points in the compare-and-exchange sequence. This hook should set
> @code{*@var{hold}} to an expression equivalent to the call to
> @code{feholdexcept}, @code{*@var{clear}} to an expression equivalent to the
> call to @code{feclearexcept} and @code{*@var{update}} to an expression
> equivalent to the call to @code{feupdateenv}. The three expressions are
> @code{NULL_TREE} on entry to the hook and may be left as @code{NULL_TREE} if
> no code is required in a particular place. The default implementation leaves
> all three expressions as @code{NULL_TREE}. The @code{__atomic_feraiseexcept}
> function from @code{libatomic} may be of use as part of the code generated in
> @code{*@var{update}}.
> +ISO C11 requires atomic compound assignments that may raise floating-point
> +exceptions to raise exceptions corresponding to the arithmetic operation
> +whose result was successfully stored in a compare-and-exchange sequence.
> +This requires code equivalent to calls to @code{feholdexcept},
> +@code{feclearexcept} and @code{feupdateenv} to be generated at
> +appropriate points in the compare-and-exchange sequence. This hook should
> +set @code{*@var{hold}} to an expression equivalent to the call to
> +@code{feholdexcept}, @code{*@var{clear}} to an expression equivalent to
> +the call to @code{feclearexcept} and @code{*@var{update}} to an expression
> +equivalent to the call to @code{feupdateenv}. The three expressions are
> +@code{NULL_TREE} on entry to the hook and may be left as @code{NULL_TREE}
> +if no code is required in a particular place. The default implementation
> +leaves all three expressions as @code{NULL_TREE}. The
> +@code{__atomic_feraiseexcept} function from @code{libatomic} may be of use
> +as part of the code generated in @code{*@var{update}}.
> @end deftypefn
>
> @deftypefn {Target Hook} void TARGET_RECORD_OFFLOAD_SYMBOL (tree)
> diff --git a/gcc/target.def b/gcc/target.def
> index 1dffedc81e4..ebe5803109b 100644
> --- a/gcc/target.def
> +++ b/gcc/target.def
> @@ -179,9 +179,9 @@ The default is that no label is emitted.",
> /* Emit a directive for setting the personality for the function. */
> DEFHOOK
> (emit_except_personality,
> - "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\
> - used to emit a directive to install a personality hook into the unwind\
> - info. This hook should not be used if dwarf2 unwind info is used.",
> + "If the target implements @code{TARGET_ASM_UNWIND_EMIT}, this hook may be\n\
> +used to emit a directive to install a personality hook into the unwind\n\
> +info. This hook should not be used if dwarf2 unwind info is used.",
> void, (rtx personality),
> NULL)
>
> @@ -189,9 +189,9 @@ DEFHOOK
> indirection. This is used when the assembler supports CFI directives.
> */
> DEFHOOK
> (make_eh_symbol_indirect,
> - "If necessary, modify personality and LSDA references to handle
> indirection.\
> - The original symbol is in @code{origsymbol} and if @code{pubvis} is true\
> - the symbol is visible outside the TU.",
> + "If necessary, modify personality and LSDA references to handle
> indirection.\n\
> +The original symbol is in @code{origsymbol} and if @code{pubvis} is true\n\
> +the symbol is visible outside the TU.",
> rtx, (rtx origsymbol, bool pubvis),
> NULL)
>
> @@ -206,22 +206,22 @@ returns @code{UI_TARGET}.",
>
> DEFHOOKPOD
> (unwind_emit_before_insn,
> - "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\
> - the assembly for @var{insn} has been emitted, false if the hook should\
> - be called afterward.",
> + "True if the @code{TARGET_ASM_UNWIND_EMIT} hook should be called before\n\
> +the assembly for @var{insn} has been emitted, false if the hook should\n\
> +be called afterward.",
> bool, true)
>
> /* Return true if the target needs extra instructions to restore the current
> frame address after a DW_CFA_restore_state opcode. */
> DEFHOOK
> (should_restore_cfa_state,
> - "For DWARF-based unwind frames, two CFI instructions provide for save and\
> - restore of register state. GCC maintains the current frame address (CFA)\
> - separately from the register bank but the unwinder in libgcc preserves this\
> - state along with the registers (and this is expected by the code that
> writes\
> - the unwind frames). This hook allows the target to specify that the CFA
> data\
> - is not saved/restored along with the registers by the target unwinder so
> that\
> - suitable additional instructions should be emitted to restore it.",
> + "For DWARF-based unwind frames, two CFI instructions provide for save and\n\
> +restore of register state. GCC maintains the current frame address (CFA)\n\
> +separately from the register bank but the unwinder in libgcc preserves
> this\n\
> +state along with the registers (and this is expected by the code that
> writes\n\
> +the unwind frames). This hook allows the target to specify that the CFA
> data\n\
> +is not saved/restored along with the registers by the target unwinder so
> that\n\
> +suitable additional instructions should be emitted to restore it.",
> bool, (void),
> hook_bool_void_false)
>
> @@ -483,11 +483,11 @@ Return NULL if function should go to default text
> section.",
> /* Output the assembler code for function exit. */
> DEFHOOK
> (function_switched_text_sections,
> - "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}.",
> + "Used by the target to emit any assembler directives or additional\n\
> +labels needed when a function is partitioned between different\n\
> +sections. Output should be written to @var{file}. The function\n\
> +decl is available as @var{decl} and the new section is `cold' if\n\
> +@var{new_is_cold} is @code{true}.",
> void, (FILE *file, tree decl, bool new_is_cold),
> default_function_switched_text_sections)
>
> @@ -599,8 +599,8 @@ the string if a different section name should be used.",
> /* Return the section to be used for transactional memory clone tables. */
> DEFHOOK
> (tm_clone_table_section,
> - "Return the section that should be used for transactional memory clone\
> - tables.",
> + "Return the section that should be used for transactional memory clone\n\
> +tables.",
> section *, (void), default_clone_table_section)
>
> /* Output a constructor for a symbol with a given priority. */
> @@ -810,10 +810,10 @@ is @code{NULL}, which disables the use of section
> anchors altogether.",
>
> DEFHOOK
> (output_ident,
> - "Output a string based on @var{name}, suitable for the @samp{#ident} \
> - directive, or the equivalent directive or pragma in non-C-family languages.
> \
> - If this hook is not defined, nothing is output for the @samp{#ident} \
> - directive.",
> + "Output a string based on @var{name}, suitable for the @samp{#ident}\n\
> +directive, or the equivalent directive or pragma in non-C-family
> languages.\n\
> +If this hook is not defined, nothing is output for the @samp{#ident}\n\
> +directive.",
> void, (const char *name),
> hook_void_constcharptr)
>
> @@ -858,11 +858,11 @@ to generate it on the spot.",
>
> DEFHOOK
> (output_source_filename,
> - "Output DWARF debugging information which indicates that filename\
> - @var{name} is the current source file to the stdio stream @var{file}.\n\
> - \n\
> - This target hook need not be defined if the standard form of output\
> - for the file format in use is appropriate.",
> + "Output DWARF debugging information which indicates that filename\n\
> +@var{name} is the current source file to the stdio stream @var{file}.\n\
> +\n\
> +This target hook need not be defined if the standard form of output\n\
> +for the file format in use is appropriate.",
> void ,(FILE *file, const char *name),
> default_asm_output_source_filename)
>
> @@ -918,11 +918,11 @@ DEFHOOK_UNDOC
> ASM_OUTPUT_LABELREF, returning result as an IDENTIFIER_NODE. */
> DEFHOOK
> (mangle_assembler_name,
> - "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\
> - @code{assemble_name}, but in memory rather than to a file stream, returning\
> - result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs.
> The\
> - default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and\
> - then prepends the @code{USER_LABEL_PREFIX}, if any.",
> + "Given a symbol @var{name}, perform same mangling as @code{varasm.c}'s\n\
> +@code{assemble_name}, but in memory rather than to a file stream,
> returning\n\
> +result as an @code{IDENTIFIER_NODE}. Required for correct LTO symtabs.
> The\n\
> +default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook
> and\n\
> +then prepends the @code{USER_LABEL_PREFIX}, if any.",
> tree, (const char *name),
> default_mangle_assembler_name)
>
> @@ -1848,7 +1848,9 @@ correct for most targets.",
> iterations) for the given scalar type. */
> DEFHOOK
> (vector_alignment_reachable,
> - "Return true if vector alignment is reachable (by peeling N iterations) for
> the given scalar type @var{type}. @var{is_packed} is false if the scalar
> access using @var{type} is known to be naturally aligned.",
> + "Return true if vector alignment is reachable (by peeling N iterations)\n\
> +for the given scalar type @var{type}. @var{is_packed} is false if the
> scalar\n\
> +access using @var{type} is known to be naturally aligned.",
> bool, (const_tree type, bool is_packed),
> default_builtin_vector_alignment_reachable)
>
> @@ -2029,14 +2031,14 @@ stores.",
> /* Target function to initialize the cost model for a loop or block. */
> DEFHOOK
> (init_cost,
> - "This hook should initialize target-specific data structures in preparation
> "
> - "for modeling the costs of vectorizing a loop or basic block. The default "
> - "allocates three unsigned integers for accumulating costs for the prologue,
> "
> - "body, and epilogue of the loop or basic block. If @var{loop_info} is "
> - "non-NULL, it identifies the loop being vectorized; otherwise a single
> block "
> - "is being vectorized. If @var{costing_for_scalar} is true, it indicates
> the "
> - "current cost model is for the scalar version of a loop or block; otherwise
> "
> - "it is for the vector version.",
> + "This hook should initialize target-specific data structures in
> preparation\n\
> +for modeling the costs of vectorizing a loop or basic block. The default\n\
> +allocates three unsigned integers for accumulating costs for the prologue,\n\
> +body, and epilogue of the loop or basic block. If @var{loop_info} is\n\
> +non-NULL, it identifies the loop being vectorized; otherwise a single
> block\n\
> +is being vectorized. If @var{costing_for_scalar} is true, it indicates
> the\n\
> +current cost model is for the scalar version of a loop or block; otherwise\n\
> +it is for the vector version.",
> void *,
> (class loop *loop_info, bool costing_for_scalar),
> default_init_cost)
> @@ -2046,13 +2048,13 @@ DEFHOOK
> block. */
> DEFHOOK
> (add_stmt_cost,
> - "This hook should update the target-specific @var{data} in response to "
> - "adding @var{count} copies of the given @var{kind} of statement to a "
> - "loop or basic block. The default adds the builtin vectorizer cost for "
> - "the copies of the statement to the accumulator specified by @var{where}, "
> - "(the prologue, body, or epilogue) and returns the amount added. The "
> - "return value should be viewed as a tentative cost that may later be "
> - "revised.",
> + "This hook should update the target-specific @var{data} in response to\n\
> +adding @var{count} copies of the given @var{kind} of statement to a\n\
> +loop or basic block. The default adds the builtin vectorizer cost for\n\
> +the copies of the statement to the accumulator specified by @var{where},\n\
> +(the prologue, body, or epilogue) and returns the amount added. The\n\
> +return value should be viewed as a tentative cost that may later be\n\
> +revised.",
> unsigned,
> (class vec_info *, void *data, int count, enum vect_cost_for_stmt kind,
> class _stmt_vec_info *stmt_info, tree vectype, int misalign,
> @@ -2063,10 +2065,10 @@ DEFHOOK
> loop or block. */
> DEFHOOK
> (finish_cost,
> - "This hook should complete calculations of the cost of vectorizing a loop "
> - "or basic block based on @var{data}, and return the prologue, body, and "
> - "epilogue costs as unsigned integers. The default returns the value of "
> - "the three accumulators.",
> + "This hook should complete calculations of the cost of vectorizing a loop\n\
> +or basic block based on @var{data}, and return the prologue, body, and\n\
> +epilogue costs as unsigned integers. The default returns the value of\n\
> +the three accumulators.",
> void,
> (void *data, unsigned *prologue_cost, unsigned *body_cost,
> unsigned *epilogue_cost),
> @@ -2075,9 +2077,9 @@ DEFHOOK
> /* Function to delete target-specific cost modeling data. */
> DEFHOOK
> (destroy_cost_data,
> - "This hook should release @var{data} and any related data structures "
> - "allocated by TARGET_VECTORIZE_INIT_COST. The default releases the "
> - "accumulator.",
> + "This hook should release @var{data} and any related data structures\n\
> +allocated by TARGET_VECTORIZE_INIT_COST. The default releases the\n\
> +accumulator.",
> void,
> (void *data),
> default_destroy_cost_data)
> @@ -2349,13 +2351,13 @@ DEFHOOK_UNDOC
>
> DEFHOOK
> (float_exceptions_rounding_supported_p,
> - "Returns true if the target supports IEEE 754 floating-point exceptions\
> - and rounding modes, false otherwise. This is intended to relate to the\
> - @code{float} and @code{double} types, but not necessarily @code{long
> double}.\
> - By default, returns true if the @code{adddf3} instruction pattern is\
> - available and false otherwise, on the assumption that hardware floating\
> - point supports exceptions and rounding modes but software floating point\
> - does not.",
> + "Returns true if the target supports IEEE 754 floating-point exceptions\n\
> +and rounding modes, false otherwise. This is intended to relate to the\n\
> +@code{float} and @code{double} types, but not necessarily @code{long
> double}.\n\
> +By default, returns true if the @code{adddf3} instruction pattern is\n\
> +available and false otherwise, on the assumption that hardware floating\n\
> +point supports exceptions and rounding modes but software floating point\n\
> +does not.",
> bool, (void),
> default_float_exceptions_rounding_supported_p)
>
> @@ -2678,11 +2680,11 @@ cannot_modify_jumps_past_reload_p ()\n\
> /* True if FOLLOWER may be modified to follow FOLLOWEE. */
> DEFHOOK
> (can_follow_jump,
> - "FOLLOWER and FOLLOWEE are JUMP_INSN instructions;\
> - return true if FOLLOWER may be modified to follow FOLLOWEE;\
> - false, if it can't.\
> - For example, on some targets, certain kinds of branches can't be made to\
> - follow through a hot/cold partitioning.",
> + "FOLLOWER and FOLLOWEE are JUMP_INSN instructions;\n\
> +return true if FOLLOWER may be modified to follow FOLLOWEE;\n\
> +false, if it can't.\n\
> +For example, on some targets, certain kinds of branches can't be made to\n\
> +follow through a hot/cold partitioning.",
> bool, (const rtx_insn *follower, const rtx_insn *followee),
> hook_bool_const_rtx_insn_const_rtx_insn_true)
>
> @@ -3064,11 +3066,11 @@ The default version of this hook use the target
> macro\n\
> enabled. */
> DEFHOOK
> (keep_leaf_when_profiled,
> - "This target hook returns true if the target wants the leaf flag for\
> - the current function to stay true even if it calls mcount. This might\
> - make sense for targets using the leaf flag only to determine whether a\
> - stack frame needs to be generated or not and for which the call to\
> - mcount is generated before the function prologue.",
> + "This target hook returns true if the target wants the leaf flag for\n\
> +the current function to stay true even if it calls mcount. This might\n\
> +make sense for targets using the leaf flag only to determine whether a\n\
> +stack frame needs to be generated or not and for which the call to\n\
> +mcount is generated before the function prologue.",
> bool, (void),
> default_keep_leaf_when_profiled)
>
> @@ -3232,7 +3234,7 @@ In order to enforce the representation of
> @code{mode},\n\
> int, (scalar_int_mode mode, scalar_int_mode rep_mode),
> default_mode_rep_extended)
>
> - DEFHOOK
> +DEFHOOK
> (setjmp_preserves_nonvolatile_regs_p,
> "On some targets, it is assumed that the compiler will spill all pseudos\n\
> that are live across a call to @code{setjmp}, while other targets treat\n\
> @@ -3259,11 +3261,11 @@ hook returns true for both @code{ptr_mode} and
> @code{Pmode}.",
> /* Disambiguate with errno. */
> DEFHOOK
> (ref_may_alias_errno,
> - "Define this to return nonzero if the memory reference @var{ref}\
> - may alias with the system C library errno location. The default\
> - version of this hook assumes the system C library errno location\
> - is either a declaration of type int or accessed by dereferencing\
> - a pointer to int.",
> + "Define this to return nonzero if the memory reference @var{ref}\n\
> +may alias with the system C library errno location. The default\n\
> +version of this hook assumes the system C library errno location\n\
> +is either a declaration of type int or accessed by dereferencing\n\
> +a pointer to int.",
> bool, (ao_ref *ref),
> default_ref_may_alias_errno)
>
> @@ -3936,7 +3938,8 @@ such as certain MIPS architectures possess both
> branches with and without\n\
> delay slots. As the eager delay slot filler can decrease performance,\n\
> disabling it is beneficial when ordinary branches are available. Use of\n\
> delay slot branches filled using the basic filler is often still
> desirable\n\
> -as the delay slot can hide a pipeline bubble.", bool, (void),
> +as the delay slot can hide a pipeline bubble.",
> + bool, (void),
> hook_bool_void_false)
>
> /* Return where to allocate pseudo for a given hard register initial value.
> */
> @@ -4330,8 +4333,8 @@ normally defined in @file{libgcc2.c}.",
> protector runtime support. */
> DEFHOOK
> (stack_protect_runtime_enabled_p,
> - "Returns true if the target wants GCC's default stack protect runtime
> support,\
> - otherwise return false. The default implementation always returns true.",
> + "Returns true if the target wants GCC's default stack protect runtime
> support,\n\
> +otherwise return false. The default implementation always returns true.",
> bool, (void),
> hook_bool_void_true)
>
> @@ -4454,17 +4457,17 @@ loops containing function calls or branch on table
> instructions.",
> /* Returns true for a legitimate combined insn. */
> DEFHOOK
> (legitimate_combined_insn,
> -"Take an instruction in @var{insn} and return @code{false} if the
> instruction\
> - is not appropriate as a combination of two or more instructions. The\
> - default is to accept all instructions.",
> +"Take an instruction in @var{insn} and return @code{false} if the
> instruction\n\
> +is not appropriate as a combination of two or more instructions. The\n\
> +default is to accept all instructions.",
> bool, (rtx_insn *insn),
> hook_bool_rtx_insn_true)
>
> DEFHOOK
> (valid_dllimport_attribute_p,
> -"@var{decl} is a variable or function with @code{__attribute__((dllimport))}\
> - specified. Use this hook if the target needs to add extra validation\
> - checks to @code{handle_dll_attribute}.",
> +"@var{decl} is a variable or function with
> @code{__attribute__((dllimport))}\n\
> +specified. Use this hook if the target needs to add extra validation\n\
> +checks to @code{handle_dll_attribute}.",
> bool, (const_tree decl),
> hook_bool_const_tree_true)
>
> @@ -5256,7 +5259,7 @@ HPPA or IA-64.\n\
> \n\
> Using descriptors for nested functions\n\
> eliminates the need for trampolines that reside on the stack and require\n\
> -it to be made executable.",\
> +it to be made executable.",
> int, -1)
>
> /* Return the number of bytes of its own arguments that a function
> @@ -5307,9 +5310,9 @@ number of arguments.",
> returned. */
> DEFHOOK
> (get_raw_result_mode,
> - "This target hook returns the mode to be used when accessing raw return\
> - registers in @code{__builtin_return}. Define this macro if the value\
> - in @var{reg_raw_mode} is not correct.",
> + "This target hook returns the mode to be used when accessing raw return\n\
> +registers in @code{__builtin_return}. Define this macro if the value\n\
> +in @var{reg_raw_mode} is not correct.",
> fixed_size_mode, (int regno),
> default_get_reg_raw_mode)
>
> @@ -5317,9 +5320,9 @@ DEFHOOK
> passed. */
> DEFHOOK
> (get_raw_arg_mode,
> - "This target hook returns the mode to be used when accessing raw argument\
> - registers in @code{__builtin_apply_args}. Define this macro if the value\
> - in @var{reg_raw_mode} is not correct.",
> + "This target hook returns the mode to be used when accessing raw argument\n\
> +registers in @code{__builtin_apply_args}. Define this macro if the value\n\
> +in @var{reg_raw_mode} is not correct.",
> fixed_size_mode, (int regno),
> default_get_reg_raw_mode)
>
> @@ -5476,53 +5479,53 @@ DEFHOOK
> /* Return true if we use LRA instead of reload. */
> DEFHOOK
> (lra_p,
> - "A target hook which returns true if we use LRA instead of reload pass.\
> - \
> - The default version of this target hook returns true. New ports\
> - should use LRA, and existing ports are encouraged to convert.",
> + "A target hook which returns true if we use LRA instead of reload pass.\n\
> +\n\
> +The default version of this target hook returns true. New ports\n\
> +should use LRA, and existing ports are encouraged to convert.",
> bool, (void),
> default_lra_p)
>
> /* Return register priority of given hard regno for the current target. */
> DEFHOOK
> (register_priority,
> - "A target hook which returns the register priority number to which the\
> - register @var{hard_regno} belongs to. The bigger the number, the\
> - more preferable the hard register usage (when all other conditions are\
> - the same). This hook can be used to prefer some hard register over\
> - others in LRA. For example, some x86-64 register usage needs\
> - additional prefix which makes instructions longer. The hook can\
> - return lower priority number for such registers make them less favorable\
> - and as result making the generated code smaller.\
> - \
> - The default version of this target hook returns always zero.",
> + "A target hook which returns the register priority number to which the\n\
> +register @var{hard_regno} belongs to. The bigger the number, the\n\
> +more preferable the hard register usage (when all other conditions are\n\
> +the same). This hook can be used to prefer some hard register over\n\
> +others in LRA. For example, some x86-64 register usage needs\n\
> +additional prefix which makes instructions longer. The hook can\n\
> +return lower priority number for such registers make them less favorable\n\
> +and as result making the generated code smaller.\n\
> +\n\
> +The default version of this target hook returns always zero.",
> int, (int),
> default_register_priority)
>
> /* Return true if we need register usage leveling. */
> DEFHOOK
> (register_usage_leveling_p,
> - "A target hook which returns true if we need register usage leveling.\
> - That means if a few hard registers are equally good for the\
> - assignment, we choose the least used hard register. The register\
> - usage leveling may be profitable for some targets. Don't use the\
> - usage leveling for targets with conditional execution or targets\
> - with big register files as it hurts if-conversion and cross-jumping\
> - optimizations.\
> - \
> - The default version of this target hook returns always false.",
> + "A target hook which returns true if we need register usage leveling.\n\
> +That means if a few hard registers are equally good for the\n\
> +assignment, we choose the least used hard register. The register\n\
> +usage leveling may be profitable for some targets. Don't use the\n\
> +usage leveling for targets with conditional execution or targets\n\
> +with big register files as it hurts if-conversion and cross-jumping\n\
> +optimizations.\n\
> +\n\
> +The default version of this target hook returns always false.",
> bool, (void),
> default_register_usage_leveling_p)
>
> /* Return true if maximal address displacement can be different. */
> DEFHOOK
> (different_addr_displacement_p,
> - "A target hook which returns true if an address with the same structure\
> - can have different maximal legitimate displacement. For example, the\
> - displacement can depend on memory mode or on operand combinations in\
> - the insn.\
> - \
> - The default version of this target hook returns always false.",
> + "A target hook which returns true if an address with the same structure\n\
> +can have different maximal legitimate displacement. For example, the\n\
> +displacement can depend on memory mode or on operand combinations in\n\
> +the insn.\n\
> +\n\
> +The default version of this target hook returns always false.",
> bool, (void),
> default_different_addr_displacement_p)
>
> @@ -5530,32 +5533,32 @@ DEFHOOK
> instead of memory. */
> DEFHOOK
> (spill_class,
> - "This hook defines a class of registers which could be used for spilling\
> - pseudos of the given mode and class, or @code{NO_REGS} if only memory\
> - should be used. Not defining this hook is equivalent to returning\
> - @code{NO_REGS} for all inputs.",
> + "This hook defines a class of registers which could be used for spilling\n\
> +pseudos of the given mode and class, or @code{NO_REGS} if only memory\n\
> +should be used. Not defining this hook is equivalent to returning\n\
> +@code{NO_REGS} for all inputs.",
> reg_class_t, (reg_class_t, machine_mode),
> NULL)
>
> /* Determine an additional allocno class. */
> DEFHOOK
> (additional_allocno_class_p,
> - "This hook should return @code{true} if given class of registers should\
> - be an allocno class in any way. Usually RA uses only one register\
> - class from all classes containing the same register set. In some\
> - complicated cases, you need to have two or more such classes as\
> - allocno ones for RA correct work. Not defining this hook is\
> - equivalent to returning @code{false} for all inputs.",
> + "This hook should return @code{true} if given class of registers should\n\
> +be an allocno class in any way. Usually RA uses only one register\n\
> +class from all classes containing the same register set. In some\n\
> +complicated cases, you need to have two or more such classes as\n\
> +allocno ones for RA correct work. Not defining this hook is\n\
> +equivalent to returning @code{false} for all inputs.",
> bool, (reg_class_t),
> hook_bool_reg_class_t_false)
>
> DEFHOOK
> (cstore_mode,
> - "This hook defines the machine mode to use for the boolean result of\
> - conditional store patterns. The ICODE argument is the instruction code\
> - for the cstore being performed. Not definiting this hook is the same\
> - as accepting the mode encoded into operand 0 of the cstore expander\
> - patterns.",
> + "This hook defines the machine mode to use for the boolean result of\n\
> +conditional store patterns. The ICODE argument is the instruction code\n\
> +for the cstore being performed. Not definiting this hook is the same\n\
> +as accepting the mode encoded into operand 0 of the cstore expander\n\
> +patterns.",
> scalar_int_mode, (enum insn_code icode),
> default_cstore_mode)
>
> @@ -5563,10 +5566,10 @@ DEFHOOK
> classes to use. */
> DEFHOOK
> (compute_pressure_classes,
> - "A target hook which lets a backend compute the set of pressure classes to\
> - be used by those optimization passes which take register pressure into\
> - account, as opposed to letting IRA compute them. It returns the number of\
> - register classes stored in the array @var{pressure_classes}.",
> + "A target hook which lets a backend compute the set of pressure classes
> to\n\
> +be used by those optimization passes which take register pressure into\n\
> +account, as opposed to letting IRA compute them. It returns the number of\n\
> +register classes stored in the array @var{pressure_classes}.",
> int, (enum reg_class *pressure_classes), NULL)
>
> /* True if a structure, union or array with MODE containing FIELD should
> @@ -5590,7 +5593,7 @@ Normally, this is not needed.",
> DEFHOOK
> (expand_divmod_libfunc,
> "Define this hook for enabling divmod transform if the port does not
> have\n\
> -hardware divmod insn but defines target-specific divmod libfuncs.",
> +hardware divmod insn but defines target-specific divmod libfuncs.",
> void, (rtx libfunc, machine_mode mode, rtx op0, rtx op1, rtx *quot, rtx
> *rem),
> NULL)
>
> @@ -5830,16 +5833,16 @@ in words.",
>
> DEFHOOK
> (preferred_rename_class,
> - "A target hook that places additional preference on the register\
> - class to use when it is necessary to rename a register in class\
> - @var{rclass} to another class, or perhaps @var{NO_REGS}, if no\
> - preferred register class is found or hook @code{preferred_rename_class}\
> - is not implemented.\
> - Sometimes returning a more restrictive class makes better code. For\
> - example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\
> - smaller than instructions using @code{GENERIC_REGS}. By returning\
> - @code{LO_REGS} from @code{preferred_rename_class}, code size can\
> - be reduced.",
> + "A target hook that places additional preference on the register\n\
> +class to use when it is necessary to rename a register in class\n\
> +@var{rclass} to another class, or perhaps @var{NO_REGS}, if no\n\
> +preferred register class is found or hook @code{preferred_rename_class}\n\
> +is not implemented.\n\
> +Sometimes returning a more restrictive class makes better code. For\n\
> +example, on ARM, thumb-2 instructions using @code{LO_REGS} may be\n\
> +smaller than instructions using @code{GENERIC_REGS}. By returning\n\
> +@code{LO_REGS} from @code{preferred_rename_class}, code size can\n\
> +be reduced.",
> reg_class_t, (reg_class_t rclass),
> default_preferred_rename_class)
>
> @@ -6145,11 +6148,11 @@ these registers when the target switches are opposed
> to them.)",
> DEFHOOK
> (stack_clash_protection_alloca_probe_range,
> "Some targets have an ABI defined interval for which no probing needs to
> be done.\n\
> -When a probe does need to be done this same interval is used as the probe
> distance \
> +When a probe does need to be done this same interval is used as the probe
> distance\n\
> up when doing stack clash protection for alloca.\n\
> On such targets this value can be set to override the default probing up
> interval.\n\
> -Define this variable to return nonzero if such a probe range is required or
> zero otherwise. \
> -Defining this hook also requires your functions which make use of alloca to
> have at least 8 byes\
> +Define this variable to return nonzero if such a probe range is required or
> zero otherwise.\n\
> +Defining this hook also requires your functions which make use of alloca to
> have at least 8 byes\n\
> of outgoing arguments. If this is not the case the stack will be
> corrupted.\n\
> You need not define this macro if it would always have the value zero.",
> HOST_WIDE_INT, (void),
> @@ -6171,22 +6174,22 @@ DEFHOOK_UNDOC
>
> DEFHOOK
> (excess_precision,
> - "Return a value, with the same meaning as the C99 macro\
> - @code{FLT_EVAL_METHOD} that describes which excess precision should be\
> - applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},\
> - @code{EXCESS_PRECISION_TYPE_FAST}, or\
> - @code{EXCESS_PRECISION_TYPE_STANDARD}. For\
> - @code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which\
> - precision and range operations will be implictly evaluated in regardless\
> - of the excess precision explicitly added. For\
> - @code{EXCESS_PRECISION_TYPE_STANDARD} and\
> - @code{EXCESS_PRECISION_TYPE_FAST}, the target should return the\
> - explicit excess precision that should be added depending on the\
> - value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}.\
> - Note that unpredictable explicit excess precision does not make sense,\
> - so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}\
> - when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or\
> - @code{EXCESS_PRECISION_TYPE_FAST}.",
> + "Return a value, with the same meaning as the C99 macro\n\
> +@code{FLT_EVAL_METHOD} that describes which excess precision should be\n\
> +applied. @var{type} is either @code{EXCESS_PRECISION_TYPE_IMPLICIT},\n\
> +@code{EXCESS_PRECISION_TYPE_FAST}, or\n\
> +@code{EXCESS_PRECISION_TYPE_STANDARD}. For\n\
> +@code{EXCESS_PRECISION_TYPE_IMPLICIT}, the target should return which\n\
> +precision and range operations will be implictly evaluated in regardless\n\
> +of the excess precision explicitly added. For\n\
> +@code{EXCESS_PRECISION_TYPE_STANDARD} and\n\
> +@code{EXCESS_PRECISION_TYPE_FAST}, the target should return the\n\
> +explicit excess precision that should be added depending on the\n\
> +value set for @option{-fexcess-precision=@r{[}standard@r{|}fast@r{]}}.\n\
> +Note that unpredictable explicit excess precision does not make sense,\n\
> +so a target should never return @code{FLT_EVAL_METHOD_UNPREDICTABLE}\n\
> +when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or\n\
> +@code{EXCESS_PRECISION_TYPE_FAST}.",
> enum flt_eval_method, (enum excess_precision_type type),
> default_excess_precision)
>
> @@ -6272,12 +6275,12 @@ method. The default is to return @code{true}.",
>
> DEFHOOK
> (determine_class_data_visibility,
> -"@var{decl} is a virtual table, virtual table table, typeinfo object,\
> - or other similar implicit class data object that will be emitted with\
> - external linkage in this translation unit. No ELF visibility has been\
> - explicitly specified. If the target needs to specify a visibility\
> - other than that of the containing class, use this hook to set\
> - @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
> +"@var{decl} is a virtual table, virtual table table, typeinfo object,\n\
> +or other similar implicit class data object that will be emitted with\n\
> +external linkage in this translation unit. No ELF visibility has been\n\
> +explicitly specified. If the target needs to specify a visibility\n\
> +other than that of the containing class, use this hook to set\n\
> +@code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
> void, (tree decl),
> hook_void_tree)
>
> @@ -6331,9 +6334,9 @@ unloaded. The default is to return false.",
>
> DEFHOOK
> (adjust_class_at_definition,
> -"@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).",
> +"@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\n\
> +been defined. Use this hook to make adjustments to the class (eg, tweak\n\
> +visibility or perform any other required target modifications).",
> void, (tree type),
> hook_void_tree)
>
> @@ -6551,7 +6554,9 @@ specific target options and the caller does not use the
> same options.",
>
> DEFHOOK
> (relayout_function,
> -"This target hook fixes function @var{fndecl} after attributes are
> processed. Default does nothing. On ARM, the default function's alignment is
> updated with the attribute target.",
> +"This target hook fixes function @var{fndecl} after attributes are
> processed.\n\
> +Default does nothing. On ARM, the default function's alignment is updated\n\
> +with the attribute target.",
> void, (tree fndecl),
> hook_void_tree)
>
> @@ -6590,8 +6595,8 @@ is to enable the fipa-ra optimization.",
> /* Fill in additional registers set up by prologue into a regset. */
> DEFHOOK
> (set_up_by_prologue,
> - "This hook should add additional registers that are computed by the
> prologue\
> - to the hard regset for shrink-wrapping optimization purposes.",
> + "This hook should add additional registers that are computed by the
> prologue\n\
> +to the hard regset for shrink-wrapping optimization purposes.",
> void, (struct hard_reg_set_container *),
> NULL)
>
> @@ -6600,7 +6605,9 @@ DEFHOOK
> function attribute. */
> DEFHOOK
> (warn_func_return,
> - "True if a function's return statements should be checked for matching the
> function's return type. This includes checking for falling off the end of a
> non-void function. Return false if no such check should be made.",
> + "True if a function's return statements should be checked for matching\n\
> +the function's return type. This includes checking for falling off the
> end\n\
> +of a non-void function. Return false if no such check should be made.",
> bool, (tree),
> hook_bool_tree_true)
>
> @@ -6678,8 +6685,8 @@ This will suppress generation of the normal debug frame
> unwind information.",
> default_debug_unwind_info)
>
> DEFHOOK
> -(reset_location_view, "\
> -This hook, if defined, enables -ginternal-reset-location-views, and\n\
> +(reset_location_view,
> + "This hook, if defined, enables -ginternal-reset-location-views, and\n\
> uses its result to override cases in which the estimated min insn\n\
> length might be nonzero even when a PC advance (i.e., a view reset)\n\
> cannot be taken for granted.\n\
> @@ -6740,9 +6747,9 @@ defined to 1.",
>
> DEFHOOKPOD
> (atomic_test_and_set_trueval,
> - "This value should be set if the result written by\
> - @code{atomic_test_and_set} is not exactly 1, i.e.@: the\
> - @code{bool} @code{true}.",
> + "This value should be set if the result written by\n\
> +@code{atomic_test_and_set} is not exactly 1, i.e.@: the\n\
> +@code{bool} @code{true}.",
> unsigned char, 1)
>
> /* Return an unsigned int representing the alignment (in bits) of the atomic
> @@ -6750,29 +6757,29 @@ DEFHOOKPOD
> as needed. */
> DEFHOOK
> (atomic_align_for_mode,
> -"If defined, this function returns an appropriate alignment in bits for an\
> - atomic object of machine_mode @var{mode}. If 0 is returned then the\
> - default alignment for the specified mode is used. ",
> +"If defined, this function returns an appropriate alignment in bits for an\n\
> +atomic object of machine_mode @var{mode}. If 0 is returned then the\n\
> +default alignment for the specified mode is used.",
> unsigned int, (machine_mode mode),
> hook_uint_mode_0)
>
> DEFHOOK
> (atomic_assign_expand_fenv,
> -"ISO C11 requires atomic compound assignments that may raise floating-point\
> - exceptions to raise exceptions corresponding to the arithmetic operation\
> - whose result was successfully stored in a compare-and-exchange sequence. \
> - This requires code equivalent to calls to @code{feholdexcept},\
> - @code{feclearexcept} and @code{feupdateenv} to be generated at\
> - appropriate points in the compare-and-exchange sequence. This hook should\
> - set @code{*@var{hold}} to an expression equivalent to the call to\
> - @code{feholdexcept}, @code{*@var{clear}} to an expression equivalent to\
> - the call to @code{feclearexcept} and @code{*@var{update}} to an expression\
> - equivalent to the call to @code{feupdateenv}. The three expressions are\
> - @code{NULL_TREE} on entry to the hook and may be left as @code{NULL_TREE}\
> - if no code is required in a particular place. The default implementation\
> - leaves all three expressions as @code{NULL_TREE}. The\
> - @code{__atomic_feraiseexcept} function from @code{libatomic} may be of use\
> - as part of the code generated in @code{*@var{update}}.",
> +"ISO C11 requires atomic compound assignments that may raise
> floating-point\n\
> +exceptions to raise exceptions corresponding to the arithmetic operation\n\
> +whose result was successfully stored in a compare-and-exchange sequence.\n\
> +This requires code equivalent to calls to @code{feholdexcept},\n\
> +@code{feclearexcept} and @code{feupdateenv} to be generated at\n\
> +appropriate points in the compare-and-exchange sequence. This hook should\n\
> +set @code{*@var{hold}} to an expression equivalent to the call to\n\
> +@code{feholdexcept}, @code{*@var{clear}} to an expression equivalent to\n\
> +the call to @code{feclearexcept} and @code{*@var{update}} to an expression\n\
> +equivalent to the call to @code{feupdateenv}. The three expressions are\n\
> +@code{NULL_TREE} on entry to the hook and may be left as @code{NULL_TREE}\n\
> +if no code is required in a particular place. The default implementation\n\
> +leaves all three expressions as @code{NULL_TREE}. The\n\
> +@code{__atomic_feraiseexcept} function from @code{libatomic} may be of use\n\
> +as part of the code generated in @code{*@var{update}}.",
> void, (tree *hold, tree *clear, tree *update),
> default_atomic_assign_expand_fenv)
>
> @@ -6857,23 +6864,26 @@ running a cleanup. The default is @code{false}.",
>
> DEFHOOKPOD
> (want_debug_pub_sections,
> - "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.",
> + "True if the @code{.debug_pubtypes} and @code{.debug_pubnames} sections\n\
> +should be emitted. These sections are not used on most platforms, and\n\
> +in particular GDB does not use them.",
> bool, false)
>
> DEFHOOKPOD
> -(delay_sched2, "True if sched2 is not to be run at its normal place.\n\
> +(delay_sched2,
> + "True if sched2 is not to be run at its normal place.\n\
> This usually means it will be run as part of machine-specific reorg.",
> bool, false)
>
> DEFHOOKPOD
> -(delay_vartrack, "True if vartrack is not to be run at its normal place.\n\
> +(delay_vartrack,
> + "True if vartrack is not to be run at its normal place.\n\
> This usually means it will be run as part of machine-specific reorg.",
> bool, false)
>
> DEFHOOKPOD
> -(no_register_allocation, "True if register allocation and the passes\n\
> +(no_register_allocation,
> + "True if register allocation and the passes\n\
> following it should not be run. Usually true only for virtual assembler\n\
> targets.",
> bool, false)
> @@ -6887,32 +6897,57 @@ HOOK_VECTOR (TARGET_TOGGLE_, mode_switching)
>
> DEFHOOK
> (emit,
> - "Generate one or more insns to set @var{entity} to @var{mode}.
> @var{hard_reg_live} is the set of hard registers live at the point where the
> insn(s) are to be inserted. @var{prev_moxde} indicates the mode to switch
> from. Sets of a lower numbered entity will be emitted before sets of a higher
> numbered entity to a mode of the same or lower priority.",
> + "Generate one or more insns to set @var{entity} to @var{mode}.\n\
> +@var{hard_reg_live} is the set of hard registers live at the point where\n\
> +the insn(s) are to be inserted. @var{prev_moxde} indicates the mode\n\
> +to switch from. Sets of a lower numbered entity will be emitted before\n\
> +sets of a higher numbered entity to a mode of the same or lower priority.",
> void, (int entity, int mode, int prev_mode, HARD_REG_SET regs_live), NULL)
>
> DEFHOOK
> (needed,
> - "@var{entity} is an integer specifying a mode-switched entity. If
> @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro to
> return an integer value not larger than the corresponding element in
> @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that @var{entity}
> must be switched into prior to the execution of @var{insn}.",
> + "@var{entity} is an integer specifying a mode-switched entity.\n\
> +If @code{OPTIMIZE_MODE_SWITCHING} is defined, you must define this macro\n\
> +to return an integer value not larger than the corresponding element\n\
> +in @code{NUM_MODES_FOR_MODE_SWITCHING}, to denote the mode that
> @var{entity}\n\
> +must be switched into prior to the execution of @var{insn}.",
> int, (int entity, rtx_insn *insn), NULL)
>
> DEFHOOK
> (after,
> - "@var{entity} is an integer specifying a mode-switched entity. If this
> macro is defined, it is evaluated for every @var{insn} during mode switching.
> It determines the mode that an insn results in (if different from the
> incoming mode).",
> + "@var{entity} is an integer specifying a mode-switched entity.\n\
> +If this macro is defined, it is evaluated for every @var{insn} during mode\n\
> +switching. It determines the mode that an insn results\n\
> +in (if different from the incoming mode).",
> int, (int entity, int mode, rtx_insn *insn), NULL)
>
> DEFHOOK
> (entry,
> - "If this macro is defined, it is evaluated for every @var{entity} that
> needs mode switching. It should evaluate to an integer, which is a mode that
> @var{entity} is assumed to be switched to at function entry. If
> @code{TARGET_MODE_ENTRY} is defined then @code{TARGET_MODE_EXIT} must be
> defined.",
> + "If this macro is defined, it is evaluated for every @var{entity} that\n\
> +needs mode switching. It should evaluate to an integer, which is a mode\n\
> +that @var{entity} is assumed to be switched to at function entry.\n\
> +If @code{TARGET_MODE_ENTRY} is defined then @code{TARGET_MODE_EXIT}\n\
> +must be defined.",
> int, (int entity), NULL)
>
> DEFHOOK
> (exit,
> - "If this macro is defined, it is evaluated for every @var{entity} that
> needs mode switching. It should evaluate to an integer, which is a mode that
> @var{entity} is assumed to be switched to at function exit. If
> @code{TARGET_MODE_EXIT} is defined then @code{TARGET_MODE_ENTRY} must be
> defined.",
> + "If this macro is defined, it is evaluated for every @var{entity} that\n\
> +needs mode switching. It should evaluate to an integer, which is a mode\n\
> +that @var{entity} is assumed to be switched to at function exit.\n\
> +If @code{TARGET_MODE_EXIT} is defined then @code{TARGET_MODE_ENTRY}\n\
> +must be defined.",
> int, (int entity), NULL)
>
> DEFHOOK
> (priority,
> - "This macro specifies the order in which modes for @var{entity} are
> processed. 0 is the highest priority,
> @code{NUM_MODES_FOR_MODE_SWITCHING[@var{entity}] - 1} the lowest. The value
> of the macro should be an integer designating a mode for @var{entity}. For
> any fixed @var{entity}, @code{mode_priority} (@var{entity}, @var{n}) shall be
> a bijection in 0 @dots{} @code{num_modes_for_mode_switching[@var{entity}] -
> 1}.",
> + "This macro specifies the order in which modes for @var{entity}\n\
> +are processed. 0 is the highest priority,\n\
> +@code{NUM_MODES_FOR_MODE_SWITCHING[@var{entity}] - 1} the lowest.\n\
> +The value of the macro should be an integer designating a mode\n\
> +for @var{entity}. For any fixed @var{entity}, @code{mode_priority}\n\
> +(@var{entity}, @var{n}) shall be a bijection in 0 @dots{}\n\
> +@code{num_modes_for_mode_switching[@var{entity}] - 1}.",
> int, (int entity, int n), NULL)
>
> HOOK_VECTOR_END (mode_switching)
> --
> 2.31.1
>
