[PATCH] Reformat target.def for better parsing.

Martin Liška mliska@suse.cz
Sun Jun 6 17:12:40 GMT 2021


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?
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



More information about the Gcc-patches mailing list