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 >