Fix uppercase names of hooks.

2 files changed, 493 insertions, 493 deletions

diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index 2e7b93c..fd74513 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -400,7 +400,7 @@ the effect you need.  Overriding this macro may be avoidable by overriding
 @end defmac
 
 @deftypevr {Common Target Hook} bool TARGET_ALWAYS_STRIP_DOTDOT
-@c hook-start:TARGET_always_strip_dotdot
+@c hook-start: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
@@ -672,7 +672,7 @@ any target-specific headers.
 @end deftypevar
 
 @deftypevr {Common Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
-@c hook-start:TARGET_default_target_flags
+@c hook-start:TARGET_DEFAULT_TARGET_FLAGS
 @c hook-end
 This variable specifies the initial value of @code{target_flags}.
 Its default setting is 0.
@@ -682,7 +682,7 @@ Its default setting is 0.
 @cindex features, optional, in system conventions
 
 @deftypefn {Common Target Hook} bool TARGET_HANDLE_OPTION (struct gcc_options *@var{opts}, struct gcc_options *@var{opts_set}, const struct cl_decoded_option *@var{decoded}, location_t @var{loc})
-@c hook-start:TARGET_handle_option
+@c hook-start:TARGET_HANDLE_OPTION
 @c hook-end
 This hook is called whenever the user specifies one of the
 target-specific options described by the @file{.opt} definition files
@@ -698,7 +698,7 @@ via attributes).
 @end deftypefn
 
 @deftypefn {C Target Hook} bool TARGET_HANDLE_C_OPTION (size_t @var{code}, const char *@var{arg}, int @var{value})
-@c hook-start:TARGET_handle_c_option
+@c hook-start:TARGET_HANDLE_C_OPTION
 @c hook-end
 This target hook is called whenever the user specifies one of the
 target-specific C language family options described by the @file{.opt}
@@ -714,7 +714,7 @@ should use @code{TARGET_HANDLE_C_OPTION} instead.
 @end deftypefn
 
 @deftypefn {C Target Hook} tree TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree @var{string})
-@c hook-start:TARGET_objc_construct_string_object
+@c hook-start:TARGET_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.
@@ -731,28 +731,28 @@ At present, the hook is used by Objective-C only, to obtain a
 @c hook-end
 
 @deftypefn {C Target Hook} void TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE (const char *@var{classname})
-@c hook-start:TARGET_objc_declare_unresolved_class_reference
+@c hook-start:TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE
 Declare that Objective C class @var{classname} is referenced
 by the current TU.
 @end deftypefn
 @c hook-end
 
 @deftypefn {C Target Hook} void TARGET_OBJC_DECLARE_CLASS_DEFINITION (const char *@var{classname})
-@c hook-start:TARGET_objc_declare_class_definition
+@c hook-start:TARGET_OBJC_DECLARE_CLASS_DEFINITION
 Declare that Objective C class @var{classname} is defined
 by the current TU.
 @end deftypefn
 @c hook-end
 
 @deftypefn {C Target Hook} bool TARGET_STRING_OBJECT_REF_TYPE_P (const_tree @var{stringref})
-@c hook-start:TARGET_string_object_ref_type_p
+@c hook-start:TARGET_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.
 @end deftypefn
 @c hook-end
 
 @deftypefn {C Target Hook} void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree @var{format_arg}, tree @var{args_list})
-@c hook-start:TARGET_check_string_object_format_arg
+@c hook-start:TARGET_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
@@ -761,7 +761,7 @@ against the format specifiers in @var{format_arg} where the type of
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
-@c hook-start:TARGET_override_options_after_change
+@c hook-start:TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
 This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
 but is called when the optimize level is changed via an attribute or
 pragma or when it is reset at the end of the code affected by the
@@ -781,7 +781,7 @@ frontends.
 @end defmac
 
 @deftypevr {Common Target Hook} {const struct default_options *} TARGET_OPTION_OPTIMIZATION_TABLE
-@c hook-start:TARGET_option_optimization_table
+@c hook-start:TARGET_OPTION_OPTIMIZATION_TABLE
 @c hook-end
 Some machines may desire to change what optimizations are performed for
 various optimization levels.   This variable, if defined, describes
@@ -797,7 +797,7 @@ options are changed via @code{#pragma GCC optimize} or by using the
 @end deftypevr
 
 @deftypefn {Common Target Hook} void TARGET_OPTION_INIT_STRUCT (struct gcc_options *@var{opts})
-@c hook-start:TARGET_option_init_struct
+@c hook-start:TARGET_OPTION_INIT_STRUCT
 Set target-dependent initial values of fields in @var{opts}.
 @end deftypefn
 @c hook-end
@@ -822,7 +822,7 @@ is 0.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P (void)
-@c hook-start:TARGET_float_exceptions_rounding_supported_p
+@c hook-start:TARGET_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}.
@@ -1005,7 +1005,7 @@ 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})
-@c hook-start:TARGET_C_excess_precision
+@c hook-start:TARGET_C_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},
@@ -1026,7 +1026,7 @@ when @var{type} is @code{EXCESS_PRECISION_TYPE_STANDARD} or
 @c hook-end
 
 @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})
-@c hook-start:TARGET_promote_function_mode
+@c hook-start:TARGET_PROMOTE_FUNCTION_MODE
 Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or
 function return values.  The target hook should return the new mode
 and possibly change @code{*@var{punsignedp}} if the promotion should
@@ -1089,7 +1089,7 @@ just the biggest alignment that, when violated, may cause a fault.
 @end defmac
 
 @deftypevr {Target Hook} HOST_WIDE_INT TARGET_ABSOLUTE_BIGGEST_ALIGNMENT
-@c hook-start:TARGET_absolute_biggest_alignment
+@c hook-start:TARGET_ABSOLUTE_BIGGEST_ALIGNMENT
 If defined, this target hook specifies the absolute biggest alignment
 that a type or variable can have on this machine, otherwise,
 @code{BIGGEST_ALIGNMENT} is used.
@@ -1160,14 +1160,14 @@ On 32-bit ELF the largest supported section alignment in bits is
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_LOWER_LOCAL_DECL_ALIGNMENT (tree @var{decl})
-@c hook-start:TARGET_lower_local_decl_alignment
+@c hook-start:TARGET_LOWER_LOCAL_DECL_ALIGNMENT
 Define this hook to lower alignment of local, parm or result
 decl @samp{(@var{decl})}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_STATIC_RTX_ALIGNMENT (machine_mode @var{mode})
-@c hook-start:TARGET_static_rtx_alignment
+@c hook-start:TARGET_STATIC_RTX_ALIGNMENT
 This hook returns the preferred alignment in bits for a
 statically-allocated rtx, such as a constant pool entry.  @var{mode}
 is the mode of the rtx.  The default implementation returns
@@ -1200,7 +1200,7 @@ If this macro is not defined, then @var{basic-align} is used.
 @end defmac
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_CONSTANT_ALIGNMENT (const_tree @var{constant}, HOST_WIDE_INT @var{basic_align})
-@c hook-start:TARGET_constant_alignment
+@c hook-start:TARGET_CONSTANT_ALIGNMENT
 This hook returns the alignment in bits of a constant that is being
 placed in memory.  @var{constant} is the constant and @var{basic_align}
 is the alignment that the object would ordinarily have.
@@ -1229,7 +1229,7 @@ If the value of this macro has a type, it should be an unsigned type.
 @end defmac
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_VECTOR_ALIGNMENT (const_tree @var{type})
-@c hook-start:TARGET_vector_alignment
+@c hook-start:TARGET_VECTOR_ALIGNMENT
 This hook can be used to define the alignment for a vector of type
 @var{type}, in order to comply with a platform ABI.  The default is to
 require natural alignment for vector types.  The alignment returned by
@@ -1371,7 +1371,7 @@ to aligning a bit-field within the structure.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_ALIGN_ANON_BITFIELD (void)
-@c hook-start:TARGET_align_anon_bitfield
+@c hook-start:TARGET_ALIGN_ANON_BITFIELD
 When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine
 whether unnamed bitfields affect the alignment of the containing
 structure.  The hook should return true if the structure should inherit
@@ -1380,7 +1380,7 @@ the alignment requirements of an unnamed bitfield's type.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_NARROW_VOLATILE_BITFIELD (void)
-@c hook-start:TARGET_narrow_volatile_bitfield
+@c hook-start:TARGET_NARROW_VOLATILE_BITFIELD
 This target hook should return @code{true} if accesses to volatile bitfields
 should use the narrowest mode possible.  It should return @code{false} if
 these accesses should use the bitfield container type.
@@ -1390,7 +1390,7 @@ The default is @code{false}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_MEMBER_TYPE_FORCES_BLK (const_tree @var{field}, machine_mode @var{mode})
-@c hook-start:TARGET_member_type_forces_blk
+@c hook-start:TARGET_MEMBER_TYPE_FORCES_BLK
 Return true if a structure, union or array containing @var{field} should
 be accessed using @code{BLKMODE}.
 
@@ -1446,7 +1446,7 @@ pattern needs to support both a 32- and a 64-bit mode.
 @end defmac
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_LIBGCC_CMP_RETURN_MODE (void)
-@c hook-start:TARGET_libgcc_cmp_return_mode
+@c hook-start:TARGET_LIBGCC_CMP_RETURN_MODE
 This target hook should return the mode to be used for the return value
 of compare instructions expanded to libgcc calls.  If not defined
 @code{word_mode} is returned which is the right choice for a majority of
@@ -1455,7 +1455,7 @@ targets.
 @c hook-end
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_LIBGCC_SHIFT_COUNT_MODE (void)
-@c hook-start:TARGET_libgcc_shift_count_mode
+@c hook-start:TARGET_LIBGCC_SHIFT_COUNT_MODE
 This target hook should return the mode to be used for the shift count operand
 of shift instructions expanded to libgcc calls.  If not defined
 @code{word_mode} is returned which is the right choice for a majority of
@@ -1464,14 +1464,14 @@ targets.
 @c hook-end
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_UNWIND_WORD_MODE (void)
-@c hook-start:TARGET_unwind_word_mode
+@c hook-start:TARGET_UNWIND_WORD_MODE
 Return machine mode to be used for @code{_Unwind_Word} type.
 The default is to use @code{word_mode}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_MS_BITFIELD_LAYOUT_P (const_tree @var{record_type})
-@c hook-start:TARGET_ms_bitfield_layout_p
+@c hook-start:TARGET_MS_BITFIELD_LAYOUT_P
 This target hook returns @code{true} if bit-fields in the given
 @var{record_type} are to be laid out following the rules of Microsoft
 Visual C/C++, namely: (i) a bit-field won't share the same storage
@@ -1501,19 +1501,19 @@ may affect its placement.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_DECIMAL_FLOAT_SUPPORTED_P (void)
-@c hook-start:TARGET_decimal_float_supported_p
+@c hook-start:TARGET_DECIMAL_FLOAT_SUPPORTED_P
 Returns true if the target supports decimal floating point.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_FIXED_POINT_SUPPORTED_P (void)
-@c hook-start:TARGET_fixed_point_supported_p
+@c hook-start:TARGET_FIXED_POINT_SUPPORTED_P
 Returns true if the target supports fixed-point arithmetic.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_EXPAND_TO_RTL_HOOK (void)
-@c hook-start:TARGET_expand_to_rtl_hook
+@c hook-start:TARGET_EXPAND_TO_RTL_HOOK
 This hook is called just before expansion into rtl, allowing the target
 to perform additional initializations or analysis before the expansion.
 For example, the rs6000 port uses it to allocate a scratch stack slot
@@ -1524,14 +1524,14 @@ usage.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_INSTANTIATE_DECLS (void)
-@c hook-start:TARGET_instantiate_decls
+@c hook-start:TARGET_INSTANTIATE_DECLS
 This hook allows the backend to perform additional instantiations on rtl
 that are not actually in any insns yet, but will be later.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_MANGLE_TYPE (const_tree @var{type})
-@c hook-start:TARGET_mangle_type
+@c hook-start:TARGET_MANGLE_TYPE
 If your target defines any fundamental types, or any types your target
 uses should be mangled differently from the default, define this hook
 to return the appropriate encoding for these types as part of a C++
@@ -1708,7 +1708,7 @@ and @option{-funsigned-char}.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_DEFAULT_SHORT_ENUMS (void)
-@c hook-start:TARGET_default_short_enums
+@c hook-start:TARGET_DEFAULT_SHORT_ENUMS
 This target hook should return true if the compiler should give an
 @code{enum} type only as many bytes as it takes to represent the range
 of possible values of that type.  It should return false if all
@@ -2003,7 +2003,7 @@ must be defined.  Modern ports should define @code{CALL_REALLY_USED_REGISTERS}.
 @cindex call-clobbered register
 @cindex call-saved register
 @deftypefn {Target Hook} {const predefined_function_abi &} TARGET_FNTYPE_ABI (const_tree @var{type})
-@c hook-start:TARGET_fntype_abi
+@c hook-start:TARGET_FNTYPE_ABI
 Return the ABI used by a function with type @var{type}; see the
 definition of @code{predefined_function_abi} for details of the ABI
 descriptor.  Targets only need to define this hook if they support
@@ -2012,7 +2012,7 @@ interoperability between several ABIs in the same translation unit.
 @c hook-end
 
 @deftypefn {Target Hook} {const predefined_function_abi &} TARGET_INSN_CALLEE_ABI (const rtx_insn *@var{insn})
-@c hook-start:TARGET_insn_callee_abi
+@c hook-start:TARGET_INSN_CALLEE_ABI
 This hook returns a description of the ABI used by the target of
 call instruction @var{insn}; see the definition of
 @code{predefined_function_abi} for details of the ABI descriptor.
@@ -2028,7 +2028,7 @@ interoperability between several ABIs in the same translation unit.
 @cindex call-clobbered register
 @cindex call-saved register
 @deftypefn {Target Hook} bool TARGET_HARD_REGNO_CALL_PART_CLOBBERED (unsigned int @var{abi_id}, unsigned int @var{regno}, machine_mode @var{mode})
-@c hook-start:TARGET_hard_regno_call_part_clobbered
+@c hook-start:TARGET_HARD_REGNO_CALL_PART_CLOBBERED
 ABIs usually specify that calls must preserve the full contents
 of a particular register, or that calls can alter any part of a
 particular register.  This information is captured by the target macro
@@ -2052,7 +2052,7 @@ for targets that don't have partly call-clobbered registers.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_GET_MULTILIB_ABI_NAME (void)
-@c hook-start:TARGET_get_multilib_abi_name
+@c hook-start:TARGET_GET_MULTILIB_ABI_NAME
 This hook returns name of multilib ABI name.
 @end deftypefn
 @c hook-end
@@ -2063,7 +2063,7 @@ This hook returns name of multilib ABI name.
 @findex reg_names
 @findex reg_class_contents
 @deftypefn {Target Hook} void TARGET_CONDITIONAL_REGISTER_USAGE (void)
-@c hook-start:TARGET_conditional_register_usage
+@c hook-start:TARGET_CONDITIONAL_REGISTER_USAGE
 This hook may conditionally modify five variables
 @code{fixed_regs}, @code{call_used_regs}, @code{global_regs},
 @code{reg_names}, and @code{reg_class_contents}, to take into account
@@ -2190,7 +2190,7 @@ This section discusses the macros that describe which kinds of values
 consecutive registers are needed for a given mode.
 
 @deftypefn {Target Hook} {unsigned int} TARGET_HARD_REGNO_NREGS (unsigned int @var{regno}, machine_mode @var{mode})
-@c hook-start:TARGET_hard_regno_nregs
+@c hook-start:TARGET_HARD_REGNO_NREGS
 This hook returns the number of consecutive hard registers, starting
 at register number @var{regno}, required to hold a value of mode
 @var{mode}.  This hook must never return zero, even if a register
@@ -2239,7 +2239,7 @@ floating-point registers is still 32-bit.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_HARD_REGNO_MODE_OK (unsigned int @var{regno}, machine_mode @var{mode})
-@c hook-start:TARGET_hard_regno_mode_ok
+@c hook-start:TARGET_HARD_REGNO_MODE_OK
 This hook returns true if it is permissible to store a value
 of mode @var{mode} in hard register number @var{regno} (or in several
 registers starting with that one).  The default definition returns true
@@ -2309,7 +2309,7 @@ The default is always nonzero.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_MODES_TIEABLE_P (machine_mode @var{mode1}, machine_mode @var{mode2})
-@c hook-start:TARGET_modes_tieable_p
+@c hook-start:TARGET_MODES_TIEABLE_P
 This hook returns true if a value of mode @var{mode1} is accessible
 in mode @var{mode2} without copying.
 
@@ -2328,7 +2328,7 @@ allocation.  The default definition returns true unconditionally.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_HARD_REGNO_SCRATCH_OK (unsigned int @var{regno})
-@c hook-start:TARGET_hard_regno_scratch_ok
+@c hook-start:TARGET_HARD_REGNO_SCRATCH_OK
 This target hook should return @code{true} if it is OK to use a hard register
 @var{regno} as scratch reg in peephole2.
 
@@ -2663,7 +2663,7 @@ only if neither labeling works.
 @end defmac
 
 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RENAME_CLASS (reg_class_t @var{rclass})
-@c hook-start:TARGET_preferred_rename_class
+@c hook-start:TARGET_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
@@ -2678,7 +2678,7 @@ be reduced.
 @c hook-end
 
 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_RELOAD_CLASS (rtx @var{x}, reg_class_t @var{rclass})
-@c hook-start:TARGET_preferred_reload_class
+@c hook-start:TARGET_PREFERRED_RELOAD_CLASS
 A target hook that places additional restrictions on the register class
 to use when it is necessary to copy value @var{x} into a register in class
 @var{rclass}.  The value is a register class; perhaps @var{rclass}, or perhaps
@@ -2751,7 +2751,7 @@ the SSE registers (and vice versa).
 @end defmac
 
 @deftypefn {Target Hook} reg_class_t TARGET_PREFERRED_OUTPUT_RELOAD_CLASS (rtx @var{x}, reg_class_t @var{rclass})
-@c hook-start:TARGET_preferred_output_reload_class
+@c hook-start:TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
 Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of
 input reloads.
 
@@ -2780,7 +2780,7 @@ require the macro to do something nontrivial.
 @end defmac
 
 @deftypefn {Target Hook} reg_class_t TARGET_SECONDARY_RELOAD (bool @var{in_p}, rtx @var{x}, reg_class_t @var{reload_class}, machine_mode @var{reload_mode}, secondary_reload_info *@var{sri})
-@c hook-start:TARGET_secondary_reload
+@c hook-start:TARGET_SECONDARY_RELOAD
 Many machines have some registers that cannot be copied directly to or
 from memory or even from other types of registers.  An example is the
 @samp{MQ} register, which on most machines, can only be copied to or
@@ -2928,7 +2928,7 @@ general registers.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_SECONDARY_MEMORY_NEEDED (machine_mode @var{mode}, reg_class_t @var{class1}, reg_class_t @var{class2})
-@c hook-start:TARGET_secondary_memory_needed
+@c hook-start:TARGET_SECONDARY_MEMORY_NEEDED
 Certain machines have the property that some registers cannot be copied
 to some other registers without using memory.  Define this hook on
 those machines to return true if objects of mode @var{m} in registers
@@ -2950,7 +2950,7 @@ Do not define this macro if you do not define
 @end defmac
 
 @deftypefn {Target Hook} machine_mode TARGET_SECONDARY_MEMORY_NEEDED_MODE (machine_mode @var{mode})
-@c hook-start:TARGET_secondary_memory_needed_mode
+@c hook-start:TARGET_SECONDARY_MEMORY_NEEDED_MODE
 If @code{TARGET_SECONDARY_MEMORY_NEEDED} tells the compiler to use memory
 when moving between two particular registers of mode @var{mode},
 this hook specifies the mode that the memory should have.
@@ -2974,7 +2974,7 @@ With LRA, the default is to use @var{mode} unmodified.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SELECT_EARLY_REMAT_MODES (sbitmap @var{modes})
-@c hook-start:TARGET_select_early_remat_modes
+@c hook-start:TARGET_SELECT_EARLY_REMAT_MODES
 On some targets, certain modes cannot be held in registers around a
 standard ABI call and are relatively expensive to spill to the stack.
 The early rematerialization pass can help in such cases by aggressively
@@ -2987,7 +2987,7 @@ the effect of disabling the early rematerialization pass.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CLASS_LIKELY_SPILLED_P (reg_class_t @var{rclass})
-@c hook-start:TARGET_class_likely_spilled_p
+@c hook-start:TARGET_CLASS_LIKELY_SPILLED_P
 A target hook which returns @code{true} if pseudos that have been assigned
 to registers of class @var{rclass} would likely be spilled because
 registers of @var{rclass} are needed for spill registers.
@@ -3005,7 +3005,7 @@ pressure.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned char} TARGET_CLASS_MAX_NREGS (reg_class_t @var{rclass}, machine_mode @var{mode})
-@c hook-start:TARGET_class_max_nregs
+@c hook-start:TARGET_CLASS_MAX_NREGS
 A target hook returns the maximum number of consecutive registers
 of class @var{rclass} needed to hold a value of mode @var{mode}.
 
@@ -3037,7 +3037,7 @@ in the reload pass.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_CAN_CHANGE_MODE_CLASS (machine_mode @var{from}, machine_mode @var{to}, reg_class_t @var{rclass})
-@c hook-start:TARGET_can_change_mode_class
+@c hook-start:TARGET_CAN_CHANGE_MODE_CLASS
 This hook returns true if it is possible to bitcast values held in
 registers of class @var{rclass} from mode @var{from} to mode @var{to}
 and if doing so preserves the low-order bits that are common to both modes.
@@ -3069,7 +3069,7 @@ value that the middle-end intended.
 @c hook-end
 
 @deftypefn {Target Hook} reg_class_t TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS (int, @var{reg_class_t}, @var{reg_class_t})
-@c hook-start:TARGET_ira_change_pseudo_allocno_class
+@c hook-start:TARGET_IRA_CHANGE_PSEUDO_ALLOCNO_CLASS
 A target hook which can change allocno class for given pseudo from
   allocno and best class calculated by IRA.
   
@@ -3078,7 +3078,7 @@ A target hook which can change allocno class for given pseudo from
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LRA_P (void)
-@c hook-start:TARGET_lra_p
+@c hook-start:TARGET_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
@@ -3087,7 +3087,7 @@ should use LRA, and existing ports are encouraged to convert.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_REGISTER_PRIORITY (int)
-@c hook-start:TARGET_register_priority
+@c hook-start:TARGET_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
@@ -3102,7 +3102,7 @@ The default version of this target hook returns always zero.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_REGISTER_USAGE_LEVELING_P (void)
-@c hook-start:TARGET_register_usage_leveling_p
+@c hook-start:TARGET_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
@@ -3116,7 +3116,7 @@ The default version of this target hook returns always false.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_DIFFERENT_ADDR_DISPLACEMENT_P (void)
-@c hook-start:TARGET_different_addr_displacement_p
+@c hook-start:TARGET_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
@@ -3127,7 +3127,7 @@ The default version of this target hook returns always false.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P (rtx @var{subst})
-@c hook-start:TARGET_cannot_substitute_mem_equiv_p
+@c hook-start:TARGET_CANNOT_SUBSTITUTE_MEM_EQUIV_P
 A target hook which returns @code{true} if @var{subst} can't
 substitute safely pseudos with equivalent memory values during
 register allocation.
@@ -3139,7 +3139,7 @@ as SH, this hook can be used to avoid excessive spilling.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT (rtx *@var{offset1}, rtx *@var{offset2}, poly_int64 @var{orig_offset}, machine_mode @var{mode})
-@c hook-start:TARGET_legitimize_address_displacement
+@c hook-start:TARGET_LEGITIMIZE_ADDRESS_DISPLACEMENT
 This hook tries to split address offset @var{orig_offset} into
 two parts: one that should be added to the base address to create
 a local anchor point, and an additional offset that can be applied
@@ -3153,7 +3153,7 @@ from the anchor in @var{offset2}.  The default implementation returns false.
 @c hook-end
 
 @deftypefn {Target Hook} reg_class_t TARGET_SPILL_CLASS (reg_class_t, @var{machine_mode})
-@c hook-start:TARGET_spill_class
+@c hook-start:TARGET_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
@@ -3162,7 +3162,7 @@ should be used.  Not defining this hook is equivalent to returning
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ADDITIONAL_ALLOCNO_CLASS_P (reg_class_t)
-@c hook-start:TARGET_additional_allocno_class_p
+@c hook-start:TARGET_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
@@ -3173,7 +3173,7 @@ equivalent to returning @code{false} for all inputs.
 @c hook-end
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_CSTORE_MODE (enum insn_code @var{icode})
-@c hook-start:TARGET_cstore_mode
+@c hook-start:TARGET_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
@@ -3183,7 +3183,7 @@ patterns.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_COMPUTE_PRESSURE_CLASSES (enum reg_class *@var{pressure_classes})
-@c hook-start:TARGET_compute_pressure_classes
+@c hook-start:TARGET_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
@@ -3257,7 +3257,7 @@ addresses on the stack.
 @end defmac
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_STARTING_FRAME_OFFSET (void)
-@c hook-start:TARGET_starting_frame_offset
+@c hook-start:TARGET_STARTING_FRAME_OFFSET
 This hook returns the offset from the frame pointer to the first local
 variable slot to be allocated.  If @code{FRAME_GROWS_DOWNWARD}, it is the
 offset to @emph{end} of the first slot allocated, otherwise it is the
@@ -3332,7 +3332,7 @@ define this macro.  The default is to do nothing.
 @end defmac
 
 @deftypefn {Target Hook} rtx TARGET_BUILTIN_SETJMP_FRAME_VALUE (void)
-@c hook-start:TARGET_builtin_setjmp_frame_value
+@c hook-start:TARGET_BUILTIN_SETJMP_FRAME_VALUE
 This target hook should return an rtx that is used to store
 the address of the current frame into the built in @code{setjmp} buffer.
 The default value, @code{virtual_stack_vars_rtx}, is correct for most
@@ -3402,7 +3402,7 @@ terminate the stack backtrace.  New ports should avoid this.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_DWARF_HANDLE_FRAME_UNSPEC (const char *@var{label}, rtx @var{pattern}, int @var{index})
-@c hook-start:TARGET_dwarf_handle_frame_unspec
+@c hook-start:TARGET_DWARF_HANDLE_FRAME_UNSPEC
 This target hook allows the backend to emit frame-related insns that
 contain UNSPECs or UNSPEC_VOLATILEs.  The DWARF 2 call frame debugging
 info engine will invoke it on insns of the form
@@ -3420,7 +3420,7 @@ the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_DWARF_POLY_INDETERMINATE_VALUE (unsigned int @var{i}, unsigned int *@var{factor}, int *@var{offset})
-@c hook-start:TARGET_dwarf_poly_indeterminate_value
+@c hook-start:TARGET_DWARF_POLY_INDETERMINATE_VALUE
 Express the value of @code{poly_int} indeterminate @var{i} as a DWARF
 expression, with @var{i} counting from 1.  Return the number of a DWARF
 register @var{R} and set @samp{*@var{factor}} and @samp{*@var{offset}} such
@@ -3728,7 +3728,7 @@ normally not need to override that default.
 @end defmac
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE (void)
-@c hook-start:TARGET_stack_clash_protection_alloca_probe_range
+@c hook-start:TARGET_STACK_CLASH_PROTECTION_ALLOCA_PROBE_RANGE
 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.
@@ -3837,7 +3837,7 @@ defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
 @end defmac
 
 @deftypefn {Target Hook} rtx TARGET_STATIC_CHAIN (const_tree @var{fndecl_or_type}, bool @var{incoming_p})
-@c hook-start:TARGET_static_chain
+@c hook-start:TARGET_STATIC_CHAIN
 This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for
 targets that may use different static chain locations for different
 nested functions.  This may be required if the target has function
@@ -3946,7 +3946,7 @@ is such a register and stores its value in @samp{*@var{value}} if so.
 This is about eliminating the frame pointer and arg pointer.
 
 @deftypefn {Target Hook} bool TARGET_FRAME_POINTER_REQUIRED (void)
-@c hook-start:TARGET_frame_pointer_required
+@c hook-start:TARGET_FRAME_POINTER_REQUIRED
 This target hook should return @code{true} if a function must have and use
 a frame pointer.  This target hook is called in the reload pass.  If its return
 value is @code{true} the function will have a frame pointer.
@@ -3998,7 +3998,7 @@ specified first since that is the preferred elimination.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_CAN_ELIMINATE (const int @var{from_reg}, const int @var{to_reg})
-@c hook-start:TARGET_can_eliminate
+@c hook-start:TARGET_CAN_ELIMINATE
 This target hook should return @code{true} if the compiler is allowed to
 try to replace register number @var{from_reg} with register number
 @var{to_reg}.  This target hook will usually be @code{true}, since most of the
@@ -4017,7 +4017,7 @@ registers @code{df_regs_ever_live_p} and @code{call_used_regs}.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_COMPUTE_FRAME_LAYOUT (void)
-@c hook-start:TARGET_compute_frame_layout
+@c hook-start:TARGET_COMPUTE_FRAME_LAYOUT
 This target hook is called once each time the frame layout needs to be
 recalculated.  The calculations can be cached by the target and can then
 be used by @code{INITIAL_ELIMINATION_OFFSET} instead of re-computing the
@@ -4037,7 +4037,7 @@ on the stack.  See the following section for other macros that
 control passing certain arguments in registers.
 
 @deftypefn {Target Hook} bool TARGET_PROMOTE_PROTOTYPES (const_tree @var{fntype})
-@c hook-start:TARGET_promote_prototypes
+@c hook-start:TARGET_PROMOTE_PROTOTYPES
 This target hook returns @code{true} if an argument declared in a
 prototype as an integral type smaller than @code{int} should actually be
 passed as an @code{int}.  In addition to avoiding errors in certain
@@ -4047,7 +4047,7 @@ The default is to not promote prototypes.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PUSH_ARGUMENT (unsigned int @var{npush})
-@c hook-start:TARGET_push_argument
+@c hook-start:TARGET_PUSH_ARGUMENT
 This target hook returns @code{true} if push instructions will be
 used to pass outgoing arguments.  When the push instruction usage is
 optional, @var{npush} is nonzero to indicate the number of bytes to
@@ -4151,7 +4151,7 @@ stack in its natural location.
 @end defmac
 
 @deftypefn {Target Hook} poly_int64 TARGET_RETURN_POPS_ARGS (tree @var{fundecl}, tree @var{funtype}, poly_int64 @var{size})
-@c hook-start:TARGET_return_pops_args
+@c hook-start:TARGET_RETURN_POPS_ARGS
 This target hook returns the number of bytes of its own arguments that
 a function pops on returning, or 0 if the function pops no arguments
 and the caller must therefore pop them all after the function returns.
@@ -4215,7 +4215,7 @@ types of arguments are passed in registers or how they are arranged in
 the stack.
 
 @deftypefn {Target Hook} rtx TARGET_FUNCTION_ARG (cumulative_args_t @var{ca}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_function_arg
+@c hook-start:TARGET_FUNCTION_ARG
 Return an RTX indicating whether function argument @var{arg} is passed
 in a register and if so, which register.  Argument @var{ca} summarizes all
 the previous arguments.
@@ -4268,7 +4268,7 @@ a register.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_MUST_PASS_IN_STACK (const function_arg_info @var{&arg})
-@c hook-start:TARGET_must_pass_in_stack
+@c hook-start:TARGET_MUST_PASS_IN_STACK
 This target hook should return @code{true} if we should not pass @var{arg}
 solely in registers.  The file @file{expr.h} defines a
 definition that is usually appropriate, refer to @file{expr.h} for additional
@@ -4277,7 +4277,7 @@ documentation.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_FUNCTION_INCOMING_ARG (cumulative_args_t @var{ca}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_function_incoming_arg
+@c hook-start:TARGET_FUNCTION_INCOMING_ARG
 Define this hook if the caller and callee on the target have different
 views of where arguments are passed.  Also define this hook if there are
 functions that are never directly called, but are invoked by the hardware
@@ -4299,21 +4299,21 @@ If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_USE_PSEUDO_PIC_REG (void)
-@c hook-start:TARGET_use_pseudo_pic_reg
+@c hook-start:TARGET_USE_PSEUDO_PIC_REG
 This hook should return 1 in case pseudo register should be created
 for pic_offset_table_rtx during function expand.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_INIT_PIC_REG (void)
-@c hook-start:TARGET_init_pic_reg
+@c hook-start:TARGET_INIT_PIC_REG
 Perform a target dependent initialization of pic_offset_table_rtx.
 This hook is called at the start of register allocation.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_ARG_PARTIAL_BYTES (cumulative_args_t @var{cum}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_arg_partial_bytes
+@c hook-start:TARGET_ARG_PARTIAL_BYTES
 This target hook returns the number of bytes at the beginning of an
 argument that must be put in registers.  The value must be zero for
 arguments that are passed entirely in registers or that are entirely
@@ -4334,7 +4334,7 @@ register to be used by the caller for this argument; likewise
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PASS_BY_REFERENCE (cumulative_args_t @var{cum}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_pass_by_reference
+@c hook-start:TARGET_PASS_BY_REFERENCE
 This target hook should return @code{true} if argument @var{arg} at the
 position indicated by @var{cum} should be passed by reference.  This
 predicate is queried after target independent reasons for being
@@ -4348,7 +4348,7 @@ to that type.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CALLEE_COPIES (cumulative_args_t @var{cum}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_callee_copies
+@c hook-start:TARGET_CALLEE_COPIES
 The function argument described by the parameters to this hook is
 known to be passed by reference.  The hook should return true if the
 function argument should be copied by the callee instead of copied
@@ -4429,7 +4429,7 @@ argument @var{libname} exists for symmetry with
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_FUNCTION_ARG_ADVANCE (cumulative_args_t @var{ca}, const function_arg_info @var{&arg})
-@c hook-start:TARGET_function_arg_advance
+@c hook-start:TARGET_FUNCTION_ARG_ADVANCE
 This hook updates the summarizer variable pointed to by @var{ca} to
 advance past argument @var{arg} in the argument list.  Once this is done,
 the variable @var{cum} is suitable for analyzing the @emph{following}
@@ -4442,7 +4442,7 @@ used for arguments without any special help.
 @c hook-end
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_FUNCTION_ARG_OFFSET (machine_mode @var{mode}, const_tree @var{type})
-@c hook-start:TARGET_function_arg_offset
+@c hook-start:TARGET_FUNCTION_ARG_OFFSET
 This hook returns the number of bytes to add to the offset of an
 argument of type @var{type} and mode @var{mode} when passed in memory.
 This is needed for the SPU, which passes @code{char} and @code{short}
@@ -4452,7 +4452,7 @@ instead of starting at the top.  The default implementation returns 0.
 @c hook-end
 
 @deftypefn {Target Hook} pad_direction TARGET_FUNCTION_ARG_PADDING (machine_mode @var{mode}, const_tree @var{type})
-@c hook-start:TARGET_function_arg_padding
+@c hook-start:TARGET_FUNCTION_ARG_PADDING
 This hook determines whether, and in which direction, to pad out
 an argument of mode @var{mode} and type @var{type}.  It returns
 @code{PAD_UPWARD} to insert padding above the argument, @code{PAD_DOWNWARD}
@@ -4489,7 +4489,7 @@ required.
 @end defmac
 
 @deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_BOUNDARY (machine_mode @var{mode}, const_tree @var{type})
-@c hook-start:TARGET_function_arg_boundary
+@c hook-start:TARGET_FUNCTION_ARG_BOUNDARY
 This hook returns the alignment boundary, in bits, of an argument
 with the specified mode and type.  The default hook returns
 @code{PARM_BOUNDARY} for all arguments.
@@ -4497,7 +4497,7 @@ with the specified mode and type.  The default hook returns
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_ROUND_BOUNDARY (machine_mode @var{mode}, const_tree @var{type})
-@c hook-start:TARGET_function_arg_round_boundary
+@c hook-start:TARGET_FUNCTION_ARG_ROUND_BOUNDARY
 Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},
 which is the default value for this hook.  You can define this hook to
 return a different value if an argument size must be rounded to a larger
@@ -4515,7 +4515,7 @@ stack.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_SPLIT_COMPLEX_ARG (const_tree @var{type})
-@c hook-start:TARGET_split_complex_arg
+@c hook-start:TARGET_SPLIT_COMPLEX_ARG
 This hook should return true if parameter of type @var{type} are passed
 as two scalar parameters.  By default, GCC will attempt to pack complex
 arguments into the target's word size.  Some ABIs require complex arguments
@@ -4530,14 +4530,14 @@ false.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_BUILD_BUILTIN_VA_LIST (void)
-@c hook-start:TARGET_build_builtin_va_list
+@c hook-start:TARGET_BUILD_BUILTIN_VA_LIST
 This hook returns a type node for @code{va_list} for the target.
 The default version of the hook returns @code{void*}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_ENUM_VA_LIST_P (int @var{idx}, const char **@var{pname}, tree *@var{ptree})
-@c hook-start:TARGET_enum_va_list_p
+@c hook-start:TARGET_ENUM_VA_LIST_P
 This target hook is used in function @code{c_common_nodes_and_builtins}
 to iterate through the target specific builtin types for va_list. The
 variable @var{idx} is used as iterator. @var{pname} has to be a pointer
@@ -4553,7 +4553,7 @@ macro to iterate through all types.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_FN_ABI_VA_LIST (tree @var{fndecl})
-@c hook-start:TARGET_fn_abi_va_list
+@c hook-start:TARGET_FN_ABI_VA_LIST
 This hook returns the va_list type of the calling convention specified by
 @var{fndecl}.
 The default version of this hook returns @code{va_list_type_node}.
@@ -4561,7 +4561,7 @@ The default version of this hook returns @code{va_list_type_node}.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_CANONICAL_VA_LIST_TYPE (tree @var{type})
-@c hook-start:TARGET_canonical_va_list_type
+@c hook-start:TARGET_CANONICAL_VA_LIST_TYPE
 This hook returns the va_list type of the calling convention specified by the
 type of @var{type}. If @var{type} is not a valid va_list type, it returns
 @code{NULL_TREE}.
@@ -4569,7 +4569,7 @@ type of @var{type}. If @var{type} is not a valid va_list type, it returns
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_GIMPLIFY_VA_ARG_EXPR (tree @var{valist}, tree @var{type}, gimple_seq *@var{pre_p}, gimple_seq *@var{post_p})
-@c hook-start:TARGET_gimplify_va_arg_expr
+@c hook-start:TARGET_GIMPLIFY_VA_ARG_EXPR
 This hook performs target-specific gimplification of
 @code{VA_ARG_EXPR}.  The first two parameters correspond to the
 arguments to @code{va_arg}; the latter two are as in
@@ -4578,7 +4578,7 @@ arguments to @code{va_arg}; the latter two are as in
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (scalar_int_mode @var{mode})
-@c hook-start:TARGET_valid_pointer_mode
+@c hook-start:TARGET_VALID_POINTER_MODE
 Define this to return nonzero if the port can handle pointers
 with machine mode @var{mode}.  The default version of this
 hook returns true for both @code{ptr_mode} and @code{Pmode}.
@@ -4586,7 +4586,7 @@ hook returns true for both @code{ptr_mode} and @code{Pmode}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_REF_MAY_ALIAS_ERRNO (ao_ref *@var{ref})
-@c hook-start:TARGET_ref_may_alias_errno
+@c hook-start:TARGET_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
@@ -4596,7 +4596,7 @@ a pointer to int.
 @c hook-end
 
 @deftypefn {Target Hook} machine_mode TARGET_TRANSLATE_MODE_ATTRIBUTE (machine_mode @var{mode})
-@c hook-start:TARGET_translate_mode_attribute
+@c hook-start:TARGET_TRANSLATE_MODE_ATTRIBUTE
 Define this hook if during mode attribute processing, the port should
 translate machine_mode @var{mode} to another mode.  For example, rs6000's
 @code{KFmode}, when it is the same as @code{TFmode}.
@@ -4606,7 +4606,7 @@ The default version of the hook returns that mode that was passed in.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCALAR_MODE_SUPPORTED_P (scalar_mode @var{mode})
-@c hook-start:TARGET_scalar_mode_supported_p
+@c hook-start:TARGET_SCALAR_MODE_SUPPORTED_P
 Define this to return nonzero if the port is prepared to handle
 insns involving scalar mode @var{mode}.  For a scalar mode to be
 considered supported, all the basic arithmetic and comparisons
@@ -4620,7 +4620,7 @@ code in @file{optabs.c}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VECTOR_MODE_SUPPORTED_P (machine_mode @var{mode})
-@c hook-start:TARGET_vector_mode_supported_p
+@c hook-start:TARGET_VECTOR_MODE_SUPPORTED_P
 Define this to return nonzero if the port is prepared to handle
 insns involving vector mode @var{mode}.  At the very least, it
 must have move patterns for this mode.
@@ -4628,7 +4628,7 @@ must have move patterns for this mode.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_COMPATIBLE_VECTOR_TYPES_P (const_tree @var{type1}, const_tree @var{type2})
-@c hook-start:TARGET_compatible_vector_types_p
+@c hook-start:TARGET_COMPATIBLE_VECTOR_TYPES_P
 Return true if there is no target-specific reason for treating
 vector types @var{type1} and @var{type2} as distinct types.  The caller
 has already checked for target-independent reasons, meaning that the
@@ -4651,7 +4651,7 @@ The default implementation returns true, which is correct for most targets.
 @c hook-end
 
 @deftypefn {Target Hook} opt_machine_mode TARGET_ARRAY_MODE (machine_mode @var{mode}, unsigned HOST_WIDE_INT @var{nelems})
-@c hook-start:TARGET_array_mode
+@c hook-start:TARGET_ARRAY_MODE
 Return the mode that GCC should use for an array that has
 @var{nelems} elements, with each element having mode @var{mode}.
 Return no mode if the target has no special requirements.  In the
@@ -4667,7 +4667,7 @@ also have a vector mode.  The default implementation returns no mode.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ARRAY_MODE_SUPPORTED_P (machine_mode @var{mode}, unsigned HOST_WIDE_INT @var{nelems})
-@c hook-start:TARGET_array_mode_supported_p
+@c hook-start:TARGET_ARRAY_MODE_SUPPORTED_P
 Return true if GCC should try to use a scalar mode to store an array
 of @var{nelems} elements, given that each element has mode @var{mode}.
 Returning true here overrides the usual @code{MAX_FIXED_MODE} limit
@@ -4697,7 +4697,7 @@ If this hook allows @code{val} to have a scalar mode, then
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P (scalar_float_mode @var{mode})
-@c hook-start:TARGET_libgcc_floating_mode_supported_p
+@c hook-start:TARGET_LIBGCC_FLOATING_MODE_SUPPORTED_P
 Define this to return nonzero if libgcc provides support for the 
 floating-point mode @var{mode}, which is known to pass 
 @code{TARGET_SCALAR_MODE_SUPPORTED_P}.  The default version of this 
@@ -4707,7 +4707,7 @@ hook returns true for all of @code{SFmode}, @code{DFmode},
 @c hook-end
 
 @deftypefn {Target Hook} opt_scalar_float_mode TARGET_FLOATN_MODE (int @var{n}, bool @var{extended})
-@c hook-start:TARGET_floatn_mode
+@c hook-start:TARGET_FLOATN_MODE
 Define this to return the machine mode to use for the type 
 @code{_Float@var{n}}, if @var{extended} is false, or the type 
 @code{_Float@var{n}x}, if @var{extended} is true.  If such a type is not
@@ -4727,7 +4727,7 @@ if @var{extended} is false, 16 or greater than 128 and a multiple of 32.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_FLOATN_BUILTIN_P (int @var{func})
-@c hook-start:TARGET_floatn_builtin_p
+@c hook-start:TARGET_FLOATN_BUILTIN_P
 Define this to return true if the @code{_Float@var{n}} and
 @code{_Float@var{n}x} built-in functions should implicitly enable the
 built-in function without the @code{__builtin_} prefix in addition to the
@@ -4740,7 +4740,7 @@ the @code{__builtin_} prefix is not enabled.  The argument @code{FUNC} is the
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (machine_mode @var{mode})
-@c hook-start:TARGET_small_register_classes_for_mode_p
+@c hook-start:TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
 Define this to return nonzero for machine modes for which the port has
 small register classes.  If this target hook returns nonzero for a given
 @var{mode}, the compiler will try to minimize the lifetime of registers
@@ -4783,7 +4783,7 @@ This section discusses the macros that control returning scalars as
 values---values that can fit in registers.
 
 @deftypefn {Target Hook} rtx TARGET_FUNCTION_VALUE (const_tree @var{ret_type}, const_tree @var{fn_decl_or_type}, bool @var{outgoing})
-@c hook-start:TARGET_function_value
+@c hook-start:TARGET_FUNCTION_VALUE
 
 Define this to return an RTX representing the place where a function
 returns or receives a value of data type @var{ret_type}, a tree node
@@ -4844,7 +4844,7 @@ compiled.
 @end defmac
 
 @deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (machine_mode @var{mode}, const_rtx @var{fun})
-@c hook-start:TARGET_libcall_value
+@c hook-start:TARGET_LIBCALL_VALUE
 Define this hook if the back-end needs to know the name of the libcall
 function in order to determine where the result should be returned.
 
@@ -4878,7 +4878,7 @@ for a new target instead.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_FUNCTION_VALUE_REGNO_P (const unsigned int @var{regno})
-@c hook-start:TARGET_function_value_regno_p
+@c hook-start:TARGET_FUNCTION_VALUE_REGNO_P
 A target hook that return @code{true} if @var{regno} is the number of a hard
 register in which the values of called function may come back.
 
@@ -4901,7 +4901,7 @@ saving and restoring an arbitrary return value.
 @end defmac
 
 @deftypevr {Target Hook} bool TARGET_OMIT_STRUCT_RETURN_REG
-@c hook-start:TARGET_omit_struct_return_reg
+@c hook-start:TARGET_OMIT_STRUCT_RETURN_REG
 Normally, when a function returns a structure by memory, the address
 is passed as an invisible pointer argument, but the compiler also
 arranges to return the address from the function like it would a normal
@@ -4911,7 +4911,7 @@ undesirable on your target.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_RETURN_IN_MSB (const_tree @var{type})
-@c hook-start:TARGET_return_in_msb
+@c hook-start:TARGET_RETURN_IN_MSB
 This hook should return true if values of type @var{type} are returned
 at the most significant end of a register (in other words, if they are
 padded at the least significant end).  You can assume that @var{type}
@@ -4943,7 +4943,7 @@ This section describes how to control returning structure values in
 memory.
 
 @deftypefn {Target Hook} bool TARGET_RETURN_IN_MEMORY (const_tree @var{type}, const_tree @var{fntype})
-@c hook-start:TARGET_return_in_memory
+@c hook-start:TARGET_RETURN_IN_MEMORY
 This target hook should return a nonzero value to say to return the
 function value in memory, just as large structures are always returned.
 Here @var{type} will be the data type of the value, and @var{fntype}
@@ -4975,7 +4975,7 @@ If not defined, this defaults to the value 1.
 @end defmac
 
 @deftypefn {Target Hook} rtx TARGET_STRUCT_VALUE_RTX (tree @var{fndecl}, int @var{incoming})
-@c hook-start:TARGET_struct_value_rtx
+@c hook-start:TARGET_STRUCT_VALUE_RTX
 This target hook should return the location of the structure value
 address (normally a @code{mem} or @code{reg}), or 0 if the address is
 passed as an ``invisible'' first argument.  Note that @var{fndecl} may
@@ -5012,7 +5012,7 @@ 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})
-@c hook-start:TARGET_get_raw_result_mode
+@c hook-start:TARGET_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.
@@ -5020,7 +5020,7 @@ in @var{reg_raw_mode} is not correct.
 @c hook-end
 
 @deftypefn {Target Hook} fixed_size_mode TARGET_GET_RAW_ARG_MODE (int @var{regno})
-@c hook-start:TARGET_get_raw_arg_mode
+@c hook-start:TARGET_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.
@@ -5028,14 +5028,14 @@ in @var{reg_raw_mode} is not correct.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_EMPTY_RECORD_P (const_tree @var{type})
-@c hook-start:TARGET_empty_record_p
+@c hook-start:TARGET_EMPTY_RECORD_P
 This target hook returns true if the type is an empty record.  The default
 is to return @code{false}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_WARN_PARAMETER_PASSING_ABI (cumulative_args_t @var{ca}, tree @var{type})
-@c hook-start:TARGET_warn_parameter_passing_abi
+@c hook-start:TARGET_WARN_PARAMETER_PASSING_ABI
 This target hook warns about the change in empty class parameter passing
 ABI.
 @end deftypefn
@@ -5066,7 +5066,7 @@ This section describes the macros that output function entry
 (@dfn{prologue}) and exit (@dfn{epilogue}) code.
 
 @deftypefn {Target Hook} void TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY (FILE *@var{file}, unsigned HOST_WIDE_INT @var{patch_area_size}, bool @var{record_p})
-@c hook-start:TARGET_ASM_print_patchable_function_entry
+@c hook-start:TARGET_ASM_PRINT_PATCHABLE_FUNCTION_ENTRY
 Generate a patchable area at the function start, consisting of
 @var{patch_area_size} NOP instructions.  If the target supports named
 sections and if @var{record_p} is true, insert a pointer to the current
@@ -5077,7 +5077,7 @@ of the hook places the table of pointers in the special section named
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_PROLOGUE (FILE *@var{file})
-@c hook-start:TARGET_ASM_function_prologue
+@c hook-start:TARGET_ASM_FUNCTION_PROLOGUE
 If defined, a function that outputs the assembler code for entry to a
 function.  The prologue is responsible for setting up the stack frame,
 initializing the frame pointer register, saving registers that must be
@@ -5124,7 +5124,7 @@ need agree with that used by other compilers for a machine.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_END_PROLOGUE (FILE *@var{file})
-@c hook-start:TARGET_ASM_function_end_prologue
+@c hook-start:TARGET_ASM_FUNCTION_END_PROLOGUE
 If defined, a function that outputs assembler code at the end of a
 prologue.  This should be used when the function prologue is being
 emitted as RTL, and you have some extra assembler that needs to be
@@ -5133,7 +5133,7 @@ emitted.  @xref{prologue instruction pattern}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_BEGIN_EPILOGUE (FILE *@var{file})
-@c hook-start:TARGET_ASM_function_begin_epilogue
+@c hook-start:TARGET_ASM_FUNCTION_BEGIN_EPILOGUE
 If defined, a function that outputs assembler code at the start of an
 epilogue.  This should be used when the function epilogue is being
 emitted as RTL, and you have some extra assembler that needs to be
@@ -5142,7 +5142,7 @@ emitted.  @xref{epilogue instruction pattern}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_EPILOGUE (FILE *@var{file})
-@c hook-start:TARGET_ASM_function_epilogue
+@c hook-start:TARGET_ASM_FUNCTION_EPILOGUE
 If defined, a function that outputs the assembler code for exit from a
 function.  The epilogue is responsible for restoring the saved
 registers and stack pointer to their values when the function was
@@ -5251,7 +5251,7 @@ on entry to an exception edge.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_MI_THUNK (FILE *@var{file}, tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, HOST_WIDE_INT @var{vcall_offset}, tree @var{function})
-@c hook-start:TARGET_ASM_output_mi_thunk
+@c hook-start:TARGET_ASM_OUTPUT_MI_THUNK
 A function that outputs the assembler code for a thunk
 function, used to implement C++ virtual function calls with multiple
 inheritance.  The thunk acts as a wrapper around a virtual function,
@@ -5295,7 +5295,7 @@ not support varargs.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_CAN_OUTPUT_MI_THUNK (const_tree @var{thunk_fndecl}, HOST_WIDE_INT @var{delta}, HOST_WIDE_INT @var{vcall_offset}, const_tree @var{function})
-@c hook-start:TARGET_ASM_can_output_mi_thunk
+@c hook-start:TARGET_ASM_CAN_OUTPUT_MI_THUNK
 A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able
 to output the assembler code for the thunk function specified by the
 arguments it is passed, and false otherwise.  In the latter case, the
@@ -5346,7 +5346,7 @@ the function prologue.  Normally, the profiling code comes after.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_KEEP_LEAF_WHEN_PROFILED (void)
-@c hook-start:TARGET_keep_leaf_when_profiled
+@c hook-start:TARGET_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
@@ -5360,7 +5360,7 @@ mcount is generated before the function prologue.
 @cindex tail calls
 
 @deftypefn {Target Hook} bool TARGET_FUNCTION_OK_FOR_SIBCALL (tree @var{decl}, tree @var{exp})
-@c hook-start:TARGET_function_ok_for_sibcall
+@c hook-start:TARGET_FUNCTION_OK_FOR_SIBCALL
 True if it is OK to do sibling call optimization for the specified
 call expression @var{exp}.  @var{decl} will be the called function,
 or @code{NULL} if this is an indirect call.
@@ -5375,7 +5375,7 @@ may vary greatly between different architectures.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_EXTRA_LIVE_ON_ENTRY (bitmap @var{regs})
-@c hook-start:TARGET_extra_live_on_entry
+@c hook-start:TARGET_EXTRA_LIVE_ON_ENTRY
 Add any hard registers to @var{regs} that are live on entry to the
 function.  This hook only needs to be defined to provide registers that
 cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved
@@ -5386,14 +5386,14 @@ FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SET_UP_BY_PROLOGUE (struct hard_reg_set_container *@var{})
-@c hook-start:TARGET_set_up_by_prologue
+@c hook-start:TARGET_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.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_WARN_FUNC_RETURN (tree)
-@c hook-start:TARGET_warn_func_return
+@c hook-start:TARGET_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.
@@ -5426,7 +5426,7 @@ and @code{shrink_wrap.components_for_bb} hooks, and deallocated by the
 generic code.
 
 @deftypefn {Target Hook} sbitmap TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS (void)
-@c hook-start:TARGET_SHRINK_WRAP_get_separate_components
+@c hook-start:TARGET_SHRINK_WRAP_GET_SEPARATE_COMPONENTS
 This hook should return an @code{sbitmap} with the bits set for those
 components that can be separately shrink-wrapped in the current function.
 Return @code{NULL} if the current function should not get any separate
@@ -5437,7 +5437,7 @@ If it is defined, the other hooks in this group have to be defined as well.
 @c hook-end
 
 @deftypefn {Target Hook} sbitmap TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB (basic_block)
-@c hook-start:TARGET_SHRINK_WRAP_components_for_bb
+@c hook-start:TARGET_SHRINK_WRAP_COMPONENTS_FOR_BB
 This hook should return an @code{sbitmap} with the bits set for those
 components where either the prologue component has to be executed before
 the @code{basic_block}, or the epilogue component after it, or both.
@@ -5445,7 +5445,7 @@ the @code{basic_block}, or the epilogue component after it, or both.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS (sbitmap @var{components}, edge @var{e}, sbitmap @var{edge_components}, bool @var{is_prologue})
-@c hook-start:TARGET_SHRINK_WRAP_disqualify_components
+@c hook-start:TARGET_SHRINK_WRAP_DISQUALIFY_COMPONENTS
 This hook should clear the bits in the @var{components} bitmap for those
 components in @var{edge_components} that the target cannot handle on edge
 @var{e}, where @var{is_prologue} says if this is for a prologue or an
@@ -5454,19 +5454,19 @@ epilogue instead.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS (sbitmap)
-@c hook-start:TARGET_SHRINK_WRAP_emit_prologue_components
+@c hook-start:TARGET_SHRINK_WRAP_EMIT_PROLOGUE_COMPONENTS
 Emit prologue insns for the components indicated by the parameter.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS (sbitmap)
-@c hook-start:TARGET_SHRINK_WRAP_emit_epilogue_components
+@c hook-start:TARGET_SHRINK_WRAP_EMIT_EPILOGUE_COMPONENTS
 Emit epilogue insns for the components indicated by the parameter.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS (sbitmap)
-@c hook-start:TARGET_SHRINK_WRAP_set_handled_components
+@c hook-start:TARGET_SHRINK_WRAP_SET_HANDLED_COMPONENTS
 Mark the components in the parameter as handled, so that the
 @code{prologue} and @code{epilogue} named patterns know to ignore those
 components.  The target code should not hang on to the @code{sbitmap}, it
@@ -5479,7 +5479,7 @@ will be deleted after this call.
 @cindex stack smashing protection
 
 @deftypefn {Target Hook} tree TARGET_STACK_PROTECT_GUARD (void)
-@c hook-start:TARGET_stack_protect_guard
+@c hook-start:TARGET_STACK_PROTECT_GUARD
 This hook returns a @code{DECL} node for the external variable to use
 for the stack protection guard.  This variable is initialized by the
 runtime to some random value and is used to initialize the guard value
@@ -5492,7 +5492,7 @@ The default version of this hook creates a variable called
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_STACK_PROTECT_FAIL (void)
-@c hook-start:TARGET_stack_protect_fail
+@c hook-start:TARGET_STACK_PROTECT_FAIL
 This hook returns a @code{CALL_EXPR} that alerts the runtime that the
 stack protect guard variable has been modified.  This expression should
 involve a call to a @code{noreturn} function.
@@ -5504,14 +5504,14 @@ normally defined in @file{libgcc2.c}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_STACK_PROTECT_RUNTIME_ENABLED_P (void)
-@c hook-start:TARGET_stack_protect_runtime_enabled_p
+@c hook-start:TARGET_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.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Common Target Hook} bool TARGET_SUPPORTS_SPLIT_STACK (bool @var{report}, struct gcc_options *@var{opts})
-@c hook-start:TARGET_supports_split_stack
+@c hook-start:TARGET_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
@@ -5522,7 +5522,7 @@ or error; if @var{report} is false, it must simply return a value
 @c hook-end
 
 @deftypefn {Common Target Hook} {vec<const char *>} TARGET_GET_VALID_OPTION_VALUES (int @var{option_code}, const char *@var{prefix})
-@c hook-start:TARGET_get_valid_option_values
+@c hook-start:TARGET_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
@@ -5537,7 +5537,7 @@ The result will be pruned to cases with PREFIX if not NULL.
 @cindex miscellaneous register hooks
 
 @deftypevr {Target Hook} bool TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS
-@c hook-start:TARGET_call_fusage_contains_non_callee_clobbers
+@c hook-start:TARGET_CALL_FUSAGE_CONTAINS_NON_CALLEE_CLOBBERS
 Set to true if each call that binds to a local definition explicitly
 clobbers or sets all non-fixed registers modified by performing the call.
 That is, by the call pattern itself, or by code that might be inserted by the
@@ -5618,7 +5618,7 @@ interpret the values of @code{__builtin_classify_type}.
 These machine description macros help implement varargs:
 
 @deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN_SAVEREGS (void)
-@c hook-start:TARGET_expand_builtin_saveregs
+@c hook-start:TARGET_EXPAND_BUILTIN_SAVEREGS
 If defined, this hook produces the machine-specific code for a call to
 @code{__builtin_saveregs}.  This code will be moved to the very
 beginning of the function, before any parameter access are made.  The
@@ -5628,7 +5628,7 @@ to use as the return of @code{__builtin_saveregs}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SETUP_INCOMING_VARARGS (cumulative_args_t @var{args_so_far}, const function_arg_info @var{&arg}, int *@var{pretend_args_size}, int @var{second_time})
-@c hook-start:TARGET_setup_incoming_varargs
+@c hook-start:TARGET_SETUP_INCOMING_VARARGS
 This target hook offers an alternative to using
 @code{__builtin_saveregs} and defining the hook
 @code{TARGET_EXPAND_BUILTIN_SAVEREGS}.  Use it to store the anonymous
@@ -5664,7 +5664,7 @@ not generate any instructions in this case.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_STRICT_ARGUMENT_NAMING (cumulative_args_t @var{ca})
-@c hook-start:TARGET_strict_argument_naming
+@c hook-start:TARGET_STRICT_ARGUMENT_NAMING
 Define this hook to return @code{true} if the location where a function
 argument is passed depends on whether or not it is a named argument.
 
@@ -5681,7 +5681,7 @@ You need not define this hook if it always returns @code{false}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_CALL_ARGS (rtx, @var{tree})
-@c hook-start:TARGET_call_args
+@c hook-start:TARGET_CALL_ARGS
 While generating RTL for a function call, this target hook is invoked once
 for each argument passed to the function, either a register returned by
 @code{TARGET_FUNCTION_ARG} or a memory location.  It is called just
@@ -5698,7 +5698,7 @@ Most ports do not need to implement anything for this hook.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_END_CALL_ARGS (void)
-@c hook-start:TARGET_end_call_args
+@c hook-start:TARGET_END_CALL_ARGS
 This target hook is invoked while generating RTL for a function call,
 just after the point where the return reg is copied into a pseudo.  It
 signals that all the call argument and return registers for the just
@@ -5708,7 +5708,7 @@ Most ports do not need to implement anything for this hook.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED (cumulative_args_t @var{ca})
-@c hook-start:TARGET_pretend_outgoing_varargs_named
+@c hook-start:TARGET_PRETEND_OUTGOING_VARARGS_NAMED
 If you need to conditionally change ABIs so that one works with
 @code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither
 @code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING} was
@@ -5719,7 +5719,7 @@ Otherwise, you should not define this hook.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_LOAD_BOUNDS_FOR_ARG (rtx @var{slot}, rtx @var{arg}, rtx @var{slot_no})
-@c hook-start:TARGET_load_bounds_for_arg
+@c hook-start:TARGET_LOAD_BOUNDS_FOR_ARG
 This hook is used by expand pass to emit insn to load bounds of
 @var{arg} passed in @var{slot}.  Expand pass uses this hook in case
 bounds of @var{arg} are not passed in register.  If @var{slot} is a
@@ -5731,7 +5731,7 @@ should be used to obtain bounds.  Hook returns RTX holding loaded bounds.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_STORE_BOUNDS_FOR_ARG (rtx @var{arg}, rtx @var{slot}, rtx @var{bounds}, rtx @var{slot_no})
-@c hook-start:TARGET_store_bounds_for_arg
+@c hook-start:TARGET_STORE_BOUNDS_FOR_ARG
 This hook is used by expand pass to emit insns to store @var{bounds} of
 @var{arg} passed in @var{slot}.  Expand pass uses this hook in case
 @var{bounds} of @var{arg} are not passed in register.  If @var{slot} is a
@@ -5743,7 +5743,7 @@ should be used to store @var{bounds}.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_LOAD_RETURNED_BOUNDS (rtx @var{slot})
-@c hook-start:TARGET_load_returned_bounds
+@c hook-start:TARGET_LOAD_RETURNED_BOUNDS
 This hook is used by expand pass to emit insn to load bounds
 returned by function call in @var{slot}.  Hook returns RTX holding
 loaded bounds.
@@ -5751,7 +5751,7 @@ loaded bounds.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_STORE_RETURNED_BOUNDS (rtx @var{slot}, rtx @var{bounds})
-@c hook-start:TARGET_store_returned_bounds
+@c hook-start:TARGET_STORE_RETURNED_BOUNDS
 This hook is used by expand pass to emit insn to store @var{bounds}
 returned by function call into @var{slot}.
 @end deftypefn
@@ -5804,7 +5804,7 @@ descriptor support, or can use GCC's generic descriptor implementation
 for nested functions.
 
 @deftypevr {Target Hook} int TARGET_CUSTOM_FUNCTION_DESCRIPTORS
-@c hook-start:TARGET_custom_function_descriptors
+@c hook-start:TARGET_CUSTOM_FUNCTION_DESCRIPTORS
 If the target can use GCC's generic descriptor mechanism for nested
 functions, define this hook to a power of 2 representing an unused bit
 in function pointers which can be used to differentiate descriptors at
@@ -5847,7 +5847,7 @@ may be necessary to take out pieces of the address and store them
 separately.
 
 @deftypefn {Target Hook} void TARGET_ASM_TRAMPOLINE_TEMPLATE (FILE *@var{f})
-@c hook-start:TARGET_ASM_trampoline_template
+@c hook-start:TARGET_ASM_TRAMPOLINE_TEMPLATE
 This hook is called by @code{assemble_trampoline_template} to output,
 on the stream @var{f}, assembler code for a block of data that contains
 the constant parts of a trampoline.  This code should not include a
@@ -5877,7 +5877,7 @@ is used for aligning trampolines.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_TRAMPOLINE_INIT (rtx @var{m_tramp}, tree @var{fndecl}, rtx @var{static_chain})
-@c hook-start:TARGET_trampoline_init
+@c hook-start:TARGET_TRAMPOLINE_INIT
 This hook is called to initialize a trampoline.
 @var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl}
 is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an
@@ -5899,7 +5899,7 @@ initializing the trampoline proper.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_EMIT_CALL_BUILTIN___CLEAR_CACHE (rtx @var{begin}, rtx @var{end})
-@c hook-start:TARGET_emit_call_builtin___clear_cache
+@c hook-start:TARGET_EMIT_CALL_BUILTIN___CLEAR_CACHE
 On targets that do not define a @code{clear_cache} insn expander,
 but that define the @code{CLEAR_CACHE_INSN} macro,
 maybe_emit_call_builtin___clear_cache relies on this target hook
@@ -5913,7 +5913,7 @@ conventions, or emit alternate RTX to perform the job.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_TRAMPOLINE_ADJUST_ADDRESS (rtx @var{addr})
-@c hook-start:TARGET_trampoline_adjust_address
+@c hook-start:TARGET_TRAMPOLINE_ADJUST_ADDRESS
 This hook should perform any machine-specific adjustment in
 the address of the trampoline.  Its argument contains the address of the
 memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}.  In case
@@ -5983,7 +5983,7 @@ are ABI-mandated names that the compiler should provide.
 @findex set_optab_libfunc
 @findex init_one_libfunc
 @deftypefn {Target Hook} void TARGET_INIT_LIBFUNCS (void)
-@c hook-start:TARGET_init_libfuncs
+@c hook-start:TARGET_INIT_LIBFUNCS
 This hook should declare additional library routines or rename
 existing ones, using the functions @code{set_optab_libfunc} and
 @code{init_one_libfunc} defined in @file{optabs.c}.
@@ -5995,7 +5995,7 @@ The default is to do nothing.  Most ports don't need to define this hook.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_LIBFUNC_GNU_PREFIX
-@c hook-start:TARGET_libfunc_gnu_prefix
+@c hook-start:TARGET_LIBFUNC_GNU_PREFIX
 If false (the default), internal library routines start with two
 underscores.  If set to true, these routines start with @code{__gnu_}
 instead.  E.g., @code{__muldi3} changes to @code{__gnu_muldi3}.  This
@@ -6059,7 +6059,7 @@ macro, a reasonable default is used.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_LIBC_HAS_FUNCTION (enum function_class @var{fn_class}, tree @var{type})
-@c hook-start:TARGET_libc_has_function
+@c hook-start:TARGET_LIBC_HAS_FUNCTION
 This hook determines whether a function from a class of functions
 @var{fn_class} is present in the target C library.  If @var{type} is NULL,
 the caller asks for support for all standard (float, double, long double)
@@ -6069,7 +6069,7 @@ specific type.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LIBC_HAS_FAST_FUNCTION (int @var{fcode})
-@c hook-start:TARGET_libc_has_fast_function
+@c hook-start:TARGET_LIBC_HAS_FAST_FUNCTION
 This hook determines whether a function from a class of functions
 @code{(enum function_class)}@var{fcode} has a fast implementation.
 @end deftypefn
@@ -6142,7 +6142,7 @@ accept.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{x}, bool @var{strict})
-@c hook-start:TARGET_legitimate_address_p
+@c hook-start:TARGET_LEGITIMATE_ADDRESS_P
 A function that returns whether @var{x} (an RTX) is a legitimate memory
 address on the target machine for a memory operand of mode @var{mode}.
 
@@ -6233,7 +6233,7 @@ a label_ref or symbol_ref within an UNSPEC@.
 @end defmac
 
 @deftypefn {Target Hook} rtx TARGET_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, machine_mode @var{mode})
-@c hook-start:TARGET_legitimize_address
+@c hook-start:TARGET_LEGITIMIZE_ADDRESS
 This hook is given an invalid memory address @var{x} for an
 operand of mode @var{mode} and should try to return a valid memory
 address.
@@ -6307,7 +6307,7 @@ address;  but often a machine-dependent strategy can generate better code.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_MODE_DEPENDENT_ADDRESS_P (const_rtx @var{addr}, addr_space_t @var{addrspace})
-@c hook-start:TARGET_mode_dependent_address_p
+@c hook-start:TARGET_MODE_DEPENDENT_ADDRESS_P
 This hook returns @code{true} if memory address @var{addr} in address
 space @var{addrspace} can have
 different meanings depending on the machine mode of the memory
@@ -6326,7 +6326,7 @@ The default version of this hook returns @code{false}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LEGITIMATE_CONSTANT_P (machine_mode @var{mode}, rtx @var{x})
-@c hook-start:TARGET_legitimate_constant_p
+@c hook-start:TARGET_LEGITIMATE_CONSTANT_P
 This hook returns true if @var{x} is a legitimate constant for a
 @var{mode}-mode immediate operand on the target machine.  You can assume that
 @var{x} satisfies @code{CONSTANT_P}, so you need not check this.
@@ -6336,7 +6336,7 @@ The default definition returns true.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PRECOMPUTE_TLS_P (machine_mode @var{mode}, rtx @var{x})
-@c hook-start:TARGET_precompute_tls_p
+@c hook-start:TARGET_PRECOMPUTE_TLS_P
 This hook returns true if @var{x} is a TLS operand on the target
 machine that should be pre-computed when used as the argument in a call.
 You can assume that @var{x} satisfies @code{CONSTANT_P}, so you need not 
@@ -6347,7 +6347,7 @@ The default definition returns false.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_DELEGITIMIZE_ADDRESS (rtx @var{x})
-@c hook-start:TARGET_delegitimize_address
+@c hook-start:TARGET_DELEGITIMIZE_ADDRESS
 This hook is used to undo the possibly obfuscating effects of the
 @code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target
 macros.  Some backend implementations of these macros wrap symbol
@@ -6359,14 +6359,14 @@ into their original form.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CONST_NOT_OK_FOR_DEBUG_P (rtx @var{x})
-@c hook-start:TARGET_const_not_ok_for_debug_p
+@c hook-start:TARGET_CONST_NOT_OK_FOR_DEBUG_P
 This hook should return true if @var{x} should not be emitted into
 debug sections.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CANNOT_FORCE_CONST_MEM (machine_mode @var{mode}, rtx @var{x})
-@c hook-start:TARGET_cannot_force_const_mem
+@c hook-start:TARGET_CANNOT_FORCE_CONST_MEM
 This hook should return true if @var{x} is of a form that cannot (or
 should not) be spilled to the constant pool.  @var{mode} is the mode
 of @var{x}.
@@ -6382,7 +6382,7 @@ of TLS symbols for various targets.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (machine_mode @var{mode}, const_rtx @var{x})
-@c hook-start:TARGET_use_blocks_for_constant_p
+@c hook-start:TARGET_USE_BLOCKS_FOR_CONSTANT_P
 This hook should return true if pool entries for constant @var{x} can
 be placed in an @code{object_block} structure.  @var{mode} is the mode
 of @var{x}.
@@ -6392,7 +6392,7 @@ The default version returns false for all constants.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_USE_BLOCKS_FOR_DECL_P (const_tree @var{decl})
-@c hook-start:TARGET_use_blocks_for_decl_p
+@c hook-start:TARGET_USE_BLOCKS_FOR_DECL_P
 This hook should return true if pool entries for @var{decl} should
 be placed in an @code{object_block} structure.
 
@@ -6401,7 +6401,7 @@ The default version returns true for all decls.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_BUILTIN_RECIPROCAL (tree @var{fndecl})
-@c hook-start:TARGET_builtin_reciprocal
+@c hook-start:TARGET_BUILTIN_RECIPROCAL
 This hook should return the DECL of a function that implements the
 reciprocal of the machine-specific builtin function @var{fndecl}, or
 @code{NULL_TREE} if such a function is not available.
@@ -6409,7 +6409,7 @@ reciprocal of the machine-specific builtin function @var{fndecl}, or
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void)
-@c hook-start:TARGET_VECTORIZE_builtin_mask_for_load
+@c hook-start:TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
 This hook should return the DECL of a function @var{f} that given an
 address @var{addr} as an argument returns a mask @var{m} that can be
 used to extract from two vectors the relevant data that resides in
@@ -6440,7 +6440,7 @@ log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST (enum vect_cost_for_stmt @var{type_of_cost}, tree @var{vectype}, int @var{misalign})
-@c hook-start:TARGET_VECTORIZE_builtin_vectorization_cost
+@c hook-start:TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
 Returns cost of different scalar or vector statements for vectorization cost model.
 For vector memory operations the cost may depend on type (@var{vectype}) and
 misalignment value (@var{misalign}).
@@ -6448,7 +6448,7 @@ misalignment value (@var{misalign}).
 @c hook-end
 
 @deftypefn {Target Hook} poly_uint64 TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT (const_tree @var{type})
-@c hook-start:TARGET_VECTORIZE_preferred_vector_alignment
+@c hook-start:TARGET_VECTORIZE_PREFERRED_VECTOR_ALIGNMENT
 This hook returns the preferred alignment in bits for accesses to
 vectors of type @var{type} in vectorized code.  This might be less than
 or greater than the ABI-defined value returned by
@@ -6462,7 +6462,7 @@ correct for most targets.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE (const_tree @var{type}, bool @var{is_packed})
-@c hook-start:TARGET_VECTORIZE_vector_alignment_reachable
+@c hook-start:TARGET_VECTORIZE_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.
@@ -6470,7 +6470,7 @@ access using @var{type} is known to be naturally aligned.
 @c hook-end
 
 @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})
-@c hook-start:TARGET_VECTORIZE_vec_perm_const
+@c hook-start:TARGET_VECTORIZE_VEC_PERM_CONST
 This hook is used to test whether the target can permute up to two
 vectors of mode @var{mode} using the permutation vector @code{sel}, and
 also to emit such a permutation.  In the former case @var{in0}, @var{in1}
@@ -6492,7 +6492,7 @@ implementation approaches itself.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION (unsigned @var{code}, tree @var{vec_type_out}, tree @var{vec_type_in})
-@c hook-start:TARGET_VECTORIZE_builtin_vectorized_function
+@c hook-start:TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
 This hook should return the decl of a function that implements the
 vectorized variant of the function with the @code{combined_fn} code
 @var{code} or @code{NULL_TREE} if such a function is not available.
@@ -6502,7 +6502,7 @@ The return type of the vectorized function shall be of vector type
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION (tree @var{fndecl}, tree @var{vec_type_out}, tree @var{vec_type_in})
-@c hook-start:TARGET_VECTORIZE_builtin_md_vectorized_function
+@c hook-start:TARGET_VECTORIZE_BUILTIN_MD_VECTORIZED_FUNCTION
 This hook should return the decl of a function that implements the
 vectorized variant of target built-in function @code{fndecl}.  The
 return type of the vectorized function shall be of vector type
@@ -6511,7 +6511,7 @@ return type of the vectorized function shall be of vector type
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed})
-@c hook-start:TARGET_VECTORIZE_support_vector_misalignment
+@c hook-start:TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
 This hook should return true if the target supports misaligned vector
 store/load of a specific factor denoted in the @var{misalignment}
 parameter.  The vector store/load should be of machine mode @var{mode} and
@@ -6521,7 +6521,7 @@ parameter is true if the memory access is defined in a packed struct.
 @c hook-end
 
 @deftypefn {Target Hook} machine_mode TARGET_VECTORIZE_PREFERRED_SIMD_MODE (scalar_mode @var{mode})
-@c hook-start:TARGET_VECTORIZE_preferred_simd_mode
+@c hook-start:TARGET_VECTORIZE_PREFERRED_SIMD_MODE
 This hook should return the preferred mode for vectorizing scalar
 mode @var{mode}.  The default is
 equal to @code{word_mode}, because the vectorizer can do some
@@ -6530,7 +6530,7 @@ transformations even in absence of specialized @acronym{SIMD} hardware.
 @c hook-end
 
 @deftypefn {Target Hook} machine_mode TARGET_VECTORIZE_SPLIT_REDUCTION (machine_mode)
-@c hook-start:TARGET_VECTORIZE_split_reduction
+@c hook-start:TARGET_VECTORIZE_SPLIT_REDUCTION
 This hook should return the preferred mode to split the final reduction
 step on @var{mode} to.  The reduction is then carried out reducing upper
 against lower halves of vectors recursively until the specified mode is
@@ -6539,7 +6539,7 @@ reached.  The default is @var{mode} which means no splitting.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES (vector_modes *@var{modes}, bool @var{all})
-@c hook-start:TARGET_VECTORIZE_autovectorize_vector_modes
+@c hook-start:TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_MODES
 If using the mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}
 is not the only approach worth considering, this hook should add one mode to
 @var{modes} for each useful alternative approach.  These modes are then
@@ -6572,7 +6572,7 @@ returns 0.
 @c hook-end
 
 @deftypefn {Target Hook} opt_machine_mode TARGET_VECTORIZE_RELATED_MODE (machine_mode @var{vector_mode}, scalar_mode @var{element_mode}, poly_uint64 @var{nunits})
-@c hook-start:TARGET_VECTORIZE_related_mode
+@c hook-start:TARGET_VECTORIZE_RELATED_MODE
 If a piece of code is using vector mode @var{vector_mode} and also wants
 to operate on elements of mode @var{element_mode}, return the vector mode
 it should use for those elements.  If @var{nunits} is nonzero, ensure that
@@ -6598,7 +6598,7 @@ when @var{nunits} is zero.  This is the correct behavior for most targets.
 @c hook-end
 
 @deftypefn {Target Hook} opt_machine_mode TARGET_VECTORIZE_GET_MASK_MODE (machine_mode @var{mode})
-@c hook-start:TARGET_VECTORIZE_get_mask_mode
+@c hook-start:TARGET_VECTORIZE_GET_MASK_MODE
 Return the mode to use for a vector mask that holds one boolean
 result for each element of vector mode @var{mode}.  The returned mask mode
 can be a vector of integers (class @code{MODE_VECTOR_INT}), a vector of
@@ -6612,7 +6612,7 @@ same size and number of elements as @var{mode}, if such a mode exists.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE (unsigned @var{ifn})
-@c hook-start:TARGET_VECTORIZE_empty_mask_is_expensive
+@c hook-start:TARGET_VECTORIZE_EMPTY_MASK_IS_EXPENSIVE
 This hook returns true if masked internal function @var{ifn} (really of
 type @code{internal_fn}) should be considered expensive when the mask is
 all zeros.  GCC can then try to branch around the instruction instead.
@@ -6620,7 +6620,7 @@ all zeros.  GCC can then try to branch around the instruction instead.
 @c hook-end
 
 @deftypefn {Target Hook} {void *} TARGET_VECTORIZE_INIT_COST (class loop *@var{loop_info}, bool @var{costing_for_scalar})
-@c hook-start:TARGET_VECTORIZE_init_cost
+@c hook-start:TARGET_VECTORIZE_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,
@@ -6633,7 +6633,7 @@ it is for the vector version.
 @c hook-end
 
 @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})
-@c hook-start:TARGET_VECTORIZE_add_stmt_cost
+@c hook-start:TARGET_VECTORIZE_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
@@ -6645,7 +6645,7 @@ revised.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_VECTORIZE_FINISH_COST (void *@var{data}, unsigned *@var{prologue_cost}, unsigned *@var{body_cost}, unsigned *@var{epilogue_cost})
-@c hook-start:TARGET_VECTORIZE_finish_cost
+@c hook-start:TARGET_VECTORIZE_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
@@ -6654,7 +6654,7 @@ the three accumulators.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_VECTORIZE_DESTROY_COST_DATA (void *@var{data})
-@c hook-start:TARGET_VECTORIZE_destroy_cost_data
+@c hook-start:TARGET_VECTORIZE_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.
@@ -6662,7 +6662,7 @@ accumulator.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_GATHER (const_tree @var{mem_vectype}, const_tree @var{index_type}, int @var{scale})
-@c hook-start:TARGET_VECTORIZE_builtin_gather
+@c hook-start:TARGET_VECTORIZE_BUILTIN_GATHER
 Target builtin that implements vector gather operation.  @var{mem_vectype}
 is the vector type of the load and @var{index_type} is scalar type of
 the index, scaled by @var{scale}.
@@ -6672,7 +6672,7 @@ loads.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_SCATTER (const_tree @var{vectype}, const_tree @var{index_type}, int @var{scale})
-@c hook-start:TARGET_VECTORIZE_builtin_scatter
+@c hook-start:TARGET_VECTORIZE_BUILTIN_SCATTER
 Target builtin that implements vector scatter operation.  @var{vectype}
 is the vector type of the store and @var{index_type} is scalar type of
 the index, scaled by @var{scale}.
@@ -6682,7 +6682,7 @@ stores.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN (struct cgraph_node *@var{}, struct cgraph_simd_clone *@var{}, @var{tree}, @var{int})
-@c hook-start:TARGET_SIMD_CLONE_compute_vecsize_and_simdlen
+@c hook-start:TARGET_SIMD_CLONE_COMPUTE_VECSIZE_AND_SIMDLEN
 This hook should set @var{vecsize_mangle}, @var{vecsize_int}, @var{vecsize_float}
 fields in @var{simd_clone} structure pointed by @var{clone_info} argument and also
 @var{simdlen} field if it was previously 0.
@@ -6692,14 +6692,14 @@ or number of @var{vecsize_mangle} variants that should be emitted.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SIMD_CLONE_ADJUST (struct cgraph_node *@var{})
-@c hook-start:TARGET_SIMD_CLONE_adjust
+@c hook-start:TARGET_SIMD_CLONE_ADJUST
 This hook should add implicit @code{attribute(target("..."))} attribute
 to SIMD clone @var{node} if needed.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SIMD_CLONE_USABLE (struct cgraph_node *@var{})
-@c hook-start:TARGET_SIMD_CLONE_usable
+@c hook-start:TARGET_SIMD_CLONE_USABLE
 This hook should return -1 if SIMD clone @var{node} shouldn't be used
 in vectorized loops in current function, or non-negative number if it is
 usable.  In that case, the smaller the number is, the more desirable it is
@@ -6708,13 +6708,13 @@ to use it.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SIMT_VF (void)
-@c hook-start:TARGET_SIMT_vf
+@c hook-start:TARGET_SIMT_VF
 Return number of threads in SIMT thread group on the target.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_OMP_DEVICE_KIND_ARCH_ISA (enum omp_device_kind_arch_isa @var{trait}, const char *@var{name})
-@c hook-start:TARGET_OMP_device_kind_arch_isa
+@c hook-start:TARGET_OMP_DEVICE_KIND_ARCH_ISA
 Return 1 if @var{trait} @var{name} is present in the OpenMP context's
 device trait set, return 0 if not present in any OpenMP context in the
 whole translation unit, or -1 if not present in the current OpenMP context
@@ -6723,7 +6723,7 @@ but might be present in another OpenMP context in the same TU.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_GOACC_VALIDATE_DIMS (tree @var{decl}, int *@var{dims}, int @var{fn_level}, unsigned @var{used})
-@c hook-start:TARGET_GOACC_validate_dims
+@c hook-start:TARGET_GOACC_VALIDATE_DIMS
 This hook should check the launch dimensions provided for an OpenACC
 compute region, or routine.  Defaulted values are represented as -1
 and non-constant values as 0.  The @var{fn_level} is negative for the
@@ -6738,14 +6738,14 @@ provide dimensions larger than 1.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_GOACC_DIM_LIMIT (int @var{axis})
-@c hook-start:TARGET_GOACC_dim_limit
+@c hook-start:TARGET_GOACC_DIM_LIMIT
 This hook should return the maximum size of a particular dimension,
 or zero if unbounded.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_GOACC_FORK_JOIN (gcall *@var{call}, const int *@var{dims}, bool @var{is_fork})
-@c hook-start:TARGET_GOACC_fork_join
+@c hook-start:TARGET_GOACC_FORK_JOIN
 This hook can be used to convert IFN_GOACC_FORK and IFN_GOACC_JOIN
 function calls to target-specific gimple, or indicate whether they
 should be retained.  It is executed during the oacc_device_lower pass.
@@ -6757,7 +6757,7 @@ The default hook returns false, if there are no RTL expanders for them.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_GOACC_REDUCTION (gcall *@var{call})
-@c hook-start:TARGET_GOACC_reduction
+@c hook-start:TARGET_GOACC_REDUCTION
 This hook is used by the oacc_transform pass to expand calls to the
 @var{GOACC_REDUCTION} internal function, into a sequence of gimple
 instructions.  @var{call} is gimple statement containing the call to
@@ -6768,7 +6768,7 @@ for allocating any storage for reductions when necessary.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_PREFERRED_ELSE_VALUE (unsigned @var{ifn}, tree @var{type}, unsigned @var{nops}, tree *@var{ops})
-@c hook-start:TARGET_preferred_else_value
+@c hook-start:TARGET_PREFERRED_ELSE_VALUE
 This hook returns the target's preferred final argument for a call
 to conditional internal function @var{ifn} (really of type
 @code{internal_fn}).  @var{type} specifies the return type of the
@@ -6786,7 +6786,7 @@ constant of type @var{type}.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_GOACC_ADJUST_PRIVATE_DECL (location_t @var{loc}, tree @var{var}, int @var{level})
-@c hook-start:TARGET_GOACC_adjust_private_decl
+@c hook-start:TARGET_GOACC_ADJUST_PRIVATE_DECL
 This hook, if defined, is used by accelerator target back-ends to adjust
 OpenACC variable declarations that should be made private to the given
 parallelism level (i.e. @code{GOMP_DIM_GANG}, @code{GOMP_DIM_WORKER} or
@@ -6801,7 +6801,7 @@ way.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_GOACC_EXPAND_VAR_DECL (tree @var{var})
-@c hook-start:TARGET_GOACC_expand_var_decl
+@c hook-start:TARGET_GOACC_EXPAND_VAR_DECL
 This hook, if defined, is used by accelerator target back-ends to expand
 specially handled kinds of @code{VAR_DECL} expressions.  A particular use is
 to place variables with specific attributes inside special accelarator
@@ -6851,7 +6851,7 @@ section anchors at all unless either @code{TARGET_MIN_ANCHOR_OFFSET}
 or @code{TARGET_MAX_ANCHOR_OFFSET} is set to a nonzero value.
 
 @deftypevr {Target Hook} HOST_WIDE_INT TARGET_MIN_ANCHOR_OFFSET
-@c hook-start:TARGET_min_anchor_offset
+@c hook-start:TARGET_MIN_ANCHOR_OFFSET
 The minimum offset that should be applied to a section anchor.
 On most targets, it should be the smallest offset that can be
 applied to a base register while still giving a legitimate address
@@ -6860,7 +6860,7 @@ for every mode.  The default value is 0.
 @c hook-end
 
 @deftypevr {Target Hook} HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET
-@c hook-start:TARGET_max_anchor_offset
+@c hook-start:TARGET_MAX_ANCHOR_OFFSET
 Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive)
 offset that should be applied to section anchors.  The default
 value is 0.
@@ -6868,7 +6868,7 @@ value is 0.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_ANCHOR (rtx @var{x})
-@c hook-start:TARGET_ASM_output_anchor
+@c hook-start:TARGET_ASM_OUTPUT_ANCHOR
 Write the assembly code to define section anchor @var{x}, which is a
 @code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true.
 The hook is called with the assembly output position set to the beginning
@@ -6882,7 +6882,7 @@ is @code{NULL}, which disables the use of section anchors altogether.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_USE_ANCHORS_FOR_SYMBOL_P (const_rtx @var{x})
-@c hook-start:TARGET_use_anchors_for_symbol_p
+@c hook-start:TARGET_USE_ANCHORS_FOR_SYMBOL_P
 Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF}
 @var{x}.  You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and
 @samp{!SYMBOL_REF_ANCHOR_P (@var{x})}.
@@ -6991,7 +6991,7 @@ in @file{@var{machine}-modes.def}.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_CANONICALIZE_COMPARISON (int *@var{code}, rtx *@var{op0}, rtx *@var{op1}, bool @var{op0_preserve_value})
-@c hook-start:TARGET_canonicalize_comparison
+@c hook-start:TARGET_CANONICALIZE_COMPARISON
 On some machines not all possible comparisons are defined, but you can
 convert an invalid comparison into a valid one.  For example, the Alpha
 does not have a @code{GT} comparison, but you can use an @code{LT}
@@ -7048,7 +7048,7 @@ like:
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_FIXED_CONDITION_CODE_REGS (unsigned int *@var{p1}, unsigned int *@var{p2})
-@c hook-start:TARGET_fixed_condition_code_regs
+@c hook-start:TARGET_FIXED_CONDITION_CODE_REGS
 On targets which use a hard
 register rather than a pseudo-register to hold condition codes, the
 regular CSE passes are often not able to identify cases in which the
@@ -7065,7 +7065,7 @@ The default version of this hook returns false.
 @c hook-end
 
 @deftypefn {Target Hook} machine_mode TARGET_CC_MODES_COMPATIBLE (machine_mode @var{m1}, machine_mode @var{m2})
-@c hook-start:TARGET_cc_modes_compatible
+@c hook-start:TARGET_CC_MODES_COMPATIBLE
 On targets which use multiple condition code modes in class
 @code{MODE_CC}, it is sometimes the case that a comparison can be
 validly done in more than one mode.  On such a system, define this
@@ -7080,7 +7080,7 @@ returns @code{VOIDmode}.
 @c hook-end
 
 @deftypevr {Target Hook} {unsigned int} TARGET_FLAGS_REGNUM
-@c hook-start:TARGET_flags_regnum
+@c hook-start:TARGET_FLAGS_REGNUM
 If the target has a dedicated flags register, and it needs to use the
 post-reload comparison elimination pass, or the delay slot filler pass,
 then this value should be set appropriately.
@@ -7119,7 +7119,7 @@ These macros are obsolete, new ports should use the target hook
 @end defmac
 
 @deftypefn {Target Hook} int TARGET_REGISTER_MOVE_COST (machine_mode @var{mode}, reg_class_t @var{from}, reg_class_t @var{to})
-@c hook-start:TARGET_register_move_cost
+@c hook-start:TARGET_REGISTER_MOVE_COST
 This target hook should return the cost of moving data of mode @var{mode}
 from a register in class @var{from} to one in class @var{to}.  The classes
 are expressed using the enumeration values such as @code{GENERAL_REGS}.
@@ -7169,7 +7169,7 @@ These macros are obsolete, new ports should use the target hook
 @end defmac
 
 @deftypefn {Target Hook} int TARGET_MEMORY_MOVE_COST (machine_mode @var{mode}, reg_class_t @var{rclass}, bool @var{in})
-@c hook-start:TARGET_memory_move_cost
+@c hook-start:TARGET_MEMORY_MOVE_COST
 This target hook should return the cost of moving data of mode @var{mode}
 between a register of class @var{rclass} and memory; @var{in} is @code{false}
 if the value is to be written to memory, @code{true} if it is to be read in.
@@ -7224,7 +7224,7 @@ other fields in the same word of the structure, but to different bytes.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_SLOW_UNALIGNED_ACCESS (machine_mode @var{mode}, unsigned int @var{align})
-@c hook-start:TARGET_slow_unaligned_access
+@c hook-start:TARGET_SLOW_UNALIGNED_ACCESS
 This hook returns true if memory accesses described by the
 @var{mode} and @var{alignment} parameters have a cost many times greater
 than aligned accesses, for example if they are emulated in a trap handler.
@@ -7259,7 +7259,7 @@ If you don't define this, a reasonable default is used.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_USE_BY_PIECES_INFRASTRUCTURE_P (unsigned HOST_WIDE_INT @var{size}, unsigned int @var{alignment}, enum by_pieces_operation @var{op}, bool @var{speed_p})
-@c hook-start:TARGET_use_by_pieces_infrastructure_p
+@c hook-start:TARGET_USE_BY_PIECES_INFRASTRUCTURE_P
 GCC will attempt several strategies when asked to copy between
 two areas of memory, or to set, clear or store to memory, for example
 when copying a @code{struct}. The @code{by_pieces} infrastructure
@@ -7296,7 +7296,7 @@ move would be greater than that of a library call.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_OVERLAP_OP_BY_PIECES_P (void)
-@c hook-start:TARGET_overlap_op_by_pieces_p
+@c hook-start:TARGET_OVERLAP_OP_BY_PIECES_P
 This target hook should return true if when the @code{by_pieces}
 infrastructure is used, an offset adjusted unaligned memory operation
 in the smallest integer mode for the last piece operation of a memory
@@ -7305,7 +7305,7 @@ region can be generated to avoid doing more than one smaller operations.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_COMPARE_BY_PIECES_BRANCH_RATIO (machine_mode @var{mode})
-@c hook-start:TARGET_compare_by_pieces_branch_ratio
+@c hook-start:TARGET_COMPARE_BY_PIECES_BRANCH_RATIO
 When expanding a block comparison in MODE, gcc can try to reduce the
 number of branches at the expense of more memory operations.  This hook
 allows the target to override the default choice.  It should return the
@@ -7418,7 +7418,7 @@ Define this macro if a non-short-circuit operation produced by
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_OPTAB_SUPPORTED_P (int @var{op}, machine_mode @var{mode1}, machine_mode @var{mode2}, optimization_type @var{opt_type})
-@c hook-start:TARGET_optab_supported_p
+@c hook-start:TARGET_OPTAB_SUPPORTED_P
 Return true if the optimizers should use optab @var{op} with
 modes @var{mode1} and @var{mode2} for optimization type @var{opt_type}.
 The optab is known to have an associated @file{.md} instruction
@@ -7434,7 +7434,7 @@ The default hook returns true for all inputs.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, machine_mode @var{mode}, int @var{outer_code}, int @var{opno}, int *@var{total}, bool @var{speed})
-@c hook-start:TARGET_rtx_costs
+@c hook-start:TARGET_RTX_COSTS
 This target hook describes the relative costs of RTL expressions.
 
 The cost may depend on the precise form of the expression, which is
@@ -7468,7 +7468,7 @@ processed, and false when @code{rtx_cost} should recurse.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address}, machine_mode @var{mode}, addr_space_t @var{as}, bool @var{speed})
-@c hook-start:TARGET_address_cost
+@c hook-start:TARGET_ADDRESS_COST
 This hook computes the cost of an addressing mode that contains
 @var{address}.  If not defined, the cost is computed from
 the @var{address} expression and the @code{TARGET_RTX_COST} hook.
@@ -7505,7 +7505,7 @@ registers on machines with lots of registers.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_INSN_COST (rtx_insn *@var{insn}, bool @var{speed})
-@c hook-start:TARGET_insn_cost
+@c hook-start:TARGET_INSN_COST
 This target hook describes the relative costs of RTL instructions.
 
 In implementing this hook, you can use the construct
@@ -7519,7 +7519,7 @@ size cost of an expression, again relative to @code{COSTS_N_INSNS}.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_MAX_NOCE_IFCVT_SEQ_COST (edge @var{e})
-@c hook-start:TARGET_max_noce_ifcvt_seq_cost
+@c hook-start:TARGET_MAX_NOCE_IFCVT_SEQ_COST
 This hook returns a value in the same units as @code{TARGET_RTX_COSTS},
 giving the maximum acceptable cost for a sequence generated by the RTL
 if-conversion pass when conditional execution is not available.
@@ -7541,7 +7541,7 @@ and uses a multiple of @code{BRANCH_COST} otherwise.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_NOCE_CONVERSION_PROFITABLE_P (rtx_insn *@var{seq}, struct noce_if_info *@var{if_info})
-@c hook-start:TARGET_noce_conversion_profitable_p
+@c hook-start:TARGET_NOCE_CONVERSION_PROFITABLE_P
 This hook returns true if the instruction sequence @code{seq} is a good
 candidate as a replacement for the if-convertible sequence described in
 @code{if_info}.
@@ -7549,7 +7549,7 @@ candidate as a replacement for the if-convertible sequence described in
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_NEW_ADDRESS_PROFITABLE_P (rtx @var{memref}, rtx_insn * @var{insn}, rtx @var{new_addr})
-@c hook-start:TARGET_new_address_profitable_p
+@c hook-start:TARGET_NEW_ADDRESS_PROFITABLE_P
 Return @code{true} if it is profitable to replace the address in
 @var{memref} with @var{new_addr}.  This allows targets to prevent the
 scheduler from undoing address optimizations.  The instruction containing the
@@ -7558,7 +7558,7 @@ memref is @var{insn}.  The default implementation returns @code{true}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P (void)
-@c hook-start:TARGET_no_speculation_in_delay_slots_p
+@c hook-start:TARGET_NO_SPECULATION_IN_DELAY_SLOTS_P
 This predicate controls the use of the eager delay slot filler to disallow
 speculatively executed instructions being placed in delay slots.  Targets
 such as certain MIPS architectures possess both branches with and without
@@ -7570,7 +7570,7 @@ as the delay slot can hide a pipeline bubble.
 @c hook-end
 
 @deftypefn {Target Hook} HOST_WIDE_INT TARGET_ESTIMATED_POLY_VALUE (poly_int64 @var{val}, poly_value_estimate_kind @var{kind})
-@c hook-start:TARGET_estimated_poly_value
+@c hook-start:TARGET_ESTIMATED_POLY_VALUE
 Return an estimate of the runtime value of @var{val}, for use in
 things like cost calculations or profiling frequencies.  @var{kind} is used
 to ask for the minimum, maximum, and likely estimates of the value through
@@ -7589,7 +7589,7 @@ hooks for this purpose.  It is usually enough to define just a few of
 them: try the first ones in this list first.
 
 @deftypefn {Target Hook} int TARGET_SCHED_ISSUE_RATE (void)
-@c hook-start:TARGET_SCHED_issue_rate
+@c hook-start:TARGET_SCHED_ISSUE_RATE
 This hook returns the maximum number of instructions that can ever
 issue at the same time on the target machine.  The default is one.
 Although the insn scheduler can define itself the possibility of issue
@@ -7603,7 +7603,7 @@ it to vary depending on what the instructions are, you must use
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_VARIABLE_ISSUE (FILE *@var{file}, int @var{verbose}, rtx_insn *@var{insn}, int @var{more})
-@c hook-start:TARGET_SCHED_variable_issue
+@c hook-start:TARGET_SCHED_VARIABLE_ISSUE
 This hook is executed by the scheduler after it has scheduled an insn
 from the ready list.  It should return the number of insns which can
 still be issued in the current cycle.  The default is
@@ -7619,7 +7619,7 @@ was scheduled.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_ADJUST_COST (rtx_insn *@var{insn}, int @var{dep_type1}, rtx_insn *@var{dep_insn}, int @var{cost}, unsigned int @var{dw})
-@c hook-start:TARGET_SCHED_adjust_cost
+@c hook-start:TARGET_SCHED_ADJUST_COST
 This function corrects the value of @var{cost} based on the
 relationship between @var{insn} and @var{dep_insn} through a
 dependence of type dep_type, and strength @var{dw}.  It should return the new
@@ -7636,7 +7636,7 @@ acceptable, you could use the hook to modify them too.  See also
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_ADJUST_PRIORITY (rtx_insn *@var{insn}, int @var{priority})
-@c hook-start:TARGET_SCHED_adjust_priority
+@c hook-start:TARGET_SCHED_ADJUST_PRIORITY
 This hook adjusts the integer scheduling priority @var{priority} of
 @var{insn}.  It should return the new priority.  Increase the priority to
 execute @var{insn} earlier, reduce the priority to execute @var{insn}
@@ -7646,7 +7646,7 @@ scheduling priorities of insns.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_REORDER (FILE *@var{file}, int @var{verbose}, rtx_insn **@var{ready}, int *@var{n_readyp}, int @var{clock})
-@c hook-start:TARGET_SCHED_reorder
+@c hook-start:TARGET_SCHED_REORDER
 This hook is executed by the scheduler after it has scheduled the ready
 list, to allow the machine description to reorder it (for example to
 combine two small instructions together on @samp{VLIW} machines).
@@ -7665,7 +7665,7 @@ can issue this cycle; normally this is just @code{issue_rate}.  See also
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_REORDER2 (FILE *@var{file}, int @var{verbose}, rtx_insn **@var{ready}, int *@var{n_readyp}, int @var{clock})
-@c hook-start:TARGET_SCHED_reorder2
+@c hook-start:TARGET_SCHED_REORDER2
 Like @samp{TARGET_SCHED_REORDER}, but called at a different time.  That
 function is called whenever the scheduler starts a new cycle.  This one
 is called once per iteration over a cycle, immediately after
@@ -7678,13 +7678,13 @@ cycle.  These other insns can then be taken into account properly.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_MACRO_FUSION_P (void)
-@c hook-start:TARGET_SCHED_macro_fusion_p
+@c hook-start:TARGET_SCHED_MACRO_FUSION_P
 This hook is used to check whether target platform supports macro fusion.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_MACRO_FUSION_PAIR_P (rtx_insn *@var{prev}, rtx_insn *@var{curr})
-@c hook-start:TARGET_SCHED_macro_fusion_pair_p
+@c hook-start:TARGET_SCHED_MACRO_FUSION_PAIR_P
 This hook is used to check whether two insns should be macro fused for
 a target microarchitecture. If this hook returns true for the given insn pair
 (@var{prev} and @var{curr}), the scheduler will put them into a sched
@@ -7695,7 +7695,7 @@ validate any dependencies needed to fuse the two insns together.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK (rtx_insn *@var{head}, rtx_insn *@var{tail})
-@c hook-start:TARGET_SCHED_dependencies_evaluation_hook
+@c hook-start:TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK
 This hook is called after evaluation forward dependencies of insns in
 chain given by two parameter values (@var{head} and @var{tail}
 correspondingly) but before insns scheduling of the insn chain.  For
@@ -7707,7 +7707,7 @@ calculated.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_INIT (FILE *@var{file}, int @var{verbose}, int @var{max_ready})
-@c hook-start:TARGET_SCHED_init
+@c hook-start:TARGET_SCHED_INIT
 This hook is executed by the scheduler at the beginning of each block of
 instructions that are to be scheduled.  @var{file} is either a null
 pointer, or a stdio stream to write any debug output to.  @var{verbose}
@@ -7719,7 +7719,7 @@ scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FINISH (FILE *@var{file}, int @var{verbose})
-@c hook-start:TARGET_SCHED_finish
+@c hook-start:TARGET_SCHED_FINISH
 This hook is executed by the scheduler at the end of each block of
 instructions that are to be scheduled.  It can be used to perform
 cleanup of any actions done by the other scheduling hooks.  @var{file}
@@ -7730,7 +7730,7 @@ to.  @var{verbose} is the verbose level provided by
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_INIT_GLOBAL (FILE *@var{file}, int @var{verbose}, int @var{old_max_uid})
-@c hook-start:TARGET_SCHED_init_global
+@c hook-start:TARGET_SCHED_INIT_GLOBAL
 This hook is executed by the scheduler after function level initializations.
 @var{file} is either a null pointer, or a stdio stream to write any debug output to.
 @var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.
@@ -7739,7 +7739,7 @@ This hook is executed by the scheduler after function level initializations.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FINISH_GLOBAL (FILE *@var{file}, int @var{verbose})
-@c hook-start:TARGET_SCHED_finish_global
+@c hook-start:TARGET_SCHED_FINISH_GLOBAL
 This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.
 @var{file} is either a null pointer, or a stdio stream to write any debug output to.
 @var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.
@@ -7747,7 +7747,7 @@ This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_SCHED_DFA_PRE_CYCLE_INSN (void)
-@c hook-start:TARGET_SCHED_dfa_pre_cycle_insn
+@c hook-start:TARGET_SCHED_DFA_PRE_CYCLE_INSN
 The hook returns an RTL insn.  The automaton state used in the
 pipeline hazard recognizer is changed as if the insn were scheduled
 when the new simulated processor cycle starts.  Usage of the hook may
@@ -7759,13 +7759,13 @@ when the new simulated processor cycle starts.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN (void)
-@c hook-start:TARGET_SCHED_init_dfa_pre_cycle_insn
+@c hook-start:TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN
 The hook can be used to initialize data used by the previous hook.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} {rtx_insn *} TARGET_SCHED_DFA_POST_CYCLE_INSN (void)
-@c hook-start:TARGET_SCHED_dfa_post_cycle_insn
+@c hook-start:TARGET_SCHED_DFA_POST_CYCLE_INSN
 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
 to changed the state as if the insn were scheduled when the new
 simulated processor cycle finishes.
@@ -7773,14 +7773,14 @@ simulated processor cycle finishes.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN (void)
-@c hook-start:TARGET_SCHED_init_dfa_post_cycle_insn
+@c hook-start:TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN
 The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but
 used to initialize data used by the previous hook.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE (void)
-@c hook-start:TARGET_SCHED_dfa_pre_advance_cycle
+@c hook-start:TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE
 The hook to notify target that the current simulated cycle is about to finish.
 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
 to change the state in more complicated situations - e.g., when advancing
@@ -7789,7 +7789,7 @@ state on a single insn is not enough.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_DFA_POST_ADVANCE_CYCLE (void)
-@c hook-start:TARGET_SCHED_dfa_post_advance_cycle
+@c hook-start:TARGET_SCHED_DFA_POST_ADVANCE_CYCLE
 The hook to notify target that new simulated cycle has just started.
 The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used
 to change the state in more complicated situations - e.g., when advancing
@@ -7798,7 +7798,7 @@ state on a single insn is not enough.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD (void)
-@c hook-start:TARGET_SCHED_first_cycle_multipass_dfa_lookahead
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
 This hook controls better choosing an insn from the ready insn queue
 for the @acronym{DFA}-based insn scheduler.  Usually the scheduler
 chooses the first insn from the queue.  If the hook returns a positive
@@ -7829,7 +7829,7 @@ The default is no multipass scheduling.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD (rtx_insn *@var{insn}, int @var{ready_index})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_dfa_lookahead_guard
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
 
 This hook controls what insns from the ready insn queue will be
 considered for the multipass insn scheduling.  If the hook returns
@@ -7847,46 +7847,46 @@ The default is that any ready insns can be chosen to be issued.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN (void *@var{data}, signed char *@var{ready_try}, int @var{n_ready}, bool @var{first_cycle_insn_p})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_begin
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN
 This hook prepares the target backend for a new round of multipass
 scheduling.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE (void *@var{data}, signed char *@var{ready_try}, int @var{n_ready}, rtx_insn *@var{insn}, const void *@var{prev_data})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_issue
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE
 This hook is called when multipass scheduling evaluates instruction INSN.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK (const void *@var{data}, signed char *@var{ready_try}, int @var{n_ready})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_backtrack
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK
 This is called when multipass scheduling backtracks from evaluation of
 an instruction.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END (const void *@var{data})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_end
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END
 This hook notifies the target about the result of the concluded current
 round of multipass scheduling.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT (void *@var{data})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_init
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT
 This hook initializes target-specific data used in multipass scheduling.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI (void *@var{data})
-@c hook-start:TARGET_SCHED_first_cycle_multipass_fini
+@c hook-start:TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI
 This hook finalizes target-specific data used in multipass scheduling.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_DFA_NEW_CYCLE (FILE *@var{dump}, int @var{verbose}, rtx_insn *@var{insn}, int @var{last_clock}, int @var{clock}, int *@var{sort_p})
-@c hook-start:TARGET_SCHED_dfa_new_cycle
+@c hook-start:TARGET_SCHED_DFA_NEW_CYCLE
 This hook is called by the insn scheduler before issuing @var{insn}
 on cycle @var{clock}.  If the hook returns nonzero,
 @var{insn} is not issued on this processor cycle.  Instead,
@@ -7901,7 +7901,7 @@ and the current processor cycle.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_IS_COSTLY_DEPENDENCE (struct _dep *@var{_dep}, int @var{cost}, int @var{distance})
-@c hook-start:TARGET_SCHED_is_costly_dependence
+@c hook-start:TARGET_SCHED_IS_COSTLY_DEPENDENCE
 This hook is used to define which dependences are considered costly by
 the target, so costly that it is not advisable to schedule the insns that
 are involved in the dependence too close to one another.  The parameters
@@ -7924,7 +7924,7 @@ not in cases of ``costly dependences'', which this hooks allows to define.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_H_I_D_EXTENDED (void)
-@c hook-start:TARGET_SCHED_h_i_d_extended
+@c hook-start:TARGET_SCHED_H_I_D_EXTENDED
 This hook is called by the insn scheduler after emitting a new instruction to
 the instruction stream.  The hook notifies a target backend to extend its
 per instruction data structures.
@@ -7932,13 +7932,13 @@ per instruction data structures.
 @c hook-end
 
 @deftypefn {Target Hook} {void *} TARGET_SCHED_ALLOC_SCHED_CONTEXT (void)
-@c hook-start:TARGET_SCHED_alloc_sched_context
+@c hook-start:TARGET_SCHED_ALLOC_SCHED_CONTEXT
 Return a pointer to a store large enough to hold target scheduling context.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_INIT_SCHED_CONTEXT (void *@var{tc}, bool @var{clean_p})
-@c hook-start:TARGET_SCHED_init_sched_context
+@c hook-start:TARGET_SCHED_INIT_SCHED_CONTEXT
 Initialize store pointed to by @var{tc} to hold target scheduling context.
 It @var{clean_p} is true then initialize @var{tc} as if scheduler is at the
 beginning of the block.  Otherwise, copy the current context into @var{tc}.
@@ -7946,25 +7946,25 @@ beginning of the block.  Otherwise, copy the current context into @var{tc}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_SET_SCHED_CONTEXT (void *@var{tc})
-@c hook-start:TARGET_SCHED_set_sched_context
+@c hook-start:TARGET_SCHED_SET_SCHED_CONTEXT
 Copy target scheduling context pointed to by @var{tc} to the current context.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_CLEAR_SCHED_CONTEXT (void *@var{tc})
-@c hook-start:TARGET_SCHED_clear_sched_context
+@c hook-start:TARGET_SCHED_CLEAR_SCHED_CONTEXT
 Deallocate internal data in target scheduling context pointed to by @var{tc}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FREE_SCHED_CONTEXT (void *@var{tc})
-@c hook-start:TARGET_SCHED_free_sched_context
+@c hook-start:TARGET_SCHED_FREE_SCHED_CONTEXT
 Deallocate a store for target scheduling context pointed to by @var{tc}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_SPECULATE_INSN (rtx_insn *@var{insn}, unsigned int @var{dep_status}, rtx *@var{new_pat})
-@c hook-start:TARGET_SCHED_speculate_insn
+@c hook-start:TARGET_SCHED_SPECULATE_INSN
 This hook is called by the insn scheduler when @var{insn} has only
 speculative dependencies and therefore can be scheduled speculatively.
 The hook is used to check if the pattern of @var{insn} has a speculative
@@ -7977,7 +7977,7 @@ the generated speculative pattern.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_NEEDS_BLOCK_P (unsigned int @var{dep_status})
-@c hook-start:TARGET_SCHED_needs_block_p
+@c hook-start:TARGET_SCHED_NEEDS_BLOCK_P
 This hook is called by the insn scheduler during generation of recovery code
 for @var{insn}.  It should return @code{true}, if the corresponding check
 instruction should branch to recovery code, or @code{false} otherwise.
@@ -7985,7 +7985,7 @@ instruction should branch to recovery code, or @code{false} otherwise.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_SCHED_GEN_SPEC_CHECK (rtx_insn *@var{insn}, rtx_insn *@var{label}, unsigned int @var{ds})
-@c hook-start:TARGET_SCHED_gen_spec_check
+@c hook-start:TARGET_SCHED_GEN_SPEC_CHECK
 This hook is called by the insn scheduler to generate a pattern for recovery
 check instruction.  If @var{mutate_p} is zero, then @var{insn} is a
 speculative instruction for which the check should be generated.
@@ -7998,7 +7998,7 @@ a pattern for a branchy check corresponding to a simple check denoted by
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_SET_SCHED_FLAGS (struct spec_info_def *@var{spec_info})
-@c hook-start:TARGET_SCHED_set_sched_flags
+@c hook-start:TARGET_SCHED_SET_SCHED_FLAGS
 This hook is used by the insn scheduler to find out what features should be
 enabled/used.
 The structure *@var{spec_info} should be filled in by the target.
@@ -8007,7 +8007,7 @@ The structure describes speculation types that can be used in the scheduler.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_CAN_SPECULATE_INSN (rtx_insn *@var{insn})
-@c hook-start:TARGET_SCHED_can_speculate_insn
+@c hook-start:TARGET_SCHED_CAN_SPECULATE_INSN
 Some instructions should never be speculated by the schedulers, usually
  because the instruction is too expensive to get this wrong.  Often such
  instructions have long latency, and often they are not fully modeled in the
@@ -8017,7 +8017,7 @@ Some instructions should never be speculated by the schedulers, usually
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_SMS_RES_MII (struct ddg *@var{g})
-@c hook-start:TARGET_SCHED_sms_res_mii
+@c hook-start:TARGET_SCHED_SMS_RES_MII
 This hook is called by the swing modulo scheduler to calculate a
 resource-based lower bound which is based on the resources available in
 the machine and the resources required by each instruction.  The target
@@ -8028,21 +8028,21 @@ of instructions divided by the issue rate.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SCHED_DISPATCH (rtx_insn *@var{insn}, int @var{x})
-@c hook-start:TARGET_SCHED_dispatch
+@c hook-start:TARGET_SCHED_DISPATCH
 This hook is called by Haifa Scheduler.  It returns true if dispatch scheduling
 is supported in hardware and the condition specified in the parameter is true.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_DISPATCH_DO (rtx_insn *@var{insn}, int @var{x})
-@c hook-start:TARGET_SCHED_dispatch_do
+@c hook-start:TARGET_SCHED_DISPATCH_DO
 This hook is called by Haifa Scheduler.  It performs the operation specified
 in its second parameter.
 @end deftypefn
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_SCHED_EXPOSED_PIPELINE
-@c hook-start:TARGET_SCHED_exposed_pipeline
+@c hook-start:TARGET_SCHED_EXPOSED_PIPELINE
 True if the processor has an exposed pipeline, which means that not just
 the order of instructions is important for correctness when scheduling, but
 also the latencies of operations.
@@ -8050,14 +8050,14 @@ also the latencies of operations.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_SCHED_REASSOCIATION_WIDTH (unsigned int @var{opc}, machine_mode @var{mode})
-@c hook-start:TARGET_SCHED_reassociation_width
+@c hook-start:TARGET_SCHED_REASSOCIATION_WIDTH
 This hook is called by tree reassociator to determine a level of
 parallelism required in output calculations chain.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SCHED_FUSION_PRIORITY (rtx_insn *@var{insn}, int @var{max_pri}, int *@var{fusion_pri}, int *@var{pri})
-@c hook-start:TARGET_SCHED_fusion_priority
+@c hook-start:TARGET_SCHED_FUSION_PRIORITY
 This hook is called by scheduling fusion pass.  It calculates fusion
 priorities for each instruction passed in by parameter.  The priorities
 are returned via pointer parameters.
@@ -8135,7 +8135,7 @@ the hook implementation for how different fusion types are supported.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_EXPAND_DIVMOD_LIBFUNC (rtx @var{libfunc}, machine_mode @var{mode}, rtx @var{op0}, rtx @var{op1}, rtx *@var{quot}, rtx *@var{rem})
-@c hook-start:TARGET_expand_divmod_libfunc
+@c hook-start:TARGET_EXPAND_DIVMOD_LIBFUNC
 Define this hook for enabling divmod transform if the port does not have
 hardware divmod insn but defines target-specific divmod libfuncs.
 @end deftypefn
@@ -8323,7 +8323,7 @@ This macro is irrelevant if there is no separate readonly data section.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_INIT_SECTIONS (void)
-@c hook-start:TARGET_ASM_init_sections
+@c hook-start:TARGET_ASM_INIT_SECTIONS
 Define this hook if you need to do something special to set up the
 @file{varasm.c} sections, or if your target has some special sections
 of its own that you need to create.
@@ -8335,7 +8335,7 @@ described below.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_ASM_RELOC_RW_MASK (void)
-@c hook-start:TARGET_ASM_reloc_rw_mask
+@c hook-start:TARGET_ASM_RELOC_RW_MASK
 Return a mask describing how relocations should be treated when
 selecting sections.  Bit 1 should be set if global relocations
 should be placed in a read-write section; bit 0 should be set if
@@ -8349,7 +8349,7 @@ in read-only sections even in executables.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC (void)
-@c hook-start:TARGET_ASM_generate_pic_addr_diff_vec
+@c hook-start:TARGET_ASM_GENERATE_PIC_ADDR_DIFF_VEC
 Return true to generate ADDR_DIF_VEC table
 or false to generate ADDR_VEC table for jumps in case of -fPIC.
 
@@ -8359,7 +8359,7 @@ equals true and false otherwise
 @c hook-end
 
 @deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_SECTION (tree @var{exp}, int @var{reloc}, unsigned HOST_WIDE_INT @var{align})
-@c hook-start:TARGET_ASM_select_section
+@c hook-start:TARGET_ASM_SELECT_SECTION
 Return the section into which @var{exp} should be placed.  You can
 assume that @var{exp} is either a @code{VAR_DECL} node or a constant of
 some sort.  @var{reloc} indicates whether the initial value of @var{exp}
@@ -8384,7 +8384,7 @@ it is unlikely to be called.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_UNIQUE_SECTION (tree @var{decl}, int @var{reloc})
-@c hook-start:TARGET_ASM_unique_section
+@c hook-start:TARGET_ASM_UNIQUE_SECTION
 Build up a unique section name, expressed as a @code{STRING_CST} node,
 and assign it to @samp{DECL_SECTION_NAME (@var{decl})}.
 As with @code{TARGET_ASM_SELECT_SECTION}, @var{reloc} indicates whether
@@ -8398,7 +8398,7 @@ Whatever the actual target object format, this is often good enough.
 @c hook-end
 
 @deftypefn {Target Hook} {section *} TARGET_ASM_FUNCTION_RODATA_SECTION (tree @var{decl}, bool @var{relocatable})
-@c hook-start:TARGET_ASM_function_rodata_section
+@c hook-start:TARGET_ASM_FUNCTION_RODATA_SECTION
 Return the readonly data or reloc readonly data section associated with
 @samp{DECL_SECTION_NAME (@var{decl})}. @var{relocatable} selects the latter
 over the former.
@@ -8410,7 +8410,7 @@ the normal readonly-data or reloc readonly data section otherwise.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_ASM_MERGEABLE_RODATA_PREFIX
-@c hook-start:TARGET_ASM_mergeable_rodata_prefix
+@c hook-start:TARGET_ASM_MERGEABLE_RODATA_PREFIX
 Usually, the compiler uses the prefix @code{".rodata"} to construct
 section names for mergeable constant data.  Define this macro to override
 the string if a different section name should be used.
@@ -8418,14 +8418,14 @@ the string if a different section name should be used.
 @c hook-end
 
 @deftypefn {Target Hook} {section *} TARGET_ASM_TM_CLONE_TABLE_SECTION (void)
-@c hook-start:TARGET_ASM_tm_clone_table_section
+@c hook-start:TARGET_ASM_TM_CLONE_TABLE_SECTION
 Return the section that should be used for transactional memory clone
 tables.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_RTX_SECTION (machine_mode @var{mode}, rtx @var{x}, unsigned HOST_WIDE_INT @var{align})
-@c hook-start:TARGET_ASM_select_rtx_section
+@c hook-start:TARGET_ASM_SELECT_RTX_SECTION
 Return the section into which a constant @var{x}, of mode @var{mode},
 should be placed.  You can assume that @var{x} is some kind of
 constant in RTL@.  The argument @var{mode} is redundant except in the
@@ -8439,7 +8439,7 @@ else in @code{readonly_data_section}.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_MANGLE_DECL_ASSEMBLER_NAME (tree @var{decl}, tree @var{id})
-@c hook-start:TARGET_mangle_decl_assembler_name
+@c hook-start:TARGET_MANGLE_DECL_ASSEMBLER_NAME
 Define this hook if you need to postprocess the assembler name generated
 by target-independent code.  The @var{id} provided to this hook will be
 the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C,
@@ -8451,7 +8451,7 @@ returns the @var{id} provided.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ENCODE_SECTION_INFO (tree @var{decl}, rtx @var{rtl}, int @var{new_decl_p})
-@c hook-start:TARGET_encode_section_info
+@c hook-start:TARGET_ENCODE_SECTION_INFO
 Define this hook if references to a symbol or a constant must be
 treated differently depending on something about the variable or
 function named by the symbol (such as what section it is in).
@@ -8491,7 +8491,7 @@ before overriding it.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_STRIP_NAME_ENCODING (const char *@var{name})
-@c hook-start:TARGET_strip_name_encoding
+@c hook-start:TARGET_STRIP_NAME_ENCODING
 Decode @var{name} and return the real name part, sans
 the characters that @code{TARGET_ENCODE_SECTION_INFO}
 may have added.
@@ -8499,21 +8499,21 @@ may have added.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_IN_SMALL_DATA_P (const_tree @var{exp})
-@c hook-start:TARGET_in_small_data_p
+@c hook-start:TARGET_IN_SMALL_DATA_P
 Returns true if @var{exp} should be placed into a ``small data'' section.
 The default version of this hook always returns false.
 @end deftypefn
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_HAVE_SRODATA_SECTION
-@c hook-start:TARGET_have_srodata_section
+@c hook-start:TARGET_HAVE_SRODATA_SECTION
 Contains the value true if the target places read-only
 ``small data'' into a separate section.  The default value is false.
 @end deftypevr
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PROFILE_BEFORE_PROLOGUE (void)
-@c hook-start:TARGET_profile_before_prologue
+@c hook-start:TARGET_PROFILE_BEFORE_PROLOGUE
 It returns true if target wants profile code emitted before prologue.
 
 The default version of this hook use the target macro
@@ -8522,7 +8522,7 @@ The default version of this hook use the target macro
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_BINDS_LOCAL_P (const_tree @var{exp})
-@c hook-start:TARGET_binds_local_p
+@c hook-start:TARGET_BINDS_LOCAL_P
 Returns true if @var{exp} names an object for which name resolution
 rules must resolve to the current ``module'' (dynamic shared library
 or executable image).
@@ -8534,7 +8534,7 @@ currently supported object file formats.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_HAVE_TLS
-@c hook-start:TARGET_have_tls
+@c hook-start:TARGET_HAVE_TLS
 Contains the value true if the target supports thread-local storage.
 The default value is false.
 @end deftypevr
@@ -8619,7 +8619,7 @@ This describes the overall framework of an assembly file.
 
 @findex default_file_start
 @deftypefn {Target Hook} void TARGET_ASM_FILE_START (void)
-@c hook-start:TARGET_ASM_file_start
+@c hook-start:TARGET_ASM_FILE_START
 Output to @code{asm_out_file} any text which the assembler expects to
 find at the beginning of a file.  The default behavior is controlled
 by two flags, documented below.  Unless your target's assembler is
@@ -8630,7 +8630,7 @@ lets other target files rely on these variables.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_ASM_FILE_START_APP_OFF
-@c hook-start:TARGET_asm_file_start_app_off
+@c hook-start:TARGET_ASM_FILE_START_APP_OFF
 If this flag is true, the text of the macro @code{ASM_APP_OFF} will be
 printed as the very first line in the assembly file, unless
 @option{-fverbose-asm} is in effect.  (If that macro has been defined
@@ -8646,7 +8646,7 @@ comments that will cause GAS to issue errors in NO_APP mode.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_ASM_FILE_START_FILE_DIRECTIVE
-@c hook-start:TARGET_asm_file_start_file_directive
+@c hook-start:TARGET_ASM_FILE_START_FILE_DIRECTIVE
 If this flag is true, @code{output_file_directive} will be called
 for the primary source file, immediately after printing
 @code{ASM_APP_OFF} (if that is enabled).  Most ELF assemblers expect
@@ -8655,7 +8655,7 @@ this to be done.  The default is false.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FILE_END (void)
-@c hook-start:TARGET_ASM_file_end
+@c hook-start:TARGET_ASM_FILE_END
 Output to @code{asm_out_file} any text which the assembler expects
 to find at the end of a file.  The default is to output nothing.
 @end deftypefn
@@ -8671,7 +8671,7 @@ this function.
 @end deftypefun
 
 @deftypefn {Target Hook} void TARGET_ASM_LTO_START (void)
-@c hook-start:TARGET_ASM_lto_start
+@c hook-start:TARGET_ASM_LTO_START
 Output to @code{asm_out_file} any text which the assembler expects
 to find at the start of an LTO section.  The default is to output
 nothing.
@@ -8679,7 +8679,7 @@ nothing.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_LTO_END (void)
-@c hook-start:TARGET_ASM_lto_end
+@c hook-start:TARGET_ASM_LTO_END
 Output to @code{asm_out_file} any text which the assembler expects
 to find at the end of an LTO section.  The default is to output
 nothing.
@@ -8687,7 +8687,7 @@ nothing.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_CODE_END (void)
-@c hook-start:TARGET_ASM_code_end
+@c hook-start:TARGET_ASM_CODE_END
 Output to @code{asm_out_file} any text which is needed before emitting
 unwind info and debug info at the end of a file.  Some targets emit
 here PIC setup thunks that cannot be emitted at the end of file,
@@ -8727,7 +8727,7 @@ 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})
-@c hook-start:TARGET_ASM_output_source_filename
+@c hook-start:TARGET_ASM_OUTPUT_SOURCE_FILENAME
 Output DWARF debugging information which indicates that filename
 @var{name} is the current source file to the stdio stream @var{file}.
 
@@ -8737,7 +8737,7 @@ for the file format in use is appropriate.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_IDENT (const char *@var{name})
-@c hook-start:TARGET_ASM_output_ident
+@c hook-start:TARGET_ASM_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}
@@ -8754,7 +8754,7 @@ of the filename using this macro.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_NAMED_SECTION (const char *@var{name}, unsigned int @var{flags}, tree @var{decl})
-@c hook-start:TARGET_ASM_named_section
+@c hook-start:TARGET_ASM_NAMED_SECTION
 Output assembly directives to switch to section @var{name}.  The section
 should have attributes as specified by @var{flags}, which is a bit mask
 of the @code{SECTION_*} flags defined in @file{output.h}.  If @var{decl}
@@ -8764,7 +8764,7 @@ this section is associated.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_ELF_FLAGS_NUMERIC (unsigned int @var{flags}, unsigned int *@var{num})
-@c hook-start:TARGET_ASM_elf_flags_numeric
+@c hook-start:TARGET_ASM_ELF_FLAGS_NUMERIC
 This hook can be used to encode ELF section flags for which no letter
 code has been defined in the assembler.  It is called by
 @code{default_asm_named_section} whenever the section flags need to be
@@ -8778,7 +8778,7 @@ is emitted.
 @c hook-end
 
 @deftypefn {Target Hook} {section *} TARGET_ASM_FUNCTION_SECTION (tree @var{decl}, enum node_frequency @var{freq}, bool @var{startup}, bool @var{exit})
-@c hook-start:TARGET_ASM_function_section
+@c hook-start:TARGET_ASM_FUNCTION_SECTION
 Return preferred text (sub)section for function @var{decl}.
 Main purpose of this function is to separate cold, normal and hot
 functions. @var{startup} is true when function is known to be used only
@@ -8790,7 +8790,7 @@ Return NULL if function should go to default text section.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS (FILE *@var{file}, tree @var{decl}, bool @var{new_is_cold})
-@c hook-start:TARGET_ASM_function_switched_text_sections
+@c hook-start:TARGET_ASM_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
@@ -8800,7 +8800,7 @@ decl is available as @var{decl} and the new section is `cold' if
 @c hook-end
 
 @deftypevr {Common Target Hook} bool TARGET_HAVE_NAMED_SECTIONS
-@c hook-start:TARGET_have_named_sections
+@c hook-start:TARGET_HAVE_NAMED_SECTIONS
 @c hook-end
 This flag is true if the target supports @code{TARGET_ASM_NAMED_SECTION}.
 It must not be modified by command-line option processing.
@@ -8808,7 +8808,7 @@ It must not be modified by command-line option processing.
 
 @anchor{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS}
 @deftypevr {Target Hook} bool TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
-@c hook-start:TARGET_have_switchable_bss_sections
+@c hook-start:TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
 This flag is true if we can create zeroed data by switching to a BSS
 section and then using @code{ASM_OUTPUT_SKIP} to allocate the space.
 This is true on most ELF targets.
@@ -8816,7 +8816,7 @@ This is true on most ELF targets.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_SECTION_TYPE_FLAGS (tree @var{decl}, const char *@var{name}, int @var{reloc})
-@c hook-start:TARGET_section_type_flags
+@c hook-start:TARGET_SECTION_TYPE_FLAGS
 Choose a set of section attributes for use by @code{TARGET_ASM_NAMED_SECTION}
 based on a variable or function decl, a section name, and whether or not the
 declaration's initializer may contain runtime relocations.  @var{decl} may be
@@ -8830,7 +8830,7 @@ set via @code{__attribute__}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_RECORD_GCC_SWITCHES (const char *@var{})
-@c hook-start:TARGET_ASM_record_gcc_switches
+@c hook-start:TARGET_ASM_RECORD_GCC_SWITCHES
 Provides the target with the ability to record the gcc command line
 switches provided as argument.
 
@@ -8844,7 +8844,7 @@ hook.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
-@c hook-start:TARGET_ASM_record_gcc_switches_section
+@c hook-start:TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
 This is the name of the section that will be created by the example
 ELF implementation of the @code{TARGET_ASM_RECORD_GCC_SWITCHES} target
 hook.
@@ -8857,7 +8857,7 @@ hook.
 
 
 @deftypevr {Target Hook} {const char *} TARGET_ASM_BYTE_OP
-@c hook-start:TARGET_ASM_byte_op
+@c hook-start:TARGET_ASM_BYTE_OP
 These hooks specify assembly directives for creating certain kinds
 of integer object.  The @code{TARGET_ASM_BYTE_OP} directive creates a
 byte-sized object, the @code{TARGET_ASM_ALIGNED_HI_OP} one creates an
@@ -8871,7 +8871,7 @@ the string should contain a tab, a pseudo-op, and then another tab.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_INTEGER (rtx @var{x}, unsigned int @var{size}, int @var{aligned_p})
-@c hook-start:TARGET_ASM_integer
+@c hook-start:TARGET_ASM_INTEGER
 The @code{assemble_integer} function uses this hook to output an
 integer object.  @var{x} is the object's value, @var{size} is its size
 in bytes and @var{aligned_p} indicates whether it is aligned.  The
@@ -8886,14 +8886,14 @@ when the relevant string is @code{NULL}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_DECL_END (void)
-@c hook-start:TARGET_ASM_decl_end
+@c hook-start:TARGET_ASM_DECL_END
 Define this hook if the target assembler requires a special marker to
 terminate an initialized variable declaration.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA (FILE *@var{file}, rtx @var{x})
-@c hook-start:TARGET_ASM_output_addr_const_extra
+@c hook-start:TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
 A target hook to recognize @var{rtx} patterns that @code{output_addr_const}
 can't deal with, and output assembly code to @var{file} corresponding to
 the pattern @var{x}.  This may be used to allow machine-dependent
@@ -8995,7 +8995,7 @@ the character @samp{;} is treated as a logical line separator.
 
 @deftypevr {Target Hook} {const char *} TARGET_ASM_OPEN_PAREN
 @deftypevrx {Target Hook} {const char *} TARGET_ASM_CLOSE_PAREN
-@c hook-start:TARGET_ASM_open_paren
+@c hook-start:TARGET_ASM_OPEN_PAREN
 These target hooks are C string constants, describing the syntax in the
 assembler for grouping arithmetic expressions.  If not overridden, they
 default to normal parentheses, which is correct for most assemblers.
@@ -9318,7 +9318,7 @@ You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} and/or
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_DECLARE_CONSTANT_NAME (FILE *@var{file}, const char *@var{name}, const_tree @var{expr}, HOST_WIDE_INT @var{size})
-@c hook-start:TARGET_ASM_declare_constant_name
+@c hook-start:TARGET_ASM_DECLARE_CONSTANT_NAME
 A target hook to output to the stdio stream @var{file} any text necessary
 for declaring the name @var{name} of a constant which is being defined.  This
 target hook is responsible for outputting the label definition (perhaps using
@@ -9357,7 +9357,7 @@ You may wish to use @code{ASM_OUTPUT_SIZE_DIRECTIVE} and/or
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_GLOBALIZE_LABEL (FILE *@var{stream}, const char *@var{name})
-@c hook-start:TARGET_ASM_globalize_label
+@c hook-start:TARGET_ASM_GLOBALIZE_LABEL
 This target hook is a function to output to the stdio stream
 @var{stream} some commands that will make the label @var{name} global;
 that is, available for reference from other files.
@@ -9368,7 +9368,7 @@ The default implementation relies on a proper definition of
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_GLOBALIZE_DECL_NAME (FILE *@var{stream}, tree @var{decl})
-@c hook-start:TARGET_ASM_globalize_decl_name
+@c hook-start:TARGET_ASM_GLOBALIZE_DECL_NAME
 This target hook is a function to output to the stdio stream
 @var{stream} some commands that will make the name associated with @var{decl}
 global; that is, available for reference from other files.
@@ -9378,7 +9378,7 @@ The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_ASSEMBLE_UNDEFINED_DECL (FILE *@var{stream}, const char *@var{name}, const_tree @var{decl})
-@c hook-start:TARGET_ASM_assemble_undefined_decl
+@c hook-start:TARGET_ASM_ASSEMBLE_UNDEFINED_DECL
 This target hook is a function to output to the stdio stream
 @var{stream} some commands that will declare the name associated with
 @var{decl} which is not defined in the current translation unit.  Most
@@ -9456,7 +9456,7 @@ be emitted as one-only.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_ASSEMBLE_VISIBILITY (tree @var{decl}, int @var{visibility})
-@c hook-start:TARGET_ASM_assemble_visibility
+@c hook-start:TARGET_ASM_ASSEMBLE_VISIBILITY
 This target hook is a function to output to @var{asm_out_file} some
 commands that will make the symbol(s) associated with @var{decl} have
 hidden, protected or internal visibility as specified by @var{visibility}.
@@ -9494,7 +9494,7 @@ The GNU assembler and most Unix assemblers don't require anything.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_EXTERNAL_LIBCALL (rtx @var{symref})
-@c hook-start:TARGET_ASM_external_libcall
+@c hook-start:TARGET_ASM_EXTERNAL_LIBCALL
 This target hook is a function to output to @var{asm_out_file} an assembler
 pseudo-op to declare a library function name external.  The name of the
 library function is given by @var{symref}, which is a @code{symbol_ref}.
@@ -9502,7 +9502,7 @@ library function is given by @var{symref}, which is a @code{symbol_ref}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_MARK_DECL_PRESERVED (const char *@var{symbol})
-@c hook-start:TARGET_ASM_mark_decl_preserved
+@c hook-start:TARGET_ASM_MARK_DECL_PRESERVED
 This target hook is a function to output to @var{asm_out_file} an assembler
 directive to annotate @var{symbol} as used.  The Darwin target uses the
 .no_dead_code_strip directive.
@@ -9518,7 +9518,7 @@ systems.  This macro is used in @code{assemble_name}.
 @end defmac
 
 @deftypefn {Target Hook} tree TARGET_MANGLE_ASSEMBLER_NAME (const char *@var{name})
-@c hook-start:TARGET_mangle_assembler_name
+@c hook-start:TARGET_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
@@ -9546,7 +9546,7 @@ being taken.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_INTERNAL_LABEL (FILE *@var{stream}, const char *@var{prefix}, unsigned long @var{labelno})
-@c hook-start:TARGET_ASM_internal_label
+@c hook-start:TARGET_ASM_INTERNAL_LABEL
 A function to output to the stdio stream @var{stream} a label whose
 name is made from the string @var{prefix} and the number @var{labelno}.
 
@@ -9873,7 +9873,7 @@ encountering an @code{init_priority} attribute.
 @end defmac
 
 @deftypevr {Target Hook} bool TARGET_HAVE_CTORS_DTORS
-@c hook-start:TARGET_have_ctors_dtors
+@c hook-start:TARGET_HAVE_CTORS_DTORS
 This value is true if the target supports some ``native'' method of
 collecting constructors and destructors to be run at startup and exit.
 It is false if we must use @command{collect2}.
@@ -9881,7 +9881,7 @@ It is false if we must use @command{collect2}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_CONSTRUCTOR (rtx @var{symbol}, int @var{priority})
-@c hook-start:TARGET_ASM_constructor
+@c hook-start:TARGET_ASM_CONSTRUCTOR
 If defined, a function that outputs assembler code to arrange to call
 the function referenced by @var{symbol} at initialization time.
 
@@ -9898,7 +9898,7 @@ is not defined.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_DESTRUCTOR (rtx @var{symbol}, int @var{priority})
-@c hook-start:TARGET_ASM_destructor
+@c hook-start:TARGET_ASM_DESTRUCTOR
 This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination
 functions rather than initialization functions.
 @end deftypefn
@@ -10049,7 +10049,7 @@ If this macro is not defined, it is equivalent to a null statement.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_FINAL_POSTSCAN_INSN (FILE *@var{file}, rtx_insn *@var{insn}, rtx *@var{opvec}, int @var{noperands})
-@c hook-start:TARGET_ASM_final_postscan_insn
+@c hook-start:TARGET_ASM_FINAL_POSTSCAN_INSN
 If defined, this target hook is a function which is executed just after the
 output of assembler code for @var{insn}, to change the mode of the assembler
 if necessary.
@@ -10271,7 +10271,7 @@ the jump-table.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_POST_CFI_STARTPROC (FILE *@var{}, @var{tree})
-@c hook-start:TARGET_ASM_post_cfi_startproc
+@c hook-start:TARGET_ASM_POST_CFI_STARTPROC
 This target hook is used to emit assembly strings required by the target
 after the .cfi_startproc directive.  The first argument is the file stream to
 write the strings to and the second argument is the function's declaration.  The
@@ -10282,7 +10282,7 @@ The default is to not output any assembly strings.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_EMIT_UNWIND_LABEL (FILE *@var{stream}, tree @var{decl}, int @var{for_eh}, int @var{empty})
-@c hook-start:TARGET_ASM_emit_unwind_label
+@c hook-start:TARGET_ASM_EMIT_UNWIND_LABEL
 This target hook emits a label at the beginning of each FDE@.  It
 should be defined on targets where FDEs need special labels, and it
 should write the appropriate label, for the FDE associated with the
@@ -10296,7 +10296,7 @@ The default is that FDEs are not given nonlocal labels.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL (FILE *@var{stream})
-@c hook-start:TARGET_ASM_emit_except_table_label
+@c hook-start:TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL
 This target hook emits a label at the beginning of the exception table.
 It should be defined on targets where it is desirable for the table
 to be broken up according to function.
@@ -10306,7 +10306,7 @@ The default is that no label is emitted.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_EMIT_EXCEPT_PERSONALITY (rtx @var{personality})
-@c hook-start:TARGET_ASM_emit_except_personality
+@c hook-start:TARGET_ASM_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.
@@ -10314,7 +10314,7 @@ info.  This hook should not be used if dwarf2 unwind info is used.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ASM_UNWIND_EMIT (FILE *@var{stream}, rtx_insn *@var{insn})
-@c hook-start:TARGET_ASM_unwind_emit
+@c hook-start:TARGET_ASM_UNWIND_EMIT
 This target hook emits assembly directives required to unwind the
 given instruction.  This is only used when @code{TARGET_EXCEPT_UNWIND_INFO}
 returns @code{UI_TARGET}.
@@ -10322,7 +10322,7 @@ returns @code{UI_TARGET}.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_ASM_MAKE_EH_SYMBOL_INDIRECT (rtx @var{origsymbol}, bool @var{pubvis})
-@c hook-start:TARGET_ASM_make_eh_symbol_indirect
+@c hook-start:TARGET_ASM_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.
@@ -10330,7 +10330,7 @@ the symbol is visible outside the TU.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_ASM_UNWIND_EMIT_BEFORE_INSN
-@c hook-start:TARGET_ASM_unwind_emit_before_insn
+@c hook-start: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.
@@ -10338,7 +10338,7 @@ be called afterward.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_SHOULD_RESTORE_CFA_STATE (void)
-@c hook-start:TARGET_ASM_should_restore_cfa_state
+@c hook-start:TARGET_ASM_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
@@ -10399,7 +10399,7 @@ GCC will provide a default definition of 1.
 @end defmac
 
 @deftypefn {Common Target Hook} {enum unwind_info_type} TARGET_EXCEPT_UNWIND_INFO (struct gcc_options *@var{opts})
-@c hook-start:TARGET_except_unwind_info
+@c hook-start:TARGET_EXCEPT_UNWIND_INFO
 @c hook-end
 This hook defines the mechanism that will be used for exception handling
 by the target.  If the target has ABI specified unwind tables, the hook
@@ -10427,7 +10427,7 @@ must define this hook so that @var{opts} is used correctly.
 @end deftypefn
 
 @deftypevr {Common Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
-@c hook-start:TARGET_unwind_tables_default
+@c hook-start:TARGET_UNWIND_TABLES_DEFAULT
 @c hook-end
 This variable should be set to @code{true} if the target ABI requires unwinding
 tables even when exceptions are not used.  It must not be modified by
@@ -10458,7 +10458,7 @@ the target supports DWARF 2 frame unwind information.
 @end defmac
 
 @deftypevr {Target Hook} bool TARGET_TERMINATE_DW2_EH_FRAME_INFO
-@c hook-start:TARGET_terminate_dw2_eh_frame_info
+@c hook-start:TARGET_TERMINATE_DW2_EH_FRAME_INFO
 Contains the value true if the target should add a zero word onto the
 end of a Dwarf-2 frame info section when used for exception handling.
 Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and
@@ -10467,7 +10467,7 @@ true otherwise.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_DWARF_REGISTER_SPAN (rtx @var{reg})
-@c hook-start:TARGET_dwarf_register_span
+@c hook-start:TARGET_DWARF_REGISTER_SPAN
 Given a register, this hook should return a parallel of registers to
 represent where to find the register pieces.  Define this hook if the
 register and its mode are represented in Dwarf in non-contiguous
@@ -10478,7 +10478,7 @@ If not defined, the default is to return @code{NULL_RTX}.
 @c hook-end
 
 @deftypefn {Target Hook} machine_mode TARGET_DWARF_FRAME_REG_MODE (int @var{regno})
-@c hook-start:TARGET_dwarf_frame_reg_mode
+@c hook-start:TARGET_DWARF_FRAME_REG_MODE
 Given a register, this hook should return the mode which the
 corresponding Dwarf frame register should have.  This is normally
 used to return a smaller mode than the raw mode to prevent call
@@ -10487,7 +10487,7 @@ clobbered parts of a register altering the frame register size
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_INIT_DWARF_REG_SIZES_EXTRA (tree @var{address})
-@c hook-start:TARGET_init_dwarf_reg_sizes_extra
+@c hook-start:TARGET_INIT_DWARF_REG_SIZES_EXTRA
 If some registers are represented in Dwarf-2 unwind information in
 multiple pieces, define this hook to fill in information about the
 sizes of those pieces in the table used by the unwinder at runtime.
@@ -10498,7 +10498,7 @@ filling in a single size corresponding to each hard register;
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ASM_TTYPE (rtx @var{sym})
-@c hook-start:TARGET_ASM_ttype
+@c hook-start:TARGET_ASM_TTYPE
 This hook is used to output a reference from a frame unwinding table to
 the type_info object identified by @var{sym}.  It should return @code{true}
 if the reference was output.  Returning @code{false} will cause the
@@ -10507,7 +10507,7 @@ reference to be output using the normal Dwarf2 routines.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_ARM_EABI_UNWINDER
-@c hook-start:TARGET_arm_eabi_unwinder
+@c hook-start:TARGET_ARM_EABI_UNWINDER
 This flag should be set to @code{true} on targets that use an ARM EABI
 based unwinding library, and @code{false} on other targets.  This effects
 the format of unwinding tables, and how the unwinder in entered after
@@ -10904,7 +10904,7 @@ Define this macro if GCC should produce dwarf version 2 format
 debugging output in response to the @option{-g} option.
 
 @deftypefn {Target Hook} int TARGET_DWARF_CALLING_CONVENTION (const_tree @var{function})
-@c hook-start:TARGET_dwarf_calling_convention
+@c hook-start:TARGET_DWARF_CALLING_CONVENTION
 Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to
 be emitted for each function.  Instead of an integer return the enum
 value for the @code{DW_CC_} tag.
@@ -10927,7 +10927,7 @@ how you define @code{DWARF2_FRAME_INFO}.
 @end defmac
 
 @deftypefn {Target Hook} {enum unwind_info_type} TARGET_DEBUG_UNWIND_INFO (void)
-@c hook-start:TARGET_debug_unwind_info
+@c hook-start:TARGET_DEBUG_UNWIND_INFO
 This hook defines the mechanism that will be used for describing frame
 unwind information to the debugger.  Normally the hook will return
 @code{UI_DWARF2} if DWARF 2 debug information is enabled, and
@@ -10955,7 +10955,7 @@ internal line number tables.
 @end defmac
 
 @deftypefn {Target Hook} int TARGET_RESET_LOCATION_VIEW (rtx_insn *@var{})
-@c hook-start:TARGET_reset_location_view
+@c hook-start:TARGET_RESET_LOCATION_VIEW
 This hook, if defined, enables -ginternal-reset-location-views, and
 uses its result to override cases in which the estimated min insn
 length might be nonzero even when a PC advance (i.e., a view reset)
@@ -10973,7 +10973,7 @@ If insn length is to be regarded as reliable, set the hook to
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_WANT_DEBUG_PUB_SECTIONS
-@c hook-start:TARGET_want_debug_pub_sections
+@c hook-start: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.
@@ -10981,21 +10981,21 @@ in particular GDB does not use them.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_DELAY_SCHED2
-@c hook-start:TARGET_delay_sched2
+@c hook-start:TARGET_DELAY_SCHED2
 True if sched2 is not to be run at its normal place.
 This usually means it will be run as part of machine-specific reorg.
 @end deftypevr
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_DELAY_VARTRACK
-@c hook-start:TARGET_delay_vartrack
+@c hook-start:TARGET_DELAY_VARTRACK
 True if vartrack is not to be run at its normal place.
 This usually means it will be run as part of machine-specific reorg.
 @end deftypevr
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_NO_REGISTER_ALLOCATION
-@c hook-start:TARGET_no_register_allocation
+@c hook-start:TARGET_NO_REGISTER_ALLOCATION
 True if register allocation and the passes
 following it should not be run.  Usually true only for virtual assembler
 targets.
@@ -11038,7 +11038,7 @@ is referenced by a function.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_DWARF_DTPREL (FILE *@var{file}, int @var{size}, rtx @var{x})
-@c hook-start:TARGET_ASM_output_dwarf_dtprel
+@c hook-start:TARGET_ASM_OUTPUT_DWARF_DTPREL
 If defined, this target hook is a function which outputs a DTP-relative
 reference to the given TLS symbol of the specified size.
 @end deftypefn
@@ -11168,7 +11168,7 @@ 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})
-@c hook-start:TARGET_MODE_emit
+@c hook-start:TARGET_MODE_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
@@ -11178,7 +11178,7 @@ sets of a higher numbered entity to a mode of the same or lower priority.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_NEEDED (int @var{entity}, rtx_insn *@var{insn})
-@c hook-start:TARGET_MODE_needed
+@c hook-start:TARGET_MODE_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
@@ -11188,7 +11188,7 @@ must be switched into prior to the execution of @var{insn}.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_AFTER (int @var{entity}, int @var{mode}, rtx_insn *@var{insn})
-@c hook-start:TARGET_MODE_after
+@c hook-start:TARGET_MODE_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
@@ -11197,7 +11197,7 @@ in (if different from the incoming mode).
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_ENTRY (int @var{entity})
-@c hook-start:TARGET_MODE_entry
+@c hook-start:TARGET_MODE_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.
@@ -11207,7 +11207,7 @@ must be defined.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_EXIT (int @var{entity})
-@c hook-start:TARGET_MODE_exit
+@c hook-start:TARGET_MODE_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.
@@ -11217,7 +11217,7 @@ must be defined.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_PRIORITY (int @var{entity}, int @var{n})
-@c hook-start:TARGET_MODE_priority
+@c hook-start:TARGET_MODE_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.
@@ -11239,7 +11239,7 @@ These are described using the following target hooks; they also need to
 be documented in @file{extend.texi}.
 
 @deftypevr {Target Hook} {const struct attribute_spec *} TARGET_ATTRIBUTE_TABLE
-@c hook-start:TARGET_attribute_table
+@c hook-start:TARGET_ATTRIBUTE_TABLE
 If defined, this target hook points to an array of @samp{struct
 attribute_spec} (defined in @file{tree-core.h}) specifying the machine
 specific attributes for this target and some of the restrictions on the
@@ -11249,7 +11249,7 @@ take.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P (const_tree @var{name})
-@c hook-start:TARGET_attribute_takes_identifier_p
+@c hook-start:TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P
 If defined, this target hook is a function which returns true if the
 machine-specific attribute named @var{name} expects an identifier
 given as its first argument to be passed on as a plain identifier, not
@@ -11259,7 +11259,7 @@ false for all machine-specific attributes.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_COMP_TYPE_ATTRIBUTES (const_tree @var{type1}, const_tree @var{type2})
-@c hook-start:TARGET_comp_type_attributes
+@c hook-start:TARGET_COMP_TYPE_ATTRIBUTES
 If defined, this target hook is a function which returns zero if the attributes on
 @var{type1} and @var{type2} are incompatible, one if they are compatible,
 and two if they are nearly compatible (which causes a warning to be
@@ -11269,14 +11269,14 @@ supposed always to be compatible.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SET_DEFAULT_TYPE_ATTRIBUTES (tree @var{type})
-@c hook-start:TARGET_set_default_type_attributes
+@c hook-start:TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
 If defined, this target hook is a function which assigns default attributes to
 the newly defined @var{type}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_MERGE_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2})
-@c hook-start:TARGET_merge_type_attributes
+@c hook-start:TARGET_MERGE_TYPE_ATTRIBUTES
 Define this target hook if the merging of type attributes needs special
 handling.  If defined, the result is a list of the combined
 @code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}.  It is assumed
@@ -11287,7 +11287,7 @@ merging.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_MERGE_DECL_ATTRIBUTES (tree @var{olddecl}, tree @var{newdecl})
-@c hook-start:TARGET_merge_decl_attributes
+@c hook-start:TARGET_MERGE_DECL_ATTRIBUTES
 Define this target hook if the merging of decl attributes needs special
 handling.  If defined, the result is a list of the combined
 @code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}.
@@ -11311,7 +11311,7 @@ to perform initial processing of the @samp{dllimport} and
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P (const_tree @var{decl})
-@c hook-start:TARGET_valid_dllimport_attribute_p
+@c hook-start:TARGET_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}.
@@ -11328,7 +11328,7 @@ on this implementation detail.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_INSERT_ATTRIBUTES (tree @var{node}, tree *@var{attr_ptr})
-@c hook-start:TARGET_insert_attributes
+@c hook-start:TARGET_INSERT_ATTRIBUTES
 Define this target hook if you want to be able to add attributes to a decl
 when it is being created.  This is normally useful for back ends which
 wish to implement a pragma by using the attributes which correspond to
@@ -11343,7 +11343,7 @@ needed.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_HANDLE_GENERIC_ATTRIBUTE (tree *@var{node}, tree @var{name}, tree @var{args}, int @var{flags}, bool *@var{no_add_attrs})
-@c hook-start:TARGET_handle_generic_attribute
+@c hook-start:TARGET_HANDLE_GENERIC_ATTRIBUTE
 Define this target hook if you want to be able to perform additional
 target-specific processing of an attribute which is handled generically
 by a front end.  The arguments are the same as those which are passed to
@@ -11353,7 +11353,7 @@ attribute handlers.  So far this only affects the @var{noinit} and
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (const_tree @var{fndecl})
-@c hook-start:TARGET_function_attribute_inlinable_p
+@c hook-start:TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P
 @cindex inlining
 This target hook returns @code{true} if it is OK to inline @var{fndecl}
 into the current function, despite its having target-specific
@@ -11363,7 +11363,7 @@ target specific attribute attached to it, it will not be inlined.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_OPTION_VALID_ATTRIBUTE_P (tree @var{fndecl}, tree @var{name}, tree @var{args}, int @var{flags})
-@c hook-start:TARGET_OPTION_valid_attribute_p
+@c hook-start:TARGET_OPTION_VALID_ATTRIBUTE_P
 This hook is called to parse @code{attribute(target("..."))}, which
 allows setting target-specific options on individual functions.
 These function-specific options may differ
@@ -11377,7 +11377,7 @@ the function declaration to hold a pointer to a target-specific
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OPTION_SAVE (struct cl_target_option *@var{ptr}, struct gcc_options *@var{opts}, struct gcc_options *@var{opts_set})
-@c hook-start:TARGET_OPTION_save
+@c hook-start:TARGET_OPTION_SAVE
 This hook is called to save any additional target-specific information
 in the @code{struct cl_target_option} structure for function-specific
 options from the @code{struct gcc_options} structure.
@@ -11386,7 +11386,7 @@ options from the @code{struct gcc_options} structure.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OPTION_RESTORE (struct gcc_options *@var{opts}, struct gcc_options *@var{opts_set}, struct cl_target_option *@var{ptr})
-@c hook-start:TARGET_OPTION_restore
+@c hook-start:TARGET_OPTION_RESTORE
 This hook is called to restore any additional target-specific
 information in the @code{struct cl_target_option} structure for
 function-specific options to the @code{struct gcc_options} structure.
@@ -11394,7 +11394,7 @@ function-specific options to the @code{struct gcc_options} structure.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OPTION_POST_STREAM_IN (struct cl_target_option *@var{ptr})
-@c hook-start:TARGET_OPTION_post_stream_in
+@c hook-start:TARGET_OPTION_POST_STREAM_IN
 This hook is called to update target-specific information in the
 @code{struct cl_target_option} structure after it is streamed in from
 LTO bytecode.
@@ -11402,7 +11402,7 @@ LTO bytecode.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OPTION_PRINT (FILE *@var{file}, int @var{indent}, struct cl_target_option *@var{ptr})
-@c hook-start:TARGET_OPTION_print
+@c hook-start:TARGET_OPTION_PRINT
 This hook is called to print any additional target-specific
 information in the @code{struct cl_target_option} structure for
 function-specific options.
@@ -11410,7 +11410,7 @@ function-specific options.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_OPTION_PRAGMA_PARSE (tree @var{args}, tree @var{pop_target})
-@c hook-start:TARGET_OPTION_pragma_parse
+@c hook-start:TARGET_OPTION_PRAGMA_PARSE
 This target hook parses the options for @code{#pragma GCC target}, which
 sets the target-specific options for functions that occur later in the
 input stream.  The options accepted should be the same as those handled by the
@@ -11419,7 +11419,7 @@ input stream.  The options accepted should be the same as those handled by the
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_OPTION_OVERRIDE (void)
-@c hook-start:TARGET_OPTION_override
+@c hook-start:TARGET_OPTION_OVERRIDE
 Sometimes certain combinations of command options do not make sense on
 a particular target machine.  You can override the hook
 @code{TARGET_OPTION_OVERRIDE} to take account of this.  This hooks is called
@@ -11435,7 +11435,7 @@ changed via the optimize attribute or pragma, see
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_OPTION_FUNCTION_VERSIONS (tree @var{decl1}, tree @var{decl2})
-@c hook-start:TARGET_OPTION_function_versions
+@c hook-start:TARGET_OPTION_FUNCTION_VERSIONS
 This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are
 versions of the same function.  @var{DECL1} and @var{DECL2} are function
 versions if and only if they have the same function signature and
@@ -11445,7 +11445,7 @@ different target machines.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CAN_INLINE_P (tree @var{caller}, tree @var{callee})
-@c hook-start:TARGET_can_inline_p
+@c hook-start:TARGET_CAN_INLINE_P
 This target hook returns @code{false} if the @var{caller} function
 cannot inline @var{callee}, based on target specific information.  By
 default, inlining is not allowed if the callee function has function
@@ -11454,7 +11454,7 @@ specific target options and the caller does not use the same options.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_RELAYOUT_FUNCTION (tree @var{fndecl})
-@c hook-start:TARGET_relayout_function
+@c hook-start:TARGET_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.
@@ -11478,7 +11478,7 @@ which, when given the address of the control object, will return the
 address of the current thread's instance of the TLS object.
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_GET_ADDRESS
-@c hook-start:TARGET_EMUTLS_get_address
+@c hook-start:TARGET_EMUTLS_GET_ADDRESS
 Contains the name of the helper function that uses a TLS control
 object to locate a TLS instance.  The default causes libgcc's
 emulated TLS helper function to be used.
@@ -11486,7 +11486,7 @@ emulated TLS helper function to be used.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_REGISTER_COMMON
-@c hook-start:TARGET_EMUTLS_register_common
+@c hook-start:TARGET_EMUTLS_REGISTER_COMMON
 Contains the name of the helper function that should be used at
 program startup to register TLS objects that are implicitly
 initialized to zero.  If this is @code{NULL}, all TLS objects will
@@ -11496,7 +11496,7 @@ registration function to be used.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_VAR_SECTION
-@c hook-start:TARGET_EMUTLS_var_section
+@c hook-start:TARGET_EMUTLS_VAR_SECTION
 Contains the name of the section in which TLS control variables should
 be placed.  The default of @code{NULL} allows these to be placed in
 any section.
@@ -11504,7 +11504,7 @@ any section.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_TMPL_SECTION
-@c hook-start:TARGET_EMUTLS_tmpl_section
+@c hook-start:TARGET_EMUTLS_TMPL_SECTION
 Contains the name of the section in which TLS initializers should be
 placed.  The default of @code{NULL} allows these to be placed in any
 section.
@@ -11512,21 +11512,21 @@ section.
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_VAR_PREFIX
-@c hook-start:TARGET_EMUTLS_var_prefix
+@c hook-start:TARGET_EMUTLS_VAR_PREFIX
 Contains the prefix to be prepended to TLS control variable names.
 The default of @code{NULL} uses a target-specific prefix.
 @end deftypevr
 @c hook-end
 
 @deftypevr {Target Hook} {const char *} TARGET_EMUTLS_TMPL_PREFIX
-@c hook-start:TARGET_EMUTLS_tmpl_prefix
+@c hook-start:TARGET_EMUTLS_TMPL_PREFIX
 Contains the prefix to be prepended to TLS initializer objects.  The
 default of @code{NULL} uses a target-specific prefix.
 @end deftypevr
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_EMUTLS_VAR_FIELDS (tree @var{type}, tree *@var{name})
-@c hook-start:TARGET_EMUTLS_var_fields
+@c hook-start:TARGET_EMUTLS_VAR_FIELDS
 Specifies a function that generates the FIELD_DECLs for a TLS control
 object type.  @var{type} is the RECORD_TYPE the fields are for and
 @var{name} should be filled with the structure tag, if the default of
@@ -11536,7 +11536,7 @@ for libgcc's emulated TLS function.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_EMUTLS_VAR_INIT (tree @var{var}, tree @var{decl}, tree @var{tmpl_addr})
-@c hook-start:TARGET_EMUTLS_var_init
+@c hook-start:TARGET_EMUTLS_VAR_INIT
 Specifies a function that generates the CONSTRUCTOR to initialize a
 TLS control object.  @var{var} is the TLS control object, @var{decl}
 is the TLS object and @var{tmpl_addr} is the address of the
@@ -11545,7 +11545,7 @@ initializer.  The default initializes libgcc's emulated TLS control object.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_EMUTLS_VAR_ALIGN_FIXED
-@c hook-start:TARGET_EMUTLS_var_align_fixed
+@c hook-start:TARGET_EMUTLS_VAR_ALIGN_FIXED
 Specifies whether the alignment of TLS control variable objects is
 fixed and should not be increased as some backends may do to optimize
 single objects.  The default is false.
@@ -11553,7 +11553,7 @@ single objects.  The default is false.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
-@c hook-start:TARGET_EMUTLS_debug_form_tls_address
+@c hook-start:TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
 Specifies whether a DWARF @code{DW_OP_form_tls_address} location descriptor
 may be used to describe emulated TLS control objects.
 @end deftypevr
@@ -11592,7 +11592,7 @@ floating-point support; they are not included in this mechanism.
 @cindex parameters, precompiled headers
 
 @deftypefn {Target Hook} {void *} TARGET_GET_PCH_VALIDITY (size_t *@var{sz})
-@c hook-start:TARGET_get_pch_validity
+@c hook-start:TARGET_GET_PCH_VALIDITY
 This hook returns a pointer to the data needed by
 @code{TARGET_PCH_VALID_P} and sets
 @samp{*@var{sz}} to the size of the data in bytes.
@@ -11600,7 +11600,7 @@ This hook returns a pointer to the data needed by
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_PCH_VALID_P (const void *@var{data}, size_t @var{sz})
-@c hook-start:TARGET_pch_valid_p
+@c hook-start:TARGET_PCH_VALID_P
 This hook checks whether the options used to create a PCH file are
 compatible with the current settings.  It returns @code{NULL}
 if so and a suitable error message if not.  Error messages will
@@ -11617,7 +11617,7 @@ suitable for most targets.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_CHECK_PCH_TARGET_FLAGS (int @var{pch_flags})
-@c hook-start:TARGET_check_pch_target_flags
+@c hook-start:TARGET_CHECK_PCH_TARGET_FLAGS
 If this hook is nonnull, the default implementation of
 @code{TARGET_PCH_VALID_P} will use it to check for compatible values
 of @code{target_flags}.  @var{pch_flags} specifies the value that
@@ -11627,7 +11627,7 @@ value is the same as for @code{TARGET_PCH_VALID_P}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_PREPARE_PCH_SAVE (void)
-@c hook-start:TARGET_prepare_pch_save
+@c hook-start:TARGET_PREPARE_PCH_SAVE
 Called before writing out a PCH file.  If the target has some
 garbage-collected data that needs to be in a particular state on PCH loads,
 it can use this hook to enforce that state.  Very few targets need
@@ -11640,7 +11640,7 @@ to do anything here.
 @cindex parameters, c++ abi
 
 @deftypefn {Target Hook} tree TARGET_CXX_GUARD_TYPE (void)
-@c hook-start:TARGET_CXX_guard_type
+@c hook-start:TARGET_CXX_GUARD_TYPE
 Define this hook to override the integer type used for guard variables.
 These are used to implement one-time construction of static objects.  The
 default is long_long_integer_type_node.
@@ -11648,7 +11648,7 @@ default is long_long_integer_type_node.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_GUARD_MASK_BIT (void)
-@c hook-start:TARGET_CXX_guard_mask_bit
+@c hook-start:TARGET_CXX_GUARD_MASK_BIT
 This hook determines how guard variables are used.  It should return
 @code{false} (the default) if the first byte should be used.  A return value of
 @code{true} indicates that only the least significant bit should be used.
@@ -11656,7 +11656,7 @@ This hook determines how guard variables are used.  It should return
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_CXX_GET_COOKIE_SIZE (tree @var{type})
-@c hook-start:TARGET_CXX_get_cookie_size
+@c hook-start:TARGET_CXX_GET_COOKIE_SIZE
 This hook returns the size of the cookie to use when allocating an array
 whose elements have the indicated @var{type}.  Assumes that it is already
 known that a cookie is needed.  The default is
@@ -11666,14 +11666,14 @@ IA64/Generic C++ ABI@.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_COOKIE_HAS_SIZE (void)
-@c hook-start:TARGET_CXX_cookie_has_size
+@c hook-start:TARGET_CXX_COOKIE_HAS_SIZE
 This hook should return @code{true} if the element size should be stored in
 array cookies.  The default is to return @code{false}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_CXX_IMPORT_EXPORT_CLASS (tree @var{type}, int @var{import_export})
-@c hook-start:TARGET_CXX_import_export_class
+@c hook-start:TARGET_CXX_IMPORT_EXPORT_CLASS
 If defined by a backend this hook allows the decision made to export
 class @var{type} to be overruled.  Upon entry @var{import_export}
 will contain 1 if the class is going to be exported, @minus{}1 if it is going
@@ -11684,7 +11684,7 @@ backend's targeted operating system.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_CDTOR_RETURNS_THIS (void)
-@c hook-start:TARGET_CXX_cdtor_returns_this
+@c hook-start:TARGET_CXX_CDTOR_RETURNS_THIS
 This hook should return @code{true} if constructors and destructors return
 the address of the object created/destroyed.  The default is to return
 @code{false}.
@@ -11692,7 +11692,7 @@ the address of the object created/destroyed.  The default is to return
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_KEY_METHOD_MAY_BE_INLINE (void)
-@c hook-start:TARGET_CXX_key_method_may_be_inline
+@c hook-start:TARGET_CXX_KEY_METHOD_MAY_BE_INLINE
 This hook returns true if the key method for a class (i.e., the method
 which, if defined in the current translation unit, causes the virtual
 table to be emitted) may be an inline function.  Under the standard
@@ -11704,7 +11704,7 @@ method.  The default is to return @code{true}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY (tree @var{decl})
-@c hook-start:TARGET_CXX_determine_class_data_visibility
+@c hook-start:TARGET_CXX_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
@@ -11715,7 +11715,7 @@ other than that of the containing class, use this hook to set
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT (void)
-@c hook-start:TARGET_CXX_class_data_always_comdat
+@c hook-start:TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT
 This hook returns true (the default) if virtual tables and other
 similar implicit class data objects are always COMDAT if they have
 external linkage.  If this hook returns false, then class data for
@@ -11725,7 +11725,7 @@ unit will not be COMDAT.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_LIBRARY_RTTI_COMDAT (void)
-@c hook-start:TARGET_CXX_library_rtti_comdat
+@c hook-start:TARGET_CXX_LIBRARY_RTTI_COMDAT
 This hook returns true (the default) if the RTTI information for
 the basic types which is defined in the C++ runtime should always
 be COMDAT, false if it should not be COMDAT.
@@ -11733,7 +11733,7 @@ be COMDAT, false if it should not be COMDAT.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_USE_AEABI_ATEXIT (void)
-@c hook-start:TARGET_CXX_use_aeabi_atexit
+@c hook-start:TARGET_CXX_USE_AEABI_ATEXIT
 This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI)
 should be used to register static destructors when @option{-fuse-cxa-atexit}
 is in effect.  The default is to return false to use @code{__cxa_atexit}.
@@ -11741,7 +11741,7 @@ is in effect.  The default is to return false to use @code{__cxa_atexit}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT (void)
-@c hook-start:TARGET_CXX_use_atexit_for_cxa_atexit
+@c hook-start:TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT
 This hook returns true if the target @code{atexit} function can be used
 in the same manner as @code{__cxa_atexit} to register C++ static
 destructors. This requires that @code{atexit}-registered functions in
@@ -11751,7 +11751,7 @@ unloaded. The default is to return false.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_CXX_ADJUST_CLASS_AT_DEFINITION (tree @var{type})
-@c hook-start:TARGET_CXX_adjust_class_at_definition
+@c hook-start:TARGET_CXX_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).
@@ -11759,7 +11759,7 @@ visibility or perform any other required target modifications).
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_CXX_DECL_MANGLING_CONTEXT (const_tree @var{decl})
-@c hook-start:TARGET_CXX_decl_mangling_context
+@c hook-start:TARGET_CXX_DECL_MANGLING_CONTEXT
 Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.
 @end deftypefn
 @c hook-end
@@ -11769,7 +11769,7 @@ Return target-specific mangling context of @var{decl} or @code{NULL_TREE}.
 @cindex parameters, d abi
 
 @deftypefn {D Target Hook} void TARGET_D_CPU_VERSIONS (void)
-@c hook-start:TARGET_d_cpu_versions
+@c hook-start:TARGET_D_CPU_VERSIONS
 Declare all environmental version identifiers relating to the target CPU
 using the function @code{builtin_version}, which takes a string representing
 the name of the version.  Version identifiers predefined by this hook apply
@@ -11778,14 +11778,14 @@ to all modules that are being compiled and imported.
 @c hook-end
 
 @deftypefn {D Target Hook} void TARGET_D_OS_VERSIONS (void)
-@c hook-start:TARGET_d_os_versions
+@c hook-start:TARGET_D_OS_VERSIONS
 Similarly to @code{TARGET_D_CPU_VERSIONS}, but is used for versions
 relating to the target operating system.
 @end deftypefn
 @c hook-end
 
 @deftypefn {D Target Hook} void TARGET_D_REGISTER_CPU_TARGET_INFO (void)
-@c hook-start:TARGET_d_register_cpu_target_info
+@c hook-start:TARGET_D_REGISTER_CPU_TARGET_INFO
 Register all target information keys relating to the target CPU using the
 function @code{d_add_target_info_handlers}, which takes a
 @samp{struct d_target_info_spec} (defined in @file{d/d-target.h}).  The keys
@@ -11796,14 +11796,14 @@ describing the requested target information.
 @c hook-end
 
 @deftypefn {D Target Hook} void TARGET_D_REGISTER_OS_TARGET_INFO (void)
-@c hook-start:TARGET_d_register_os_target_info
+@c hook-start:TARGET_D_REGISTER_OS_TARGET_INFO
 Same as @code{TARGET_D_CPU_TARGET_INFO}, but is used for keys relating to
 the target operating system.
 @end deftypefn
 @c hook-end
 
 @deftypevr {D Target Hook} {const char *} TARGET_D_MINFO_SECTION
-@c hook-start:TARGET_d_minfo_section
+@c hook-start:TARGET_D_MINFO_SECTION
 Contains the name of the section in which module info references should be
 placed.  This section is expected to be bracketed by two symbols to indicate
 the start and end address of the section, so that the runtime library can
@@ -11813,7 +11813,7 @@ default value of @code{NULL} disables the use of sections altogether.
 @c hook-end
 
 @deftypevr {D Target Hook} {const char *} TARGET_D_MINFO_START_NAME
-@c hook-start:TARGET_d_minfo_start_name
+@c hook-start:TARGET_D_MINFO_START_NAME
 If @code{TARGET_D_MINFO_SECTION} is defined, then this must also be defined
 as the name of the symbol indicating the start address of the module info
 section
@@ -11821,7 +11821,7 @@ section
 @c hook-end
 
 @deftypevr {D Target Hook} {const char *} TARGET_D_MINFO_END_NAME
-@c hook-start:TARGET_d_minfo_end_name
+@c hook-start:TARGET_D_MINFO_END_NAME
 If @code{TARGET_D_MINFO_SECTION} is defined, then this must also be defined
 as the name of the symbol indicating the end address of the module info
 section
@@ -11829,7 +11829,7 @@ section
 @c hook-end
 
 @deftypefn {D Target Hook} bool TARGET_D_HAS_STDCALL_CONVENTION (unsigned int *@var{link_system}, unsigned int *@var{link_windows})
-@c hook-start:TARGET_d_has_stdcall_convention
+@c hook-start:TARGET_D_HAS_STDCALL_CONVENTION
 Returns @code{true} if the target supports the stdcall calling convention.
 The hook should also set @var{link_system} to @code{1} if the @code{stdcall}
 attribute should be applied to functions with @code{extern(System)} linkage,
@@ -11839,7 +11839,7 @@ and @var{link_windows} to @code{1} to apply @code{stdcall} to functions with
 @c hook-end
 
 @deftypevr {D Target Hook} bool TARGET_D_TEMPLATES_ALWAYS_COMDAT
-@c hook-start:TARGET_d_templates_always_comdat
+@c hook-start:TARGET_D_TEMPLATES_ALWAYS_COMDAT
 This flag is true if instantiated functions and variables are always COMDAT
 if they have external linkage.  If this flag is false, then instantiated
 decls will be emitted as weak symbols.  The default is @code{false}.
@@ -11885,7 +11885,7 @@ c_register_addr_space ("__ea", ADDR_SPACE_EA);
 @end smallexample
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t @var{address_space})
-@c hook-start:TARGET_ADDR_SPACE_pointer_mode
+@c hook-start:TARGET_ADDR_SPACE_POINTER_MODE
 Define this to return the machine mode to use for pointers to
 @var{address_space} if the target supports named address spaces.
 The default version of this hook returns @code{ptr_mode}.
@@ -11893,7 +11893,7 @@ The default version of this hook returns @code{ptr_mode}.
 @c hook-end
 
 @deftypefn {Target Hook} scalar_int_mode TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t @var{address_space})
-@c hook-start:TARGET_ADDR_SPACE_address_mode
+@c hook-start:TARGET_ADDR_SPACE_ADDRESS_MODE
 Define this to return the machine mode to use for addresses in
 @var{address_space} if the target supports named address spaces.
 The default version of this hook returns @code{Pmode}.
@@ -11901,7 +11901,7 @@ The default version of this hook returns @code{Pmode}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (scalar_int_mode @var{mode}, addr_space_t @var{as})
-@c hook-start:TARGET_ADDR_SPACE_valid_pointer_mode
+@c hook-start:TARGET_ADDR_SPACE_VALID_POINTER_MODE
 Define this to return nonzero if the port can handle pointers
 with machine mode @var{mode} to address space @var{as}.  This target
 hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,
@@ -11913,7 +11913,7 @@ target hooks for the given address space.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (machine_mode @var{mode}, rtx @var{exp}, bool @var{strict}, addr_space_t @var{as})
-@c hook-start:TARGET_ADDR_SPACE_legitimate_address_p
+@c hook-start:TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
 Define this to return true if @var{exp} is a valid address for mode
 @var{mode} in the named address space @var{as}.  The @var{strict}
 parameter says whether strict addressing is in effect after reload has
@@ -11924,7 +11924,7 @@ explicit named address space support.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, machine_mode @var{mode}, addr_space_t @var{as})
-@c hook-start:TARGET_ADDR_SPACE_legitimize_address
+@c hook-start:TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS
 Define this to modify an invalid address @var{x} to be a valid address
 with mode @var{mode} in the named address space @var{as}.  This target
 hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,
@@ -11933,7 +11933,7 @@ except that it includes explicit named address space support.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_SUBSET_P (addr_space_t @var{subset}, addr_space_t @var{superset})
-@c hook-start:TARGET_ADDR_SPACE_subset_p
+@c hook-start:TARGET_ADDR_SPACE_SUBSET_P
 Define this to return whether the @var{subset} named address space is
 contained within the @var{superset} named address space.  Pointers to
 a named address space that is a subset of another named address space
@@ -11944,14 +11944,14 @@ converted to pointers to a subset address space via explicit casts.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ADDR_SPACE_ZERO_ADDRESS_VALID (addr_space_t @var{as})
-@c hook-start:TARGET_ADDR_SPACE_zero_address_valid
+@c hook-start:TARGET_ADDR_SPACE_ZERO_ADDRESS_VALID
 Define this to modify the default handling of address 0 for the
 address space.  Return true if 0 should be considered a valid address.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_ADDR_SPACE_CONVERT (rtx @var{op}, tree @var{from_type}, tree @var{to_type})
-@c hook-start:TARGET_ADDR_SPACE_convert
+@c hook-start:TARGET_ADDR_SPACE_CONVERT
 Define this to convert the pointer expression represented by the RTL
 @var{op} with type @var{from_type} that points to a named address
 space to a new pointer expression with type @var{to_type} that points
@@ -11962,14 +11962,14 @@ as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_ADDR_SPACE_DEBUG (addr_space_t @var{as})
-@c hook-start:TARGET_ADDR_SPACE_debug
+@c hook-start:TARGET_ADDR_SPACE_DEBUG
 Define this to define how the address space is encoded in dwarf.
 The result is the value to be used with @code{DW_AT_address_class}.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ADDR_SPACE_DIAGNOSE_USAGE (addr_space_t @var{as}, location_t @var{loc})
-@c hook-start:TARGET_ADDR_SPACE_diagnose_usage
+@c hook-start:TARGET_ADDR_SPACE_DIAGNOSE_USAGE
 Define this hook if the availability of an address space depends on
 command line options and some diagnostics should be printed when the
 address space is used.  This hook is called during parsing and allows
@@ -12030,7 +12030,7 @@ is in effect.
 @end defmac
 
 @deftypefn {Target Hook} {unsigned int} TARGET_CASE_VALUES_THRESHOLD (void)
-@c hook-start:TARGET_case_values_threshold
+@c hook-start:TARGET_CASE_VALUES_THRESHOLD
 This function return the smallest number of different values for which it
 is best to use a jump-table instead of a tree of conditional branches.
 The default is four for machines with a @code{casesi} instruction and
@@ -12049,7 +12049,7 @@ to 1.  Most RISC machines have this property and most CISC machines do not.
 @end defmac
 
 @deftypefn {Target Hook} {unsigned int} TARGET_MIN_ARITHMETIC_PRECISION (void)
-@c hook-start:TARGET_min_arithmetic_precision
+@c hook-start:TARGET_MIN_ARITHMETIC_PRECISION
 On some RISC architectures with 64-bit registers, the processor also
 maintains 32-bit condition codes that make it possible to do real 32-bit
 arithmetic, although the operations are performed on the full registers.
@@ -12100,7 +12100,7 @@ extends.
 @end defmac
 
 @deftypefn {Target Hook} {unsigned int} TARGET_MIN_DIVISIONS_FOR_RECIP_MUL (machine_mode @var{mode})
-@c hook-start:TARGET_min_divisions_for_recip_mul
+@c hook-start:TARGET_MIN_DIVISIONS_FOR_RECIP_MUL
 When @option{-ffast-math} is in effect, GCC tries to optimize
 divisions by the same divisor, by turning them into multiplications by
 the reciprocal.  This target hook specifies the minimum number of divisions
@@ -12150,7 +12150,7 @@ You need not define this macro if it would always have the value of zero.
 
 @anchor{TARGET_SHIFT_TRUNCATION_MASK}
 @deftypefn {Target Hook} {unsigned HOST_WIDE_INT} TARGET_SHIFT_TRUNCATION_MASK (machine_mode @var{mode})
-@c hook-start:TARGET_shift_truncation_mask
+@c hook-start:TARGET_SHIFT_TRUNCATION_MASK
 This function describes how the standard shift patterns for @var{mode}
 deal with shifts by negative amounts or by more than the width of the mode.
 @xref{shift patterns}.
@@ -12176,7 +12176,7 @@ by overriding it.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_TRULY_NOOP_TRUNCATION (poly_uint64 @var{outprec}, poly_uint64 @var{inprec})
-@c hook-start:TARGET_truly_noop_truncation
+@c hook-start:TARGET_TRULY_NOOP_TRUNCATION
 This hook returns true if it is safe to ``convert'' a value of
 @var{inprec} bits to one of @var{outprec} bits (where @var{outprec} is
 smaller than @var{inprec}) by merely operating on it as if it had only
@@ -12192,7 +12192,7 @@ mode sizes.  Making this hook return false in such cases may improve things.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_MODE_REP_EXTENDED (scalar_int_mode @var{mode}, scalar_int_mode @var{rep_mode})
-@c hook-start:TARGET_mode_rep_extended
+@c hook-start:TARGET_MODE_REP_EXTENDED
 The representation of an integral mode can be such that the values
 are always extended to a wider integral mode.  Return
 @code{SIGN_EXTEND} if values of @var{mode} are represented in
@@ -12222,7 +12222,7 @@ In order to enforce the representation of @code{mode},
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_SETJMP_PRESERVES_NONVOLATILE_REGS_P (void)
-@c hook-start:TARGET_setjmp_preserves_nonvolatile_regs_p
+@c hook-start:TARGET_SETJMP_PRESERVES_NONVOLATILE_REGS_P
 On some targets, it is assumed that the compiler will spill all pseudos
   that are live across a call to @code{setjmp}, while other targets treat
   @code{setjmp} calls as normal function calls.
@@ -12416,7 +12416,7 @@ files @code{__STDC__} will always expand to 1.
 @end defmac
 
 @deftypefn {C Target Hook} {const char *} TARGET_C_PREINCLUDE (void)
-@c hook-start:TARGET_c_preinclude
+@c hook-start:TARGET_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
@@ -12431,7 +12431,7 @@ than just the compiler.
 @c hook-end
 
 @deftypefn {C Target Hook} bool TARGET_CXX_IMPLICIT_EXTERN_C (const char*@var{})
-@c hook-start:TARGET_cxx_implicit_extern_c
+@c hook-start:TARGET_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
@@ -12559,7 +12559,7 @@ You need not define this macro if it would always evaluate to zero.
 @end defmac
 
 @deftypefn {Target Hook} {rtx_insn *} TARGET_MD_ASM_ADJUST (vec<rtx>& @var{outputs}, vec<rtx>& @var{inputs}, vec<machine_mode>& @var{input_modes}, vec<const char *>& @var{constraints}, vec<rtx>& @var{clobbers}, HARD_REG_SET& @var{clobbered_regs})
-@c hook-start:TARGET_md_asm_adjust
+@c hook-start:TARGET_MD_ASM_ADJUST
 This target hook may add @dfn{clobbers} to @var{clobbers} and
 @var{clobbered_regs} for any hard regs the port wishes to automatically
 clobber for an asm.  The @var{outputs} and @var{inputs} may be inspected
@@ -12651,7 +12651,7 @@ to by @var{ce_info}.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_MACHINE_DEPENDENT_REORG (void)
-@c hook-start:TARGET_machine_dependent_reorg
+@c hook-start:TARGET_MACHINE_DEPENDENT_REORG
 If non-null, this hook performs a target-specific pass over the
 instruction stream.  The compiler will run it at all optimization levels,
 just before the point at which it normally does delayed-branch scheduling.
@@ -12667,7 +12667,7 @@ definition is null.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_INIT_BUILTINS (void)
-@c hook-start:TARGET_init_builtins
+@c hook-start:TARGET_INIT_BUILTINS
 Define this hook if you have any machine-specific built-in functions
 that need to be defined.  It should be a function that performs the
 necessary setup.
@@ -12687,7 +12687,7 @@ only language front ends that use those two functions will call
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_BUILTIN_DECL (unsigned @var{code}, bool @var{initialize_p})
-@c hook-start:TARGET_builtin_decl
+@c hook-start:TARGET_BUILTIN_DECL
 Define this hook if you have any machine-specific built-in functions
 that need to be defined.  It should be a function that returns the
 builtin function declaration for the builtin function code @var{code}.
@@ -12699,7 +12699,7 @@ If @var{code} is out of range the function should return
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN (tree @var{exp}, rtx @var{target}, rtx @var{subtarget}, machine_mode @var{mode}, int @var{ignore})
-@c hook-start:TARGET_expand_builtin
+@c hook-start:TARGET_EXPAND_BUILTIN
 
 Expand a call to a machine specific built-in function that was set up by
 @samp{TARGET_INIT_BUILTINS}.  @var{exp} is the expression for the
@@ -12713,7 +12713,7 @@ built-in function.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_RESOLVE_OVERLOADED_BUILTIN (unsigned int @var{loc}, tree @var{fndecl}, void *@var{arglist})
-@c hook-start:TARGET_resolve_overloaded_builtin
+@c hook-start:TARGET_RESOLVE_OVERLOADED_BUILTIN
 Select a replacement for a machine specific built-in function that
 was set up by @samp{TARGET_INIT_BUILTINS}.  This is done
 @emph{before} regular type checking, and so allows the target to
@@ -12727,7 +12727,7 @@ another @code{CALL_EXPR}.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CHECK_BUILTIN_CALL (location_t @var{loc}, vec<location_t> @var{arg_loc}, tree @var{fndecl}, tree @var{orig_fndecl}, unsigned int @var{nargs}, tree *@var{args})
-@c hook-start:TARGET_check_builtin_call
+@c hook-start:TARGET_CHECK_BUILTIN_CALL
 Perform semantic checking on a call to a machine-specific built-in
 function after its arguments have been constrained to the function
 signature.  Return true if the call is valid, otherwise report an error
@@ -12744,7 +12744,7 @@ of each argument.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_FOLD_BUILTIN (tree @var{fndecl}, int @var{n_args}, tree *@var{argp}, bool @var{ignore})
-@c hook-start:TARGET_fold_builtin
+@c hook-start:TARGET_FOLD_BUILTIN
 Fold a call to a machine specific built-in function that was set up by
 @samp{TARGET_INIT_BUILTINS}.  @var{fndecl} is the declaration of the
 built-in function.  @var{n_args} is the number of arguments passed to
@@ -12756,7 +12756,7 @@ containing a simplified expression for the call's result.  If
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_GIMPLE_FOLD_BUILTIN (gimple_stmt_iterator *@var{gsi})
-@c hook-start:TARGET_gimple_fold_builtin
+@c hook-start:TARGET_GIMPLE_FOLD_BUILTIN
 Fold a call to a machine specific built-in function that was set up
 by @samp{TARGET_INIT_BUILTINS}.  @var{gsi} points to the gimple
 statement holding the function call.  Returns true if any change
@@ -12765,7 +12765,7 @@ was made to the GIMPLE stream.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_COMPARE_VERSION_PRIORITY (tree @var{decl1}, tree @var{decl2})
-@c hook-start:TARGET_compare_version_priority
+@c hook-start:TARGET_COMPARE_VERSION_PRIORITY
 This hook is used to compare the target attributes in two functions to
 determine which function's features get higher priority.  This is used
 during function multi-versioning to figure out the order in which two
@@ -12776,7 +12776,7 @@ is checked for dispatching earlier.  @var{decl1} and @var{decl2} are
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_GET_FUNCTION_VERSIONS_DISPATCHER (void *@var{decl})
-@c hook-start:TARGET_get_function_versions_dispatcher
+@c hook-start:TARGET_GET_FUNCTION_VERSIONS_DISPATCHER
 This hook is used to get the dispatcher function for a set of function
 versions.  The dispatcher function is called to invoke the right function
 version at run-time. @var{decl} is one version from a set of semantically
@@ -12785,7 +12785,7 @@ identical versions.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_GENERATE_VERSION_DISPATCHER_BODY (void *@var{arg})
-@c hook-start:TARGET_generate_version_dispatcher_body
+@c hook-start:TARGET_GENERATE_VERSION_DISPATCHER_BODY
 This hook is used to generate the dispatcher logic to invoke the right
 function version at run-time for a given set of function versions.
 @var{arg} points to the callgraph node of the dispatcher function whose
@@ -12794,7 +12794,7 @@ body must be generated.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_PREDICT_DOLOOP_P (class loop *@var{loop})
-@c hook-start:TARGET_predict_doloop_p
+@c hook-start:TARGET_PREDICT_DOLOOP_P
 Return true if we can predict it is possible to use a low-overhead loop
 for a particular loop.  The parameter @var{loop} is a pointer to the loop.
 This target hook is required only when the target supports low-overhead
@@ -12804,7 +12804,7 @@ The default version of this hook returns false.
 @c hook-end
 
 @deftypevr {Target Hook} bool TARGET_HAVE_COUNT_REG_DECR_P
-@c hook-start:TARGET_have_count_reg_decr_p
+@c hook-start:TARGET_HAVE_COUNT_REG_DECR_P
 Return true if the target supports hardware count register for decrement
 and branch.
 The default value is false.
@@ -12812,7 +12812,7 @@ The default value is false.
 @c hook-end
 
 @deftypevr {Target Hook} int64_t TARGET_DOLOOP_COST_FOR_GENERIC
-@c hook-start:TARGET_doloop_cost_for_generic
+@c hook-start:TARGET_DOLOOP_COST_FOR_GENERIC
 One IV candidate dedicated for doloop is introduced in IVOPTs, we can
 calculate the computation cost of adopting it to any generic IV use by
 function get_computation_cost as before.  But for targets which have
@@ -12826,7 +12826,7 @@ The default value is zero.
 @c hook-end
 
 @deftypevr {Target Hook} int64_t TARGET_DOLOOP_COST_FOR_ADDRESS
-@c hook-start:TARGET_doloop_cost_for_address
+@c hook-start:TARGET_DOLOOP_COST_FOR_ADDRESS
 One IV candidate dedicated for doloop is introduced in IVOPTs, we can
 calculate the computation cost of adopting it to any address IV use by
 function get_computation_cost as before.  But for targets which have
@@ -12840,7 +12840,7 @@ The default value is zero.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CAN_USE_DOLOOP_P (const widest_int @var{&iterations}, const widest_int @var{&iterations_max}, unsigned int @var{loop_depth}, bool @var{entered_at_top})
-@c hook-start:TARGET_can_use_doloop_p
+@c hook-start:TARGET_CAN_USE_DOLOOP_P
 Return true if it is possible to use low-overhead loops (@code{doloop_end}
 and @code{doloop_begin}) for a particular loop.  @var{iterations} gives the
 exact number of iterations, or 0 if not known.  @var{iterations_max} gives
@@ -12856,7 +12856,7 @@ if the loop must be the innermost, and if there are no other restrictions.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_WITHIN_DOLOOP (const rtx_insn *@var{insn})
-@c hook-start:TARGET_invalid_within_doloop
+@c hook-start:TARGET_INVALID_WITHIN_DOLOOP
 
 Take an instruction in @var{insn} and return NULL if it is valid within a
 low-overhead loop, otherwise return a string explaining why doloop
@@ -12871,7 +12871,7 @@ loops containing function calls or branch on table instructions.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_LEGITIMATE_COMBINED_INSN (rtx_insn *@var{insn})
-@c hook-start:TARGET_legitimate_combined_insn
+@c hook-start:TARGET_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.
@@ -12879,7 +12879,7 @@ default is to accept all instructions.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_CAN_FOLLOW_JUMP (const rtx_insn *@var{follower}, const rtx_insn *@var{followee})
-@c hook-start:TARGET_can_follow_jump
+@c hook-start:TARGET_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.
@@ -12889,7 +12889,7 @@ follow through a hot/cold partitioning.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_COMMUTATIVE_P (const_rtx @var{x}, int @var{outer_code})
-@c hook-start:TARGET_commutative_p
+@c hook-start:TARGET_COMMUTATIVE_P
 This target hook returns @code{true} if @var{x} is considered to be commutative.
 Usually, this is just COMMUTATIVE_P (@var{x}), but the HP PA doesn't consider
 PLUS to be commutative inside a MEM@.  @var{outer_code} is the rtx code
@@ -12898,7 +12898,7 @@ of the enclosing rtl, if known, otherwise it is UNKNOWN.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_ALLOCATE_INITIAL_VALUE (rtx @var{hard_reg})
-@c hook-start:TARGET_allocate_initial_value
+@c hook-start:TARGET_ALLOCATE_INITIAL_VALUE
 
 When the initial value of a hard register has been copied in a pseudo
 register, it is often not necessary to actually allocate another register
@@ -12922,7 +12922,7 @@ allocation.
 @c hook-end
 
 @deftypefn {Target Hook} int TARGET_UNSPEC_MAY_TRAP_P (const_rtx @var{x}, unsigned @var{flags})
-@c hook-start:TARGET_unspec_may_trap_p
+@c hook-start:TARGET_UNSPEC_MAY_TRAP_P
 This target hook returns nonzero if @var{x}, an @code{unspec} or
 @code{unspec_volatile} operation, might cause a trap.  Targets can use
 this hook to enhance precision of analysis for @code{unspec} and
@@ -12933,7 +12933,7 @@ passed along.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_SET_CURRENT_FUNCTION (tree @var{decl})
-@c hook-start:TARGET_set_current_function
+@c hook-start:TARGET_SET_CURRENT_FUNCTION
 The compiler invokes this hook whenever it changes its current function
 context (@code{cfun}).  You can define this function if
 the back end needs to perform any initialization or reset actions on a
@@ -12975,7 +12975,7 @@ lists.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_CANNOT_MODIFY_JUMPS_P (void)
-@c hook-start:TARGET_cannot_modify_jumps_p
+@c hook-start:TARGET_CANNOT_MODIFY_JUMPS_P
 This target hook returns @code{true} past the point in which new jump
 instructions could be created.  On machines that require a register for
 every jump such as the SHmedia ISA of SH5, this point would typically be
@@ -12992,7 +12992,7 @@ cannot_modify_jumps_past_reload_p ()
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_HAVE_CONDITIONAL_EXECUTION (void)
-@c hook-start:TARGET_have_conditional_execution
+@c hook-start:TARGET_HAVE_CONDITIONAL_EXECUTION
 This target hook returns true if the target supports conditional execution.
 This target hook is required only when the target has several different
 modes and they have different conditional execution capability, such as ARM.
@@ -13000,7 +13000,7 @@ modes and they have different conditional execution capability, such as ARM.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_GEN_CCMP_FIRST (rtx_insn **@var{prep_seq}, rtx_insn **@var{gen_seq}, int @var{code}, tree @var{op0}, tree @var{op1})
-@c hook-start:TARGET_gen_ccmp_first
+@c hook-start:TARGET_GEN_CCMP_FIRST
 This function prepares to emit a comparison insn for the first compare in a
  sequence of conditional comparisions.  It returns an appropriate comparison
  with @code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.
@@ -13012,7 +13012,7 @@ This function prepares to emit a comparison insn for the first compare in a
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_GEN_CCMP_NEXT (rtx_insn **@var{prep_seq}, rtx_insn **@var{gen_seq}, rtx @var{prev}, int @var{cmp_code}, tree @var{op0}, tree @var{op1}, int @var{bit_code})
-@c hook-start:TARGET_gen_ccmp_next
+@c hook-start:TARGET_GEN_CCMP_NEXT
 This function prepares to emit a conditional comparison within a sequence
  of conditional comparisons.  It returns an appropriate comparison with
  @code{CC} for passing to @code{gen_ccmp_next} or @code{cbranch_optab}.
@@ -13029,7 +13029,7 @@ This function prepares to emit a conditional comparison within a sequence
 @c hook-end
 
 @deftypefn {Target Hook} unsigned TARGET_LOOP_UNROLL_ADJUST (unsigned @var{nunroll}, class loop *@var{loop})
-@c hook-start:TARGET_loop_unroll_adjust
+@c hook-start:TARGET_LOOP_UNROLL_ADJUST
 This target hook returns a new value for the number of times @var{loop}
 should be unrolled. The parameter @var{nunroll} is the number of times
 the loop is to be unrolled. The parameter @var{loop} is a pointer to
@@ -13109,7 +13109,7 @@ and scanf formatter settings.
 @end defmac
 
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN (const_tree @var{typelist}, const_tree @var{funcdecl}, const_tree @var{val})
-@c hook-start:TARGET_invalid_arg_for_unprototyped_fn
+@c hook-start:TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
 If defined, this macro returns the diagnostic message when it is
 illegal to pass argument @var{val} to function @var{funcdecl}
 with prototype @var{typelist}.
@@ -13117,7 +13117,7 @@ with prototype @var{typelist}.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_CONVERSION (const_tree @var{fromtype}, const_tree @var{totype})
-@c hook-start:TARGET_invalid_conversion
+@c hook-start:TARGET_INVALID_CONVERSION
 If defined, this macro returns the diagnostic message when it is
 invalid to convert from @var{fromtype} to @var{totype}, or @code{NULL}
 if validity should be determined by the front end.
@@ -13125,7 +13125,7 @@ if validity should be determined by the front end.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_UNARY_OP (int @var{op}, const_tree @var{type})
-@c hook-start:TARGET_invalid_unary_op
+@c hook-start:TARGET_INVALID_UNARY_OP
 If defined, this macro returns the diagnostic message when it is
 invalid to apply operation @var{op} (where unary plus is denoted by
 @code{CONVERT_EXPR}) to an operand of type @var{type}, or @code{NULL}
@@ -13134,7 +13134,7 @@ if validity should be determined by the front end.
 @c hook-end
 
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_BINARY_OP (int @var{op}, const_tree @var{type1}, const_tree @var{type2})
-@c hook-start:TARGET_invalid_binary_op
+@c hook-start:TARGET_INVALID_BINARY_OP
 If defined, this macro returns the diagnostic message when it is
 invalid to apply operation @var{op} to operands of types @var{type1}
 and @var{type2}, or @code{NULL} if validity should be determined by
@@ -13143,7 +13143,7 @@ the front end.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_PROMOTED_TYPE (const_tree @var{type})
-@c hook-start:TARGET_promoted_type
+@c hook-start:TARGET_PROMOTED_TYPE
 If defined, this target hook returns the type to which values of
 @var{type} should be promoted when they appear in expressions,
 analogous to the integer promotions, or @code{NULL_TREE} to use the
@@ -13154,7 +13154,7 @@ This is currently used only by the C and C++ front ends.
 @c hook-end
 
 @deftypefn {Target Hook} tree TARGET_CONVERT_TO_TYPE (tree @var{type}, tree @var{expr})
-@c hook-start:TARGET_convert_to_type
+@c hook-start:TARGET_CONVERT_TO_TYPE
 If defined, this hook returns the result of converting @var{expr} to
 @var{type}.  It should return the converted expression,
 or @code{NULL_TREE} to apply the front end's normal conversion rules.
@@ -13165,7 +13165,7 @@ This is currently used only by the C and C++ front ends.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_VERIFY_TYPE_CONTEXT (location_t @var{loc}, type_context_kind @var{context}, const_tree @var{type}, bool @var{silent_p})
-@c hook-start:TARGET_verify_type_context
+@c hook-start:TARGET_VERIFY_TYPE_CONTEXT
 If defined, this hook returns false if there is a target-specific reason
 why type @var{type} cannot be used in the source language context described
 by @var{context}.  When @var{silent_p} is false, the hook also reports an
@@ -13192,14 +13192,14 @@ and the associated definitions of those functions.
 @end defmac
 
 @deftypefn {Target Hook} void TARGET_UPDATE_STACK_BOUNDARY (void)
-@c hook-start:TARGET_update_stack_boundary
+@c hook-start:TARGET_UPDATE_STACK_BOUNDARY
 Define this macro to update the current function stack boundary if
 necessary.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_GET_DRAP_RTX (void)
-@c hook-start:TARGET_get_drap_rtx
+@c hook-start:TARGET_GET_DRAP_RTX
 This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a
 different argument pointer register is needed to access the function's
 argument list due to stack realignment.  Return @code{NULL} if no DRAP
@@ -13208,7 +13208,7 @@ is needed.
 @c hook-end
 
 @deftypefn {Target Hook} HARD_REG_SET TARGET_ZERO_CALL_USED_REGS (HARD_REG_SET @var{selected_regs})
-@c hook-start:TARGET_zero_call_used_regs
+@c hook-start:TARGET_ZERO_CALL_USED_REGS
 This target hook emits instructions to zero the subset of @var{selected_regs}
 that could conceivably contain values that are useful to an attacker.
 Return the set of registers that were actually cleared.
@@ -13222,7 +13222,7 @@ values that are useful to an attacker.
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS (void)
-@c hook-start:TARGET_allocate_stack_slots_for_args
+@c hook-start:TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS
 When optimization is disabled, this hook indicates whether or not
 arguments should be allocated to stack slots.  Normally, GCC allocates
 stacks slots for arguments when not optimizing in order to make
@@ -13235,7 +13235,7 @@ false for naked functions.  The default implementation always returns true.
 @c hook-end
 
 @deftypevr {Target Hook} {unsigned HOST_WIDE_INT} TARGET_CONST_ANCHOR
-@c hook-start:TARGET_const_anchor
+@c hook-start:TARGET_CONST_ANCHOR
 On some architectures it can take multiple instructions to synthesize
 a constant.  If there is another constant already in a register that
 is close enough in value then it is preferable that the new constant
@@ -13255,7 +13255,7 @@ is zero, which disables this optimization.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned HOST_WIDE_INT} TARGET_ASAN_SHADOW_OFFSET (void)
-@c hook-start:TARGET_asan_shadow_offset
+@c hook-start:TARGET_ASAN_SHADOW_OFFSET
 Return the offset bitwise ored into shifted address to get corresponding
 Address Sanitizer shadow memory address.  NULL if Address Sanitizer is not
 supported by the target.  May return 0 if Address Sanitizer is not supported
@@ -13264,14 +13264,14 @@ by a subtarget.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned HOST_WIDE_INT} TARGET_MEMMODEL_CHECK (unsigned HOST_WIDE_INT @var{val})
-@c hook-start:TARGET_memmodel_check
+@c hook-start:TARGET_MEMMODEL_CHECK
 Validate target specific memory model mask bits. When NULL no target specific
 memory model bits are allowed.
 @end deftypefn
 @c hook-end
 
 @deftypevr {Target Hook} {unsigned char} TARGET_ATOMIC_TEST_AND_SET_TRUEVAL
-@c hook-start:TARGET_atomic_test_and_set_trueval
+@c hook-start: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}.
@@ -13279,7 +13279,7 @@ This value should be set if the result written by
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_HAS_IFUNC_P (void)
-@c hook-start:TARGET_has_ifunc_p
+@c hook-start:TARGET_HAS_IFUNC_P
 It returns true if the target supports GNU indirect functions.
 The support includes the assembler, linker and dynamic linker.
 The default value of this hook is based on target's libc.
@@ -13287,7 +13287,7 @@ The default value of this hook is based on target's libc.
 @c hook-end
 
 @deftypefn {Target Hook} {unsigned int} TARGET_ATOMIC_ALIGN_FOR_MODE (machine_mode @var{mode})
-@c hook-start:TARGET_atomic_align_for_mode
+@c hook-start:TARGET_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.
@@ -13295,7 +13295,7 @@ default alignment for the specified mode is used.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_ATOMIC_ASSIGN_EXPAND_FENV (tree *@var{hold}, tree *@var{clear}, tree *@var{update})
-@c hook-start:TARGET_atomic_assign_expand_fenv
+@c hook-start:TARGET_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.
@@ -13315,7 +13315,7 @@ as part of the code generated in @code{*@var{update}}.
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_RECORD_OFFLOAD_SYMBOL (tree)
-@c hook-start:TARGET_record_offload_symbol
+@c hook-start:TARGET_RECORD_OFFLOAD_SYMBOL
 Used when offloaded functions are seen in the compilation unit and no named
 sections are available.  It is called once for each symbol that must be
 recorded in the offload function and variable table.
@@ -13323,7 +13323,7 @@ recorded in the offload function and variable table.
 @c hook-end
 
 @deftypefn {Target Hook} {char *} TARGET_OFFLOAD_OPTIONS (void)
-@c hook-start:TARGET_offload_options
+@c hook-start:TARGET_OFFLOAD_OPTIONS
 Used when writing out the list of options into an LTO file.  It should
 translate any relevant target-specific options (such as the ABI in use)
 into one of the @option{-foffload} options that exist as a common interface
@@ -13380,7 +13380,7 @@ maintainer is familiar with.
 @end defmac
 
 @deftypefn {Target Hook} bool TARGET_HAVE_SPECULATION_SAFE_VALUE (bool @var{active})
-@c hook-start:TARGET_have_speculation_safe_value
+@c hook-start:TARGET_HAVE_SPECULATION_SAFE_VALUE
 This hook is used to determine the level of target support for
  @code{__builtin_speculation_safe_value}.  If called with an argument
  of false, it returns true if the target has been modified to support
@@ -13400,7 +13400,7 @@ This hook is used to determine the level of target support for
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_SPECULATION_SAFE_VALUE (machine_mode @var{mode}, rtx @var{result}, rtx @var{val}, rtx @var{failval})
-@c hook-start:TARGET_speculation_safe_value
+@c hook-start:TARGET_SPECULATION_SAFE_VALUE
 This target hook can be used to generate a target-specific code
  sequence that implements the @code{__builtin_speculation_safe_value}
  built-in function.  The function must always return @var{val} in
@@ -13420,13 +13420,13 @@ This target hook can be used to generate a target-specific code
 @c hook-end
 
 @deftypefn {Target Hook} void TARGET_RUN_TARGET_SELFTESTS (void)
-@c hook-start:TARGET_run_target_selftests
+@c hook-start:TARGET_RUN_TARGET_SELFTESTS
 If selftests are enabled, run any selftests for this target.
 @end deftypefn
 @c hook-end
 
 @deftypefn {Target Hook} bool TARGET_MEMTAG_CAN_TAG_ADDRESSES ()
-@c hook-start:TARGET_MEMTAG_can_tag_addresses
+@c hook-start:TARGET_MEMTAG_CAN_TAG_ADDRESSES
 True if the backend architecture naturally supports ignoring some region
 of pointers.  This feature means that @option{-fsanitize=hwaddress} can
 work.
@@ -13437,7 +13437,7 @@ At preset, this feature does not support address spaces.  It also requires
 @c hook-end
 
 @deftypefn {Target Hook} uint8_t TARGET_MEMTAG_TAG_SIZE ()
-@c hook-start:TARGET_MEMTAG_tag_size
+@c hook-start:TARGET_MEMTAG_TAG_SIZE
 Return the size of a tag (in bits) for this platform.
 
 The default returns 8.
@@ -13445,7 +13445,7 @@ The default returns 8.
 @c hook-end
 
 @deftypefn {Target Hook} uint8_t TARGET_MEMTAG_GRANULE_SIZE ()
-@c hook-start:TARGET_MEMTAG_granule_size
+@c hook-start:TARGET_MEMTAG_GRANULE_SIZE
 Return the size in real memory that each byte in shadow memory refers to.
 I.e. if a variable is @var{X} bytes long in memory, then this hook should
 return the value @var{Y} such that the tag in shadow memory spans
@@ -13460,7 +13460,7 @@ The default returns 16.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_MEMTAG_INSERT_RANDOM_TAG (rtx @var{untagged}, rtx @var{target})
-@c hook-start:TARGET_MEMTAG_insert_random_tag
+@c hook-start:TARGET_MEMTAG_INSERT_RANDOM_TAG
 Return an RTX representing the value of @var{untagged} but with a
 (possibly) random tag in it.
 Put that value into @var{target} if it is convenient to do so.
@@ -13469,7 +13469,7 @@ This function is used to generate a tagged base for the current stack frame.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_MEMTAG_ADD_TAG (rtx @var{base}, poly_int64 @var{addr_offset}, uint8_t @var{tag_offset})
-@c hook-start:TARGET_MEMTAG_add_tag
+@c hook-start:TARGET_MEMTAG_ADD_TAG
 Return an RTX that represents the result of adding @var{addr_offset} to
 the address in pointer @var{base} and @var{tag_offset} to the tag in pointer
 @var{base}.
@@ -13482,7 +13482,7 @@ RTL.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_MEMTAG_SET_TAG (rtx @var{untagged_base}, rtx @var{tag}, rtx @var{target})
-@c hook-start:TARGET_MEMTAG_set_tag
+@c hook-start:TARGET_MEMTAG_SET_TAG
 Return an RTX representing @var{untagged_base} but with the tag @var{tag}.
 Try and store this in @var{target} if convenient.
 @var{untagged_base} is required to have a zero tag when this hook is called.
@@ -13492,7 +13492,7 @@ The default of this hook is to set the top byte of @var{untagged_base} to
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_MEMTAG_EXTRACT_TAG (rtx @var{tagged_pointer}, rtx @var{target})
-@c hook-start:TARGET_MEMTAG_extract_tag
+@c hook-start:TARGET_MEMTAG_EXTRACT_TAG
 Return an RTX representing the tag stored in @var{tagged_pointer}.
 Store the result in @var{target} if it is convenient.
 The default represents the top byte of the original pointer.
@@ -13500,7 +13500,7 @@ The default represents the top byte of the original pointer.
 @c hook-end
 
 @deftypefn {Target Hook} rtx TARGET_MEMTAG_UNTAGGED_POINTER (rtx @var{tagged_pointer}, rtx @var{target})
-@c hook-start:TARGET_MEMTAG_untagged_pointer
+@c hook-start:TARGET_MEMTAG_UNTAGGED_POINTER
 Return an RTX representing @var{tagged_pointer} with its tag set to zero.
 Store the result in @var{target} if convenient.
 The default clears the top byte of the original pointer.
diff --git a/gcc/genhooks.c b/gcc/genhooks.c
index 15417d7..14faa70 100644
--- a/gcc/genhooks.c
+++ b/gcc/genhooks.c
@@ -232,7 +232,7 @@ emit_documentation (const char *in_fname)
 			  deftype, hook_array[j].docname,
 			  hook_array[j].type, namex);
 		}
-	      printf ("\n@c hook-start:%s", hook_array[i].name);
+	      printf ("\n@c hook-start:%s", upstrdup (hook_array[i].name));
 	      if (hook_array[i].doc[0])
 		{
 		  printf ("\n");