Patchwork RFA (middle-end): Fix PR other/44034

login
register
mail settings
Submitter Joern Rennecke
Date June 28, 2010, 7:46 p.m.
Message ID <20100628154608.qp5i7s17hcgcgwo8-nzlynne@webmail.spamcop.net>
Download mbox | patch
Permalink /patch/57184/
State New
Headers show

Comments

Joern Rennecke - June 28, 2010, 7:46 p.m.
Quoting Alexandre Oliva <aoliva@redhat.com>:

> I assume you're Cc:ing me as maintainer of the build machinery.

Yes.

> The
> changes to gcc/Makefile.in are fine, although I think it would be better
> for the message that follows to be sent to stderr rather than stdout:

Done.

I've also updated the patch to take the new register_move_cost hook into
account.

Bootstrapped & regression tested in trunk revision 161492 on
i686-pc-linux-gnu.

With Joseph S. Myers's review of documentation and c-frontend parts,
http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01816.html
http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01858.html

the one outstanding review area is the middle end.
2010-06-28  Joern Rennecke  <joern.rennecke@embecosm.com>

gcc:
	PR other/44034
	* target.def, doc/tm.texi.in, genhooks.c: New files.
	* target.h: Instead of defining individual hook members,
	define DEFHOOKPOD / DEFHOOK / DEFHOOK_UNDOC / HOOKSTRUCT and
	include target.def.
	* target-def.h: Instead of defining individual hook initializers,
	include target-hooks-def.h.
	* df-scan.c, haifa-sched.c, sel-sched.c: Rename targetm members:
	targetm.live_on_entry -> targetm.extra_live_on_entry
	targetm.sched.md_finish ->targetm.sched.finish
	targetm.sched.md_init -> targetm.sched.init
	targetm.sched.md_init_global -> targetm.sched.init_global
	targetm.asm_out.unwind_label -> targetm.asm_out.emit_unwind_label
	targetm.asm_out.except_table_label ->
	  targetm.asm_out.emit_except_table_label
	targetm.asm_out.visibility -> targetm.asm_out.assemble_visibility
	targetm.target_help -> targetm.help
	targetm.vectorize.builtin_support_vector_misalignment ->
	  targetm.vectorize.support_vector_misalignment
	targetm.file_start_app_off -> targetm.asm_file_start_app_off
	targetm.file_start_file_directive ->
	 targetm.asm_file_start_file_directive
	* dwarf2out.c, opts.c, tree-vect-data-refs.c, except.c: Likewise.
	* varasm.c, config/alpha/alpha.c, config/cris/cris.c: Likewise.
	* gcc/config/spu/spu.c, config/ia64/ia64.c: Rename target macros:
	TARGET_VECTOR_ALIGNMENT_REACHABLE ->
	  TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
	TARGET_SUPPORT_VECTOR_MISALIGNMENT ->
	  TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
	TARGET_UNWIND_EMIT -> TARGET_ASM_UNWIND_EMIT
	* config/rs6000/rs6000.c, config/arm/arm.c: Likewise.
	* Makefile.in (TARGET_H): Depend on target.def.
	(TARGET_DEF_H): Depend on target-hooks-def.h.
	(target-hooks-def.h, tm.texi, s-target-hooks-def-h): New rules.
	(s-tm-texi, build/genhooks.o, build/genhooks): Likewise.
	* doc/tm.texi: Regenerate.
gcc/c-family:
	* c-common.c: Rename targetm member:
	targetm.enum_va_list -> targetm.enum_va_list_p
gcc/po:
	* EXCLUDES: Add genhooks.c.
Richard Henderson - June 29, 2010, 5:24 p.m.
On 06/28/2010 12:46 PM, Joern Rennecke wrote:
> Quoting Alexandre Oliva <aoliva@redhat.com>:
> 
>> I assume you're Cc:ing me as maintainer of the build machinery.
> 
> Yes.
> 
>> The
>> changes to gcc/Makefile.in are fine, although I think it would be better
>> for the message that follows to be sent to stderr rather than stdout:
> 
> Done.
> 
> I've also updated the patch to take the new register_move_cost hook into
> account.
> 
> Bootstrapped & regression tested in trunk revision 161492 on
> i686-pc-linux-gnu.
> 
> With Joseph S. Myers's review of documentation and c-frontend parts,
> http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01816.html
> http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01858.html
> 
> the one outstanding review area is the middle end.

The patch is ok for the middle end.


r~
H.J. Lu - June 29, 2010, 7 p.m.
On Mon, Jun 28, 2010 at 12:46 PM, Joern Rennecke <amylaar@spamcop.net> wrote:
> Quoting Alexandre Oliva <aoliva@redhat.com>:
>
>> I assume you're Cc:ing me as maintainer of the build machinery.
>
> Yes.
>
>> The
>> changes to gcc/Makefile.in are fine, although I think it would be better
>> for the message that follows to be sent to stderr rather than stdout:
>
> Done.
>
> I've also updated the patch to take the new register_move_cost hook into
> account.
>
> Bootstrapped & regression tested in trunk revision 161492 on
> i686-pc-linux-gnu.
>
> With Joseph S. Myers's review of documentation and c-frontend parts,
> http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01816.html
> http://gcc.gnu.org/ml/gcc-patches/2010-06/msg01858.html
>
> the one outstanding review area is the middle end.
>
> 2010-06-28  Joern Rennecke  <joern.rennecke@embecosm.com>
>
> gcc:
>        PR other/44034
>        * target.def, doc/tm.texi.in, genhooks.c: New files.
>        * target.h: Instead of defining individual hook members,
>        define DEFHOOKPOD / DEFHOOK / DEFHOOK_UNDOC / HOOKSTRUCT and
>        include target.def.
>        * target-def.h: Instead of defining individual hook initializers,
>        include target-hooks-def.h.
>        * df-scan.c, haifa-sched.c, sel-sched.c: Rename targetm members:
>        targetm.live_on_entry -> targetm.extra_live_on_entry
>        targetm.sched.md_finish ->targetm.sched.finish
>        targetm.sched.md_init -> targetm.sched.init
>        targetm.sched.md_init_global -> targetm.sched.init_global
>        targetm.asm_out.unwind_label -> targetm.asm_out.emit_unwind_label
>        targetm.asm_out.except_table_label ->
>          targetm.asm_out.emit_except_table_label
>        targetm.asm_out.visibility -> targetm.asm_out.assemble_visibility
>        targetm.target_help -> targetm.help
>        targetm.vectorize.builtin_support_vector_misalignment ->
>          targetm.vectorize.support_vector_misalignment
>        targetm.file_start_app_off -> targetm.asm_file_start_app_off
>        targetm.file_start_file_directive ->
>         targetm.asm_file_start_file_directive
>        * dwarf2out.c, opts.c, tree-vect-data-refs.c, except.c: Likewise.
>        * varasm.c, config/alpha/alpha.c, config/cris/cris.c: Likewise.
>        * gcc/config/spu/spu.c, config/ia64/ia64.c: Rename target macros:
>        TARGET_VECTOR_ALIGNMENT_REACHABLE ->
>          TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
>        TARGET_SUPPORT_VECTOR_MISALIGNMENT ->
>          TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
>        TARGET_UNWIND_EMIT -> TARGET_ASM_UNWIND_EMIT
>        * config/rs6000/rs6000.c, config/arm/arm.c: Likewise.
>        * Makefile.in (TARGET_H): Depend on target.def.
>        (TARGET_DEF_H): Depend on target-hooks-def.h.
>        (target-hooks-def.h, tm.texi, s-target-hooks-def-h): New rules.
>        (s-tm-texi, build/genhooks.o, build/genhooks): Likewise.
>        * doc/tm.texi: Regenerate.
> gcc/c-family:
>        * c-common.c: Rename targetm member:
>        targetm.enum_va_list -> targetm.enum_va_list_p
> gcc/po:
>        * EXCLUDES: Add genhooks.c.
>

This patch caused:

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=44719

Patch

Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi	(revision 161494)
+++ gcc/doc/tm.texi	(working copy)
@@ -4423,8 +4423,7 @@  specially by the compiler and was not me
 compiled.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode
-@var{mode}, const_rtx @var{fun})
+@deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode @var{mode}, const_rtx @var{fun})
 Define this hook if the back-end needs to know the name of the libcall
 function in order to determine where the result should be returned.  
 
@@ -5742,7 +5741,7 @@  return type of the vectorized function s
 @var{vec_type_out} and the argument types should be @var{vec_type_in}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed})
+@deftypefn {Target Hook} bool TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed})
 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
@@ -8691,7 +8690,7 @@  to be broken up according to function.
 The default is that no label is emitted.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_UNWIND_EMIT (FILE *@var{stream}, rtx @var{insn})
+@deftypefn {Target Hook} void TARGET_ASM_UNWIND_EMIT (FILE *@var{stream}, rtx @var{insn})
 This target hook emits assembly directives required to unwind the
 given instruction.  This is only used when TARGET_UNWIND_INFO is set.
 @end deftypefn
@@ -8755,7 +8754,7 @@  default.
 
 @defmac TARGET_UNWIND_INFO
 Define this macro if your target has ABI specified unwind tables.  Usually
-these will be output by @code{TARGET_UNWIND_EMIT}.
+these will be output by @code{TARGET_ASM_UNWIND_EMIT}.
 @end defmac
 
 @deftypevr {Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
@@ -9626,9 +9625,7 @@  to perform initial processing of the @sa
 @end deftypefn
 
 @deftypefn {Target Hook} bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P (const_tree @var{decl})
-@var{decl} is a variable or function with @code{__attribute__((dllimport))}
-specified. Use this hook if the target needs to add extra validation
-checks to @code{handle_dll_attribute}.
+@var{decl} is a variable or function with @code{__attribute__((dllimport))} specified.  Use this hook if the target needs to add extra validation checks to @code{handle_dll_attribute}.
 @end deftypefn
 
 @defmac TARGET_DECLSPEC
@@ -9886,7 +9883,7 @@  This hook should return @code{true} if t
 array cookies.  The default is to return @code{false}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_CXX_IMPORT_EXPORT_CLASS (tree  @var{type}, int @var{import_export})
+@deftypefn {Target Hook} int TARGET_CXX_IMPORT_EXPORT_CLASS (tree @var{type}, int @var{import_export})
 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
@@ -9912,12 +9909,7 @@  method.  The default is to return @code{
 @end deftypefn
 
 @deftypefn {Target Hook} void TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY (tree @var{decl})
-@var{decl} is a virtual table, virtual table table, typeinfo object,
-or other similar implicit class data object that will be emitted with
-external linkage in this translation unit.  No ELF visibility has been
-explicitly specified.  If the target needs to specify a visibility
-other than that of the containing class, use this hook to set
-@code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.
+@var{decl} is a virtual table, virtual table table, typeinfo object, or other similar implicit class data object that will be emitted with external linkage in this translation unit.  No ELF visibility has been explicitly specified.  If the target needs to specify a visibility other than that of the containing class, use this hook to set @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.
 @end deftypefn
 
 @deftypefn {Target Hook} bool TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT (void)
@@ -9949,9 +9941,7 @@  unloaded. The default is to return false
 @end deftypefn
 
 @deftypefn {Target Hook} void TARGET_CXX_ADJUST_CLASS_AT_DEFINITION (tree @var{type})
-@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just been
-defined.  Use this hook to make adjustments to the class (eg, tweak
-visibility or perform any other required target modifications).
+@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just been defined.  Use this hook to make adjustments to the class (eg, tweak visibility or perform any other required target modifications).
 @end deftypefn
 
 @node Named Address Spaces
Index: gcc/doc/tm.texi.in
===================================================================
--- gcc/doc/tm.texi.in	(revision 161494)
+++ gcc/doc/tm.texi.in	(working copy)
@@ -718,7 +718,7 @@  This variable is declared in @file{optio
 any target-specific headers.
 @end deftypevar
 
-@deftypevr {Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
+@hook TARGET_DEFAULT_TARGET_FLAGS
 This variable specifies the initial value of @code{target_flags}.
 Its default setting is 0.
 @end deftypevr
@@ -726,7 +726,7 @@  Its default setting is 0.
 @cindex optional hardware or system features
 @cindex features, optional, in system conventions
 
-@deftypefn {Target Hook} bool TARGET_HANDLE_OPTION (size_t @var{code}, const char *@var{arg}, int @var{value})
+@hook TARGET_HANDLE_OPTION
 This hook is called whenever the user specifies one of the
 target-specific options described by the @file{.opt} definition files
 (@pxref{Options}).  It has the opportunity to do some option-specific
@@ -743,7 +743,7 @@  argument.  Otherwise @var{value} is 1 if
 option was used and 0 if the ``no-'' form was.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_HANDLE_C_OPTION (size_t @var{code}, const char *@var{arg}, int @var{value})
+@hook TARGET_HANDLE_C_OPTION
 This target hook is called whenever the user specifies one of the
 target-specific C language family options described by the @file{.opt}
 definition files(@pxref{Options}).  It has the opportunity to do some
@@ -788,7 +788,7 @@  changed via the optimize attribute or pr
 @code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
+@hook TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
 This target function is similar to the macro @code{OVERRIDE_OPTIONS}
 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
@@ -826,7 +826,7 @@  this macro!} The debugging options are n
 generated code.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_HELP (void)
+@hook TARGET_HELP
 This hook is called in response to the user invoking
 @option{--target-help} on the command line.  It gives the target a
 chance to display extra information on the target specific command
@@ -1022,7 +1022,7 @@  sign-extend the result to 64 bits.  On s
 Do not define this macro if it would never modify @var{m}.
 @end defmac
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_PROMOTE_FUNCTION_MODE (const_tree @var{type}, enum machine_mode @var{mode}, int *@var{punsignedp}, const_tree @var{funtype}, int @var{for_return})
+@hook 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
@@ -1308,14 +1308,14 @@  Like @code{PCC_BITFIELD_TYPE_MATTERS} ex
 to aligning a bit-field within the structure.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_ALIGN_ANON_BITFIELD (void)
+@hook 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
 the alignment requirements of an unnamed bitfield's type.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_NARROW_VOLATILE_BITFIELD (void)
+@hook 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.
@@ -1377,21 +1377,21 @@  You would most commonly define this macr
 pattern needs to support both a 32- and a 64-bit mode.
 @end defmac
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_LIBGCC_CMP_RETURN_MODE (void)
+@hook 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
 targets.
 @end deftypefn
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_LIBGCC_SHIFT_COUNT_MODE (void)
+@hook 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
 targets.
 @end deftypefn
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_UNWIND_WORD_MODE (void)
+@hook 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
@@ -1417,7 +1417,7 @@  floating-point arithmetic.
 The default definition of this macro returns false for all sizes.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_MS_BITFIELD_LAYOUT_P (const_tree @var{record_type})
+@hook 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
@@ -1445,15 +1445,15 @@  precedence for that field, but the align
 may affect its placement.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_DECIMAL_FLOAT_SUPPORTED_P (void)
+@hook TARGET_DECIMAL_FLOAT_SUPPORTED_P
 Returns true if the target supports decimal floating point.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_FIXED_POINT_SUPPORTED_P (void)
+@hook TARGET_FIXED_POINT_SUPPORTED_P
 Returns true if the target supports fixed-point arithmetic.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_EXPAND_TO_RTL_HOOK (void)
+@hook 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
@@ -1462,12 +1462,12 @@  registers whenever the function being ex
 usage.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_INSTANTIATE_DECLS (void)
+@hook 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
 
-@deftypefn {Target Hook} {const char *} TARGET_MANGLE_TYPE (const_tree @var{type})
+@hook 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++
@@ -1684,7 +1684,7 @@  always override this default with the op
 and @option{-funsigned-char}.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_DEFAULT_SHORT_ENUMS (void)
+@hook 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
@@ -2243,7 +2243,7 @@  possible since doing so will allow GCC t
 allocation.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_HARD_REGNO_SCRATCH_OK (unsigned int @var{regno})
+@hook 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.
 
@@ -2645,7 +2645,7 @@  Don't define this macro unless the targe
 require the macro to do something nontrivial.
 @end defmac
 
-@deftypefn {Target Hook} {enum reg_class} TARGET_SECONDARY_RELOAD (bool @var{in_p}, rtx @var{x}, enum reg_class @var{reload_class}, enum machine_mode @var{reload_mode}, secondary_reload_info *@var{sri})
+@hook 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
@@ -2885,7 +2885,7 @@  as below:
 @end smallexample
 @end defmac
 
-@deftypefn {Target Hook} {const enum reg_class *} TARGET_IRA_COVER_CLASSES (void)
+@hook TARGET_IRA_COVER_CLASSES
 Return an array of cover classes for the Integrated Register Allocator
 (@acronym{IRA}).  Cover classes are a set of non-intersecting register
 classes covering all hard registers used for register allocation
@@ -3202,7 +3202,7 @@  before we can access arbitrary stack fra
 define this macro.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_BUILTIN_SETJMP_FRAME_VALUE (void)
+@hook 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
@@ -3269,7 +3269,7 @@  someone decided it was a good idea to us
 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})
+@hook 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
@@ -3654,7 +3654,7 @@  If the static chain is passed in memory,
 defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_STATIC_CHAIN (const_tree @var{fndecl}, bool @var{incoming_p})
+@hook 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
@@ -3738,7 +3738,7 @@  return @code{@var{regno}}.
 @c prevent bad page break with this line
 This is about eliminating the frame pointer and arg pointer.
 
-@deftypefn {Target Hook} bool TARGET_FRAME_POINTER_REQUIRED (void)
+@hook 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.
@@ -3804,7 +3804,7 @@  Note that the elimination of the argumen
 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})
+@hook TARGET_CAN_ELIMINATE
 This target hook should returns @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 need only be defined if @code{ELIMINABLE_REGS}
@@ -3831,7 +3831,7 @@  The macros in this section control how a
 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})
+@hook 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
@@ -4046,7 +4046,7 @@  defined, the argument will be computed i
 a register.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_MUST_PASS_IN_STACK (enum machine_mode @var{mode}, const_tree @var{type})
+@hook TARGET_MUST_PASS_IN_STACK
 This target hook should return @code{true} if we should not pass @var{type}
 solely in registers.  The file @file{expr.h} defines a
 definition that is usually appropriate, refer to @file{expr.h} for additional
@@ -4068,7 +4068,7 @@  If @code{FUNCTION_INCOMING_ARG} is not d
 serves both purposes.
 @end defmac
 
-@deftypefn {Target Hook} int TARGET_ARG_PARTIAL_BYTES (CUMULATIVE_ARGS *@var{cum}, enum machine_mode @var{mode}, tree @var{type}, bool @var{named})
+@hook 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
@@ -4099,7 +4099,7 @@  The pointer is passed in whatever way is
 to that type.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CALLEE_COPIES (CUMULATIVE_ARGS *@var{cum}, enum machine_mode @var{mode}, const_tree @var{type}, bool @var{named})
+@hook 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
@@ -4248,7 +4248,7 @@  used for this purpose since all function
 stack.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_SPLIT_COMPLEX_ARG (const_tree @var{type})
+@hook 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
@@ -4261,7 +4261,7 @@  The default value of this hook is @code{
 false.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_BUILD_BUILTIN_VA_LIST (void)
+@hook 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
@@ -4280,32 +4280,32 @@  Otherwise the @var{IDX} should be increa
 macro to iterate through all types.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_FN_ABI_VA_LIST (tree @var{fndecl})
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_CANONICAL_VA_LIST_TYPE (tree @var{type})
+@hook 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}.
 @end deftypefn
 
-@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})
+@hook 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
 @code{gimplify.c:gimplify_expr}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VALID_POINTER_MODE (enum machine_mode @var{mode})
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SCALAR_MODE_SUPPORTED_P (enum machine_mode @var{mode})
+@hook 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
@@ -4317,13 +4317,13 @@  Included here are the double-word arithm
 code in @file{optabs.c}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VECTOR_MODE_SUPPORTED_P (enum machine_mode @var{mode})
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P (enum machine_mode @var{mode})
+@hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
 Define this to return nonzero for machine modes for which the port has
 small register classes.  If this target hook returns nonzero for a given
 @var{mode}, the compiler will try to minimize the lifetime of registers
@@ -4364,7 +4364,7 @@  of spill registers and print a fatal err
 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})
+@hook 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
@@ -4423,8 +4423,7 @@  specially by the compiler and was not me
 compiled.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode
-@var{mode}, const_rtx @var{fun})
+@hook TARGET_LIBCALL_VALUE
 Define this hook if the back-end needs to know the name of the libcall
 function in order to determine where the result should be returned.  
 
@@ -4456,7 +4455,7 @@  This macro has been deprecated.  Use @co
 for a new target instead.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_FUNCTION_VALUE_REGNO_P (const unsigned int @var{regno})
+@hook 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.
 
@@ -4477,7 +4476,7 @@  need more space than is implied by @code
 saving and restoring an arbitrary return value.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_RETURN_IN_MSB (const_tree @var{type})
+@hook 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}
@@ -4507,7 +4506,7 @@  address}.
 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})
+@hook 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}
@@ -4537,7 +4536,7 @@  target hook.
 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})
+@hook 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
@@ -4606,7 +4605,7 @@  will select the smallest suitable mode.
 This section describes the macros that output function entry
 (@dfn{prologue}) and exit (@dfn{epilogue}) code.
 
-@deftypefn {Target Hook} void TARGET_ASM_FUNCTION_PROLOGUE (FILE *@var{file}, HOST_WIDE_INT @var{size})
+@hook 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
@@ -4651,21 +4650,21 @@  or by a debugger, there is no reason why
 need agree with that used by other compilers for a machine.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_FUNCTION_END_PROLOGUE (FILE *@var{file})
+@hook 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
 emitted.  @xref{prologue instruction pattern}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_FUNCTION_BEGIN_EPILOGUE (FILE *@var{file})
+@hook 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
 emitted.  @xref{epilogue instruction pattern}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_FUNCTION_EPILOGUE (FILE *@var{file}, HOST_WIDE_INT @var{size})
+@hook 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
@@ -4804,7 +4803,7 @@  You need not define this macro if you di
 @code{DELAY_SLOTS_FOR_EPILOGUE}.
 @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})
+@hook 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,
@@ -4846,7 +4845,7 @@  front end will generate a less efficient
 not support varargs.
 @end deftypefn
 
-@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})
+@hook 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
@@ -4899,7 +4898,7 @@  the function prologue.  Normally, the pr
 @subsection Permitting tail calls
 @cindex tail calls
 
-@deftypefn {Target Hook} bool TARGET_FUNCTION_OK_FOR_SIBCALL (tree @var{decl}, tree @var{exp})
+@hook 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.
@@ -4912,7 +4911,7 @@  as the @code{sibcall} md pattern can not
 may vary greatly between different architectures.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_EXTRA_LIVE_ON_ENTRY (bitmap @var{regs})
+@hook 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
@@ -4925,7 +4924,7 @@  FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM
 @subsection Stack smashing protection
 @cindex stack smashing protection
 
-@deftypefn {Target Hook} tree TARGET_STACK_PROTECT_GUARD (void)
+@hook 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
@@ -4936,7 +4935,7 @@  The default version of this hook creates
 @samp{__stack_chk_guard}, which is normally defined in @file{libgcc2.c}.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_STACK_PROTECT_FAIL (void)
+@hook TARGET_STACK_PROTECT_FAIL
 This hook returns a tree expression that alerts the runtime that the
 stack protect guard variable has been modified.  This expression should
 involve a call to a @code{noreturn} function.
@@ -5039,7 +5038,7 @@  interpret the values of @code{__builtin_
 
 These machine description macros help implement varargs:
 
-@deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN_SAVEREGS (void)
+@hook 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
@@ -5047,7 +5046,7 @@  return value of this function should be 
 to use as the return of @code{__builtin_saveregs}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SETUP_INCOMING_VARARGS (CUMULATIVE_ARGS *@var{args_so_far}, enum machine_mode @var{mode}, tree @var{type}, int *@var{pretend_args_size}, int @var{second_time})
+@hook 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
@@ -5081,7 +5080,7 @@  end of the source file.  The hook @code{
 not generate any instructions in this case.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_STRICT_ARGUMENT_NAMING (CUMULATIVE_ARGS *@var{ca})
+@hook 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.
 
@@ -5096,7 +5095,7 @@  except the last are treated as named.
 You need not define this hook if it always returns @code{false}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED (CUMULATIVE_ARGS *@var{ca})
+@hook 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
@@ -5133,7 +5132,7 @@  proper offset from the start of the tram
 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})
+@hook 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
@@ -5161,7 +5160,7 @@  If you don't define this macro, the valu
 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})
+@hook 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
@@ -5180,7 +5179,7 @@  enabling stack execution, these actions 
 initializing the trampoline proper.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_TRAMPOLINE_ADJUST_ADDRESS (rtx @var{addr})
+@hook 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
@@ -5261,7 +5260,7 @@  are ABI-mandated names that the compiler
 
 @findex set_optab_libfunc
 @findex init_one_libfunc
-@deftypefn {Target Hook} void TARGET_INIT_LIBFUNCS (void)
+@hook 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}.
@@ -5418,7 +5417,7 @@  the maximum number that @code{TARGET_LEG
 accept.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode}, rtx @var{x}, bool @var{strict})
+@hook 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}.
 
@@ -5502,7 +5501,7 @@  The typical use of this macro is to hand
 a label_ref or symbol_ref within an UNSPEC@.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode})
+@hook 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.
@@ -5572,7 +5571,7 @@  It is not necessary for this macro to co
 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})
+@hook TARGET_MODE_DEPENDENT_ADDRESS_P
 This hook returns @code{true} if memory address @var{addr} can have
 different meanings depending on the machine mode of the memory
 reference it is used for or if the address is valid for some modes
@@ -5614,7 +5613,7 @@  an immediate operand on the target machi
 anything @code{CONSTANT_P} is valid.
 @end defmac
 
-@deftypefn {Target Hook} rtx TARGET_DELEGITIMIZE_ADDRESS (rtx @var{x})
+@hook TARGET_DELEGITIMIZE_ADDRESS
 This hook is used to undo the possibly obfuscating effects of the
 @code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target
 macros.  Some backend implementations of these macros wrap symbol
@@ -5624,7 +5623,7 @@  the semantics of these opaque @code{UNSP
 into their original form.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CANNOT_FORCE_CONST_MEM (rtx @var{x})
+@hook TARGET_CANNOT_FORCE_CONST_MEM
 This hook should return true if @var{x} is of a form that cannot (or
 should not) be spilled to the constant pool.  The default version of
 this hook returns false.
@@ -5636,7 +5635,7 @@  holding the constant.  This restriction 
 of TLS symbols for various targets.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_USE_BLOCKS_FOR_CONSTANT_P (enum machine_mode @var{mode}, const_rtx @var{x})
+@hook 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}.
@@ -5654,7 +5653,7 @@  of a square root function are performed,
 function are valid.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD (void)
+@hook 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
@@ -5683,7 +5682,7 @@  the argument @var{OFF} to @code{REALIGN_
 log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN (tree @var{x})
+@hook TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
 This hook should return the DECL of a function @var{f} that implements
 widening multiplication of the even elements of two input vectors of type @var{x}.
 
@@ -5694,7 +5693,7 @@  preserved (e.g.@: used only by a reducti
 @code{widen_mult_hi/lo} idioms will be used.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD (tree @var{x})
+@hook TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
 This hook should return the DECL of a function @var{f} that implements
 widening multiplication of the odd elements of two input vectors of type @var{x}.
 
@@ -5705,23 +5704,23 @@  preserved (e.g.@: used only by a reducti
 @code{widen_mult_hi/lo} idioms will be used.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST (enum vect_cost_for_stmt @var{type_of_cost})
+@hook TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
 Returns cost of different scalar or vector statements for vectorization cost model.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE (const_tree @var{type}, bool @var{is_packed})
+@hook TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
 Return true if vector alignment is reachable (by peeling N iterations) for the given type.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_VEC_PERM (tree @var{type}, tree *@var{mask_element_type})
+@hook TARGET_VECTORIZE_BUILTIN_VEC_PERM
 Target builtin that implements vector permute.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK (tree @var{vec_type}, tree @var{mask})
+@hook TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK
 Return true if a vector created for @code{builtin_vec_perm} is valid.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_CONVERSION (unsigned @var{code}, tree @var{dest_type}, tree @var{src_type})
+@hook TARGET_VECTORIZE_BUILTIN_CONVERSION
 This hook should return the DECL of a function that implements conversion of the
 input vector of type @var{src_type} to type @var{dest_type}.
 The value of @var{code} is one of the enumerators in @code{enum tree_code} and
@@ -5733,7 +5732,7 @@  If this hook is defined, the autovectori
 conversion. Otherwise, it will return @code{NULL_TREE}.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION (tree @var{fndecl}, tree @var{vec_type_out}, tree @var{vec_type_in})
+@hook TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
 This hook should return the decl of a function that implements the
 vectorized variant of the builtin function with builtin function code
 @var{code} or @code{NULL_TREE} if such a function is not available.
@@ -5742,7 +5741,7 @@  return type of the vectorized function s
 @var{vec_type_out} and the argument types should be @var{vec_type_in}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, const_tree @var{type}, int @var{misalignment}, bool @var{is_packed})
+@hook 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
@@ -5785,20 +5784,20 @@  in order to make effective use of sectio
 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
+@hook 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
 for every mode.  The default value is 0.
 @end deftypevr
 
-@deftypevr {Target Hook} HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET
+@hook 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.
 @end deftypevr
 
-@deftypefn {Target Hook} void TARGET_ASM_OUTPUT_ANCHOR (rtx @var{x})
+@hook 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
@@ -5810,7 +5809,7 @@  If @code{ASM_OUTPUT_DEF} is not availabl
 is @code{NULL}, which disables the use of section anchors altogether.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_USE_ANCHORS_FOR_SYMBOL_P (const_rtx @var{x})
+@hook 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})}.
@@ -6039,7 +6038,7 @@  like:
 @end smallexample
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_FIXED_CONDITION_CODE_REGS (unsigned int *@var{p1}, unsigned int *@var{p2})
+@hook TARGET_FIXED_CONDITION_CODE_REGS
 On targets which do not use @code{(cc0)}, and 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
@@ -6054,7 +6053,7 @@  integer pointed to by @var{p2} should be
 The default version of this hook returns false.
 @end deftypefn
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_CC_MODES_COMPATIBLE (enum machine_mode @var{m1}, enum machine_mode @var{m2})
+@hook 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
@@ -6121,7 +6120,7 @@  These macros are obsolete, new ports sho
 @code{TARGET_REGISTER_MOVE_COST} instead.
 @end defmac
 
-@deftypefn {Target Hook} int TARGET_REGISTER_MOVE_COST (enum machine_mode @var{mode}, enum reg_class @var{from}, enum reg_class @var{to})
+@hook 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}.
@@ -6376,7 +6375,7 @@  Define this macro if a non-short-circuit
 @code{BRANCH_COST} is greater than or equal to the value 2.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, int @var{code}, int @var{outer_code}, int *@var{total}, bool @var{speed})
+@hook 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
@@ -6403,7 +6402,7 @@  The hook returns true when all subexpres
 processed, and false when @code{rtx_cost} should recurse.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address}, bool @var{speed})
+@hook 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.
@@ -6446,7 +6445,7 @@  adjustment in order to produce good code
 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)
+@hook 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
@@ -6458,7 +6457,7 @@  it to vary depending on what the instruc
 @samp{TARGET_SCHED_VARIABLE_ISSUE}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_VARIABLE_ISSUE (FILE *@var{file}, int @var{verbose}, rtx @var{insn}, int @var{more})
+@hook 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
@@ -6472,7 +6471,7 @@  debug output to.  @var{verbose} is the v
 was scheduled.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_ADJUST_COST (rtx @var{insn}, rtx @var{link}, rtx @var{dep_insn}, int @var{cost})
+@hook TARGET_SCHED_ADJUST_COST
 This function corrects the value of @var{cost} based on the
 relationship between @var{insn} and @var{dep_insn} through the
 dependence @var{link}.  It should return the new value.  The default
@@ -6487,7 +6486,7 @@  acceptable, you could use the hook to mo
 @pxref{Processor pipeline description}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_ADJUST_PRIORITY (rtx @var{insn}, int @var{priority})
+@hook 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}
@@ -6495,7 +6494,7 @@  later.  Do not define this hook if you d
 scheduling priorities of insns.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_REORDER (FILE *@var{file}, int @var{verbose}, rtx *@var{ready}, int *@var{n_readyp}, int @var{clock})
+@hook 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).
@@ -6512,7 +6511,7 @@  can issue this cycle; normally this is j
 @samp{TARGET_SCHED_REORDER2}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_REORDER2 (FILE *@var{file}, int @var{verbose}, rtx *@var{ready}, int *@var{n_readyp}, int @var{clock})
+@hook 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
@@ -6523,7 +6522,7 @@  scheduling one insn causes other insns t
 cycle.  These other insns can then be taken into account properly.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK (rtx @var{head}, rtx @var{tail})
+@hook 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
@@ -6533,7 +6532,7 @@  dependencies of the insn scheduler becau
 calculated.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_INIT (FILE *@var{file}, int @var{verbose}, int @var{max_ready})
+@hook 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}
@@ -6543,7 +6542,7 @@  region that can be live at the same time
 scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_FINISH (FILE *@var{file}, int @var{verbose})
+@hook 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}
@@ -6552,20 +6551,20 @@  to.  @var{verbose} is the verbose level 
 @option{-fsched-verbose-@var{n}}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_INIT_GLOBAL (FILE *@var{file}, int @var{verbose}, int @var{old_max_uid})
+@hook 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}}.
 @var{old_max_uid} is the maximum insn uid when scheduling begins.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_FINISH_GLOBAL (FILE *@var{file}, int @var{verbose})
+@hook 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}}.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_SCHED_DFA_PRE_CYCLE_INSN (void)
+@hook 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
@@ -6575,36 +6574,36 @@  based pipeline description.  The default
 when the new simulated processor cycle starts.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN (void)
+@hook TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN
 The hook can be used to initialize data used by the previous hook.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_SCHED_DFA_POST_CYCLE_INSN (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN (void)
+@hook 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
 
-@deftypefn {Target Hook} void TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE (void)
+@hook 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
 state on a single insn is not enough.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_DFA_POST_ADVANCE_CYCLE (void)
+@hook 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
 state on a single insn is not enough.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD (void)
+@hook 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
@@ -6633,7 +6632,7 @@  schedules to choose the best one.
 The default is no multipass scheduling.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD (rtx @var{insn})
+@hook 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
@@ -6657,7 +6656,7 @@  processor cycle on which the previous in
 and the current processor cycle.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SCHED_IS_COSTLY_DEPENDENCE (struct _dep *@var{_dep}, int @var{cost}, int @var{distance})
+@hook 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
@@ -6678,35 +6677,35 @@  closer to one another---i.e., closer tha
 not in cases of ``costly dependences'', which this hooks allows to define.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_H_I_D_EXTENDED (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} {void *} TARGET_SCHED_ALLOC_SCHED_CONTEXT (void)
+@hook TARGET_SCHED_ALLOC_SCHED_CONTEXT
 Return a pointer to a store large enough to hold target scheduling context.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_INIT_SCHED_CONTEXT (void *@var{tc}, bool @var{clean_p})
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_SET_SCHED_CONTEXT (void *@var{tc})
+@hook TARGET_SCHED_SET_SCHED_CONTEXT
 Copy target scheduling context pointed to by @var{tc} to the current context.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_CLEAR_SCHED_CONTEXT (void *@var{tc})
+@hook TARGET_SCHED_CLEAR_SCHED_CONTEXT
 Deallocate internal data in target scheduling context pointed to by @var{tc}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_FREE_SCHED_CONTEXT (void *@var{tc})
+@hook TARGET_SCHED_FREE_SCHED_CONTEXT
 Deallocate a store for target scheduling context pointed to by @var{tc}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_SPECULATE_INSN (rtx @var{insn}, int @var{request}, rtx *@var{new_pat})
+@hook 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
@@ -6717,13 +6716,13 @@  speculation.  If the return value equals
 the generated speculative pattern.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SCHED_NEEDS_BLOCK_P (int @var{dep_status})
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_SCHED_GEN_SPEC_CHECK (rtx @var{insn}, rtx @var{label}, int @var{mutate_p})
+@hook 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.
@@ -6734,7 +6733,7 @@  a pattern for a branchy check correspond
 @var{insn} should be generated.  In this case @var{label} can't be null.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC (const_rtx @var{insn})
+@hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC
 This hook is used as a workaround for
 @samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD} not being
 called on the first instruction of the ready list.  The hook is used to
@@ -6747,14 +6746,14 @@  the hook is used to cancel data speculat
 is nearly full.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SCHED_SET_SCHED_FLAGS (struct spec_info_def *@var{spec_info})
+@hook 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.
 The structure describes speculation types that can be used in the scheduler.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_SCHED_SMS_RES_MII (struct ddg *@var{g})
+@hook 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
@@ -6938,7 +6937,7 @@  readonly data section is used.
 This macro is irrelevant if there is no separate readonly data section.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_INIT_SECTIONS (void)
+@hook 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.
@@ -6948,7 +6947,7 @@  any assembly code, and before calling an
 described below.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_ASM_RELOC_RW_MASK (void)
+@hook 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
@@ -6960,7 +6959,7 @@  when the target cannot support (some kin
 in read-only sections even in executables.
 @end deftypefn
 
-@deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_SECTION (tree @var{exp}, int @var{reloc}, unsigned HOST_WIDE_INT @var{align})
+@hook 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}
@@ -6983,7 +6982,7 @@  function has been determined to be likel
 it is unlikely to be called.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_UNIQUE_SECTION (tree @var{decl}, int @var{reloc})
+@hook 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
@@ -6995,7 +6994,7 @@  example, the function @code{foo} would b
 Whatever the actual target object format, this is often good enough.
 @end deftypefn
 
-@deftypefn {Target Hook} {section *} TARGET_ASM_FUNCTION_RODATA_SECTION (tree @var{decl})
+@hook TARGET_ASM_FUNCTION_RODATA_SECTION
 Return the readonly data section associated with
 @samp{DECL_SECTION_NAME (@var{decl})}.
 The default version of this function selects @code{.gnu.linkonce.r.name} if
@@ -7004,7 +7003,7 @@  if function is in @code{.text.name}, and
 otherwise.
 @end deftypefn
 
-@deftypefn {Target Hook} {section *} TARGET_ASM_SELECT_RTX_SECTION (enum machine_mode @var{mode}, rtx @var{x}, unsigned HOST_WIDE_INT @var{align})
+@hook TARGET_ASM_SELECT_RTX_SECTION
 Return the section into which a constant @var{x}, of mode @var{mode},
 should be placed.  You can assume that @var{x} is some kind of
 constant in RTL@.  The argument @var{mode} is redundant except in the
@@ -7016,7 +7015,7 @@  constants in @code{flag_pic} mode in @co
 else in @code{readonly_data_section}.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_MANGLE_DECL_ASSEMBLER_NAME (tree @var{decl}, tree @var{id})
+@hook 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,
@@ -7026,7 +7025,7 @@  your target system.  The default impleme
 returns the @var{id} provided.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ENCODE_SECTION_INFO (tree @var{decl}, rtx @var{rtl}, int @var{new_decl_p})
+@hook 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).
@@ -7064,23 +7063,23 @@  in @file{varasm.c}, sets a number of com
 before overriding it.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_STRIP_NAME_ENCODING (const char *@var{name})
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_IN_SMALL_DATA_P (const_tree @var{exp})
+@hook 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
 
-@deftypevr {Target Hook} bool TARGET_HAVE_SRODATA_SECTION
+@hook 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
 
-@deftypefn {Target Hook} bool TARGET_BINDS_LOCAL_P (const_tree @var{exp})
+@hook 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).
@@ -7090,7 +7089,7 @@  for ELF, which has a looser model of glo
 currently supported object file formats.
 @end deftypefn
 
-@deftypevr {Target Hook} bool TARGET_HAVE_TLS
+@hook TARGET_HAVE_TLS
 Contains the value true if the target supports thread-local storage.
 The default value is false.
 @end deftypevr
@@ -7172,7 +7171,7 @@  instructions do.
 This describes the overall framework of an assembly file.
 
 @findex default_file_start
-@deftypefn {Target Hook} void TARGET_ASM_FILE_START (void)
+@hook 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
@@ -7181,7 +7180,7 @@  quite unusual, if you override the defau
 lets other target files rely on these variables.
 @end deftypefn
 
-@deftypevr {Target Hook} bool TARGET_ASM_FILE_START_APP_OFF
+@hook 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
@@ -7195,14 +7194,14 @@  verified that your port does not generat
 comments that will cause GAS to issue errors in NO_APP mode.
 @end deftypevr
 
-@deftypevr {Target Hook} bool TARGET_ASM_FILE_START_FILE_DIRECTIVE
+@hook 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
 this to be done.  The default is false.
 @end deftypevr
 
-@deftypefn {Target Hook} void TARGET_ASM_FILE_END (void)
+@hook 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
@@ -7216,19 +7215,19 @@  need to do other things in that hook, ha
 this function.
 @end deftypefun
 
-@deftypefn {Target Hook} void TARGET_ASM_LTO_START (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_LTO_END (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_CODE_END (void)
+@hook 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,
@@ -7280,7 +7279,7 @@  A C statement to output something to the
 macro is not defined, nothing is output for a @samp{#ident} directive.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_NAMED_SECTION (const char *@var{name}, unsigned int @var{flags}, tree @var{decl})
+@hook 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}
@@ -7288,18 +7287,18 @@  is non-NULL, it is the @code{VAR_DECL} o
 this section is associated.
 @end deftypefn
 
-@deftypevr {Target Hook} bool TARGET_HAVE_NAMED_SECTIONS
+@hook TARGET_HAVE_NAMED_SECTIONS
 This flag is true if the target supports @code{TARGET_ASM_NAMED_SECTION}.
 @end deftypevr
 
 @anchor{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS}
-@deftypevr {Target Hook} bool TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
+@hook 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.
 @end deftypevr
 
-@deftypefn {Target Hook} {unsigned int} TARGET_SECTION_TYPE_FLAGS (tree @var{decl}, const char *@var{name}, int @var{reloc})
+@hook 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
@@ -7311,7 +7310,7 @@  need to override this if your target has
 set via @code{__attribute__}.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_ASM_RECORD_GCC_SWITCHES (print_switch_type @var{type}, const char *@var{text})
+@hook TARGET_ASM_RECORD_GCC_SWITCHES
 Provides the target with the ability to record the gcc command line
 switches that have been passed to the compiler, and options that are
 enabled.  The @var{type} argument specifies what is being recorded.
@@ -7357,7 +7356,7 @@  provided by the @code{TARGET_ASM_RECORD_
 hook.
 @end deftypefn
 
-@deftypevr {Target Hook} {const char *} TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
+@hook 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.
@@ -7368,7 +7367,7 @@  hook.
 @subsection Output of Data
 
 
-@deftypevr {Target Hook} {const char *} TARGET_ASM_BYTE_OP
+@hook TARGET_ASM_BYTE_OP
 @deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_HI_OP
 @deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_SI_OP
 @deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_DI_OP
@@ -7388,7 +7387,7 @@  followed immediately by the object's ini
 the string should contain a tab, a pseudo-op, and then another tab.
 @end deftypevr
 
-@deftypefn {Target Hook} bool TARGET_ASM_INTEGER (rtx @var{x}, unsigned int @var{size}, int @var{aligned_p})
+@hook 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
@@ -7500,8 +7499,7 @@  If you do not define this macro, the def
 the character @samp{;} is treated as a logical line separator.
 @end defmac
 
-@deftypevr {Target Hook} {const char *} TARGET_ASM_OPEN_PAREN
-@deftypevrx {Target Hook} {const char *} TARGET_ASM_CLOSE_PAREN
+@hook 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.
@@ -7816,7 +7814,7 @@  You may wish to use @code{ASM_OUTPUT_SIZ
 @code{ASM_OUTPUT_MEASURED_SIZE} in the definition of this macro.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_GLOBALIZE_LABEL (FILE *@var{stream}, const char *@var{name})
+@hook 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.
@@ -7825,7 +7823,7 @@  The default implementation relies on a p
 @code{GLOBAL_ASM_OP}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_GLOBALIZE_DECL_NAME (FILE *@var{stream}, tree @var{decl})
+@hook 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.
@@ -7894,7 +7892,7 @@  setting the @code{DECL_ONE_ONLY} flag is
 be emitted as one-only.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_ASSEMBLE_VISIBILITY (tree @var{decl}, int @var{visibility})
+@hook 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}.
@@ -7930,13 +7928,13 @@  This macro need not be defined if it doe
 The GNU assembler and most Unix assemblers don't require anything.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_EXTERNAL_LIBCALL (rtx @var{symref})
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_MARK_DECL_PRESERVED (const char *@var{symbol})
+@hook 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.
@@ -7968,7 +7966,7 @@  when it is necessary to output a label d
 being taken.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_INTERNAL_LABEL (FILE *@var{stream}, const char *@var{prefix}, unsigned long @var{labelno})
+@hook 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}.
 
@@ -8307,13 +8305,13 @@  of objects.  If zero, the compiler will 
 encountering an @code{init_priority} attribute.
 @end defmac
 
-@deftypevr {Target Hook} bool TARGET_HAVE_CTORS_DTORS
+@hook 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}.
 @end deftypevr
 
-@deftypefn {Target Hook} void TARGET_ASM_CONSTRUCTOR (rtx @var{symbol}, int @var{priority})
+@hook TARGET_ASM_CONSTRUCTOR
 If defined, a function that outputs assembler code to arrange to call
 the function referenced by @var{symbol} at initialization time.
 
@@ -8328,7 +8326,7 @@  target defines @code{CTORS_SECTION_ASM_O
 is not defined.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_DESTRUCTOR (rtx @var{symbol}, int @var{priority})
+@hook TARGET_ASM_DESTRUCTOR
 This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination
 functions rather than initialization functions.
 @end deftypefn
@@ -8453,7 +8451,7 @@  writing conditional output routines in t
 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 @var{insn}, rtx *@var{opvec}, int @var{noperands})
+@hook 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.
@@ -8671,7 +8669,7 @@  If this macro is not defined, nothing sp
 the jump-table.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_ASM_EMIT_UNWIND_LABEL (FILE *@var{stream}, tree @var{decl}, int @var{for_eh}, int @var{empty})
+@hook 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
@@ -8683,7 +8681,7 @@  true if this is a placeholder label for 
 The default is that FDEs are not given nonlocal labels.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL (FILE *@var{stream})
+@hook 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.
@@ -8691,7 +8689,7 @@  to be broken up according to function.
 The default is that no label is emitted.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_UNWIND_EMIT (FILE *@var{stream}, rtx @var{insn})
+@hook TARGET_ASM_UNWIND_EMIT
 This target hook emits assembly directives required to unwind the
 given instruction.  This is only used when TARGET_UNWIND_INFO is set.
 @end deftypefn
@@ -8755,10 +8753,10 @@  default.
 
 @defmac TARGET_UNWIND_INFO
 Define this macro if your target has ABI specified unwind tables.  Usually
-these will be output by @code{TARGET_UNWIND_EMIT}.
+these will be output by @code{TARGET_ASM_UNWIND_EMIT}.
 @end defmac
 
-@deftypevr {Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
+@hook TARGET_UNWIND_TABLES_DEFAULT
 This variable should be set to @code{true} if the target ABI requires unwinding
 tables even when exceptions are not used.
 @end deftypevr
@@ -8785,14 +8783,14 @@  minimum alignment otherwise.  @xref{SDB 
 the target supports DWARF 2 frame unwind information.
 @end defmac
 
-@deftypevr {Target Hook} bool TARGET_TERMINATE_DW2_EH_FRAME_INFO
+@hook 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
 true otherwise.
 @end deftypevr
 
-@deftypefn {Target Hook} rtx TARGET_DWARF_REGISTER_SPAN (rtx @var{reg})
+@hook 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
@@ -8801,7 +8799,7 @@  register in Dwarf.  Otherwise, this hook
 If not defined, the default is to return @code{NULL_RTX}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_INIT_DWARF_REG_SIZES_EXTRA (tree @var{address})
+@hook 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.
@@ -8810,14 +8808,14 @@  filling in a single size corresponding t
 @var{address} is the address of the table.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_ASM_TTYPE (rtx @var{sym})
+@hook 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
 reference to be output using the normal Dwarf2 routines.
 @end deftypefn
 
-@deftypevr {Target Hook} bool TARGET_ARM_EABI_UNWINDER
+@hook 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
@@ -9250,7 +9248,7 @@  for SDB in response to the @option{-g} o
 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})
+@hook 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.
@@ -9305,7 +9303,7 @@  is used on some systems to avoid garbage
 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})
+@hook 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
@@ -9565,7 +9563,7 @@  Target-specific attributes may be define
 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
+@hook TARGET_ATTRIBUTE_TABLE
 If defined, this target hook points to an array of @samp{struct
 attribute_spec} (defined in @file{tree.h}) specifying the machine
 specific attributes for this target and some of the restrictions on the
@@ -9573,7 +9571,7 @@  entities to which these attributes are a
 take.
 @end deftypevr
 
-@deftypefn {Target Hook} bool TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P (const_tree @var{name})
+@hook 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
@@ -9581,7 +9579,7 @@  subjected to name lookup.  If this is no
 false for all machine-specific attributes.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_COMP_TYPE_ATTRIBUTES (const_tree @var{type1}, const_tree @var{type2})
+@hook 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
@@ -9589,12 +9587,12 @@  generated).  If this is not defined, mac
 supposed always to be compatible.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SET_DEFAULT_TYPE_ATTRIBUTES (tree @var{type})
+@hook 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
 
-@deftypefn {Target Hook} tree TARGET_MERGE_TYPE_ATTRIBUTES (tree @var{type1}, tree @var{type2})
+@hook 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
@@ -9603,7 +9601,7 @@  function may call @code{merge_attributes
 merging.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_MERGE_DECL_ATTRIBUTES (tree @var{olddecl}, tree @var{newdecl})
+@hook 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}.
@@ -9625,11 +9623,7 @@  to perform initial processing of the @sa
 @file{i386/i386.c}, for example.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_VALID_DLLIMPORT_ATTRIBUTE_P (const_tree @var{decl})
-@var{decl} is a variable or function with @code{__attribute__((dllimport))}
-specified. Use this hook if the target needs to add extra validation
-checks to @code{handle_dll_attribute}.
-@end deftypefn
+@hook TARGET_VALID_DLLIMPORT_ATTRIBUTE_P
 
 @defmac TARGET_DECLSPEC
 Define this macro to a nonzero value if you want to treat
@@ -9640,7 +9634,7 @@  of @code{__declspec} is via a built-in m
 on this implementation detail.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_INSERT_ATTRIBUTES (tree @var{node}, tree *@var{attr_ptr})
+@hook 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
@@ -9653,7 +9647,7 @@  attributes, or a copy of the list may be
 needed.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (const_tree @var{fndecl})
+@hook 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
@@ -9661,7 +9655,7 @@  attributes, @code{false} otherwise.  By 
 target specific attribute attached to it, it will not be inlined.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_OPTION_VALID_ATTRIBUTE_P (tree @var{fndecl}, tree @var{name}, tree @var{args}, int @var{flags})
+@hook TARGET_OPTION_VALID_ATTRIBUTE_P
 This hook is called to parse the @code{attribute(option("..."))}, and
 it allows the function to set different target machine compile time
 options for the current function that might be different than the
@@ -9673,20 +9667,20 @@  the function declaration to hold a point
 @var{struct cl_target_option} structure.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_OPTION_SAVE (struct cl_target_option *@var{ptr})
+@hook TARGET_OPTION_SAVE
 This hook is called to save any additional target specific information
 in the @var{struct cl_target_option} structure for function specific
 options.
 @xref{Option file format}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_OPTION_RESTORE (struct cl_target_option *@var{ptr})
+@hook TARGET_OPTION_RESTORE
 This hook is called to restore any additional target specific
 information in the @var{struct cl_target_option} structure for
 function specific options.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_OPTION_PRINT (FILE *@var{file}, int @var{indent}, struct cl_target_option *@var{ptr})
+@hook TARGET_OPTION_PRINT
 This hook is called to print any additional target specific
 information in the @var{struct cl_target_option} structure for
 function specific options.
@@ -9699,7 +9693,7 @@  input stream.  The options should be the
 @code{TARGET_VALID_OPTION_ATTRIBUTE_P} hook.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CAN_INLINE_P (tree @var{caller}, tree @var{callee})
+@hook 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
@@ -9722,13 +9716,13 @@  object.  To access the TLS object, a loo
 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
+@hook 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.
 @end deftypevr
 
-@deftypevr {Target Hook} {const char *} TARGET_EMUTLS_REGISTER_COMMON
+@hook 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
@@ -9736,29 +9730,29 @@  have explicit initializers.  The default
 registration function to be used.
 @end deftypevr
 
-@deftypevr {Target Hook} {const char *} TARGET_EMUTLS_VAR_SECTION
+@hook 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.
 @end deftypevr
 
-@deftypevr {Target Hook} {const char *} TARGET_EMUTLS_TMPL_SECTION
+@hook 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.
 @end deftypevr
 
-@deftypevr {Target Hook} {const char *} TARGET_EMUTLS_VAR_PREFIX
+@hook 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
 
-@deftypevr {Target Hook} {const char *} TARGET_EMUTLS_TMPL_PREFIX
+@hook 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
 
-@deftypefn {Target Hook} tree TARGET_EMUTLS_VAR_FIELDS (tree @var{type}, tree *@var{name})
+@hook 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
@@ -9766,20 +9760,20 @@  object type.  @var{type} is the RECORD_T
 for libgcc's emulated TLS function.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_EMUTLS_VAR_INIT (tree @var{var}, tree @var{decl}, tree @var{tmpl_addr})
+@hook 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
 initializer.  The default initializes libgcc's emulated TLS control object.
 @end deftypefn
 
-@deftypevr {Target Hook} bool TARGET_EMUTLS_VAR_ALIGN_FIXED
+@hook 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.
 @end deftypevr
 
-@deftypevr {Target Hook} bool TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
+@hook 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
@@ -9828,13 +9822,13 @@  Default: empty.
 @section Parameters for Precompiled Header Validity Checking
 @cindex parameters, precompiled headers
 
-@deftypefn {Target Hook} {void *} TARGET_GET_PCH_VALIDITY (size_t *@var{sz})
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_PCH_VALID_P (const void *@var{data}, size_t @var{sz})
+@hook 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
@@ -9849,7 +9843,7 @@  The default definition of @code{default_
 suitable for most targets.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_CHECK_PCH_TARGET_FLAGS (int @var{pch_flags})
+@hook 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
@@ -9861,19 +9855,19 @@  value is the same as for @code{TARGET_PC
 @section C++ ABI parameters
 @cindex parameters, c++ abi
 
-@deftypefn {Target Hook} tree TARGET_CXX_GUARD_TYPE (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_GUARD_MASK_BIT (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_CXX_GET_COOKIE_SIZE (tree @var{type})
+@hook 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
@@ -9881,12 +9875,12 @@  known that a cookie is needed.  The defa
 IA64/Generic C++ ABI@.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_COOKIE_HAS_SIZE (void)
+@hook 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
 
-@deftypefn {Target Hook} int TARGET_CXX_IMPORT_EXPORT_CLASS (tree  @var{type}, int @var{import_export})
+@hook 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
@@ -9895,13 +9889,13 @@  modified value and perform any other act
 backend's targeted operating system.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_CDTOR_RETURNS_THIS (void)
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_KEY_METHOD_MAY_BE_INLINE (void)
+@hook 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
@@ -9911,16 +9905,9 @@  some variants of the ABI, an inline func
 method.  The default is to return @code{true}.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY (tree @var{decl})
-@var{decl} is a virtual table, virtual table table, typeinfo object,
-or other similar implicit class data object that will be emitted with
-external linkage in this translation unit.  No ELF visibility has been
-explicitly specified.  If the target needs to specify a visibility
-other than that of the containing class, use this hook to set
-@code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.
-@end deftypefn
+@hook TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
 
-@deftypefn {Target Hook} bool TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT (void)
+@hook 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
@@ -9928,19 +9915,19 @@  classes whose virtual table will be emit
 unit will not be COMDAT.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_LIBRARY_RTTI_COMDAT (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_USE_AEABI_ATEXIT (void)
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT (void)
+@hook 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
@@ -9948,11 +9935,7 @@  shared libraries are run in the correct 
 unloaded. The default is to return false.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_CXX_ADJUST_CLASS_AT_DEFINITION (tree @var{type})
-@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just been
-defined.  Use this hook to make adjustments to the class (eg, tweak
-visibility or perform any other required target modifications).
-@end deftypefn
+@hook TARGET_CXX_ADJUST_CLASS_AT_DEFINITION
 
 @node Named Address Spaces
 @section Adding support for named address spaces
@@ -9992,21 +9975,21 @@  named address space #1:
 c_register_addr_space ("__ea", ADDR_SPACE_EA);
 @end smallexample
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t @var{address_space})
+@hook 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} for the
 generic address space only.
 @end deftypefn
 
-@deftypefn {Target Hook} {enum machine_mode} TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t @var{address_space})
+@hook 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} for the
 generic address space only.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (enum machine_mode @var{mode}, addr_space_t @var{as})
+@hook 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,
@@ -10016,7 +9999,7 @@  version of this hook returns true for th
 target hooks for the given address space.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode}, rtx @var{exp}, bool @var{strict}, addr_space_t @var{as})
+@hook 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
@@ -10025,14 +10008,14 @@  finished.  This target hook is the same 
 explicit named address space support.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode}, addr_space_t @var{as})
+@hook 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,
 except that it includes explicit named address space support.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_SUBSET_P (addr_space_t @var{superset}, addr_space_t @var{subset})
+@hook 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
@@ -10041,7 +10024,7 @@  arithmetic operations.  Pointers to a su
 converted to pointers to a subset address space via explicit casts.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_ADDR_SPACE_CONVERT (rtx @var{op}, tree @var{from_type}, tree @var{to_type})
+@hook 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
@@ -10098,7 +10081,7 @@  contain relative addresses only when @op
 is in effect.
 @end defmac
 
-@deftypefn {Target Hook} {unsigned int} TARGET_CASE_VALUES_THRESHOLD (void)
+@hook 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
@@ -10159,7 +10142,7 @@  point number to a signed fixed point num
 unsigned one.
 @end defmac
 
-@deftypefn {Target Hook} {unsigned int} TARGET_MIN_DIVISIONS_FOR_RECIP_MUL (enum machine_mode @var{mode})
+@hook 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
@@ -10207,7 +10190,7 @@  You need not define this macro if it wou
 @end defmac
 
 @anchor{TARGET_SHIFT_TRUNCATION_MASK}
-@deftypefn {Target Hook} {unsigned HOST_WIDE_INT} TARGET_SHIFT_TRUNCATION_MASK (enum machine_mode @var{mode})
+@hook 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}.
@@ -10247,7 +10230,7 @@  If this is the case, making @code{TRULY_
 such cases may improve things.
 @end defmac
 
-@deftypefn {Target Hook} int TARGET_MODE_REP_EXTENDED (enum machine_mode @var{mode}, enum machine_mode @var{rep_mode})
+@hook 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
@@ -10570,9 +10553,7 @@  Define this macro, as well as
 arguments of @samp{#pragma pack}.
 @end defmac
 
-@deftypevr {Target Hook} bool TARGET_HANDLE_PRAGMA_EXTERN_PREFIX
-True if @code{#pragma extern_prefix} is to be supported.
-@end deftypevr
+@hook TARGET_HANDLE_PRAGMA_EXTERN_PREFIX
 
 @defmac TARGET_DEFAULT_PACK_STRUCT
 If your target requires a structure packing default other than 0 (meaning
@@ -10638,7 +10619,7 @@  from shared libraries (DLLs).
 You need not define this macro if it would always evaluate to zero.
 @end defmac
 
-@deftypefn {Target Hook} tree TARGET_MD_ASM_CLOBBERS (tree @var{outputs}, tree @var{inputs}, tree @var{clobbers})
+@hook TARGET_MD_ASM_CLOBBERS
 This target hook should add to @var{clobbers} @code{STRING_CST} trees for
 any hard regs the port wishes to automatically clobber for an asm.
 It should return the result of the last @code{tree_cons} used to add a
@@ -10731,7 +10712,7 @@  added to the @code{struct ce_if_block} s
 by the @code{IFCVT_INIT_EXTRA_FIELDS} macro.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_MACHINE_DEPENDENT_REORG (void)
+@hook 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.
@@ -10745,7 +10726,7 @@  You need not implement the hook if it ha
 definition is null.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_INIT_BUILTINS (void)
+@hook 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.
@@ -10763,7 +10744,7 @@  only language front ends that use those 
 @samp{TARGET_INIT_BUILTINS}.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_BUILTIN_DECL (unsigned @var{code}, bool @var{initialize_p})
+@hook 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}.
@@ -10773,7 +10754,7 @@  If @var{code} is out of range the functi
 @code{error_mark_node}.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN (tree @var{exp}, rtx @var{target}, rtx @var{subtarget}, enum machine_mode @var{mode}, int @var{ignore})
+@hook 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
@@ -10808,7 +10789,7 @@  The result is another tree containing a 
 call's result.  If @var{ignore} is true the value will be ignored.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_WITHIN_DOLOOP (const_rtx @var{insn})
+@hook 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
@@ -10832,14 +10813,14 @@  filling of delay slots can result in bra
 may in turn cause a branch offset to overflow.
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_COMMUTATIVE_P (const_rtx @var{x}, int @var{outer_code})
+@hook 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
 of the enclosing rtl, if known, otherwise it is UNKNOWN.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_ALLOCATE_INITIAL_VALUE (rtx @var{hard_reg})
+@hook 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
@@ -10861,7 +10842,7 @@  The default value of this hook is @code{
 allocation.
 @end deftypefn
 
-@deftypefn {Target Hook} int TARGET_UNSPEC_MAY_TRAP_P (const_rtx @var{x}, unsigned @var{flags})
+@hook 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
@@ -10870,7 +10851,7 @@  to analyze inner elements of @var{x} in 
 passed along.
 @end deftypefn
 
-@deftypefn {Target Hook} void TARGET_SET_CURRENT_FUNCTION (tree @var{decl})
+@hook 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
@@ -10926,7 +10907,7 @@  build_type_attribute_variant (@var{mdecl
 @end smallexample
 @end defmac
 
-@deftypefn {Target Hook} bool TARGET_CANNOT_MODIFY_JUMPS_P (void)
+@hook 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
@@ -10941,7 +10922,7 @@  cannot_modify_jumps_past_reload_p ()
 @end smallexample
 @end deftypefn
 
-@deftypefn {Target Hook} {enum reg_class} TARGET_BRANCH_TARGET_REGISTER_CLASS (void)
+@hook TARGET_BRANCH_TARGET_REGISTER_CLASS
 This target hook returns a register class for which branch target register
 optimizations should be applied.  All registers in this class should be
 usable interchangeably.  After reload, registers in this class will be
@@ -10949,7 +10930,7 @@  re-allocated and loads will be hoisted o
 to inter-block scheduling.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED (bool @var{after_prologue_epilogue_gen})
+@hook TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED
 Branch target register optimization will by default exclude callee-saved
 registers
 that are not already live during the current function; if this target hook
@@ -10963,13 +10944,13 @@  to have to make special provisions in @c
 to reserve space for caller-saved target registers.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_HAVE_CONDITIONAL_EXECUTION (void)
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} unsigned TARGET_LOOP_UNROLL_ADJUST (unsigned @var{nunroll}, struct loop *@var{loop})
+@hook 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
@@ -11047,7 +11028,7 @@  routine for target specific customizatio
 and scanf formatter settings.
 @end defmac
 
-@deftypevr {Target Hook} bool TARGET_RELAXED_ORDERING
+@hook TARGET_RELAXED_ORDERING
 If set to @code{true}, means that the target's memory model does not
 guarantee that loads which do not depend on one another will access
 main memory in the order of the instruction stream; if ordering is
@@ -11057,47 +11038,47 @@  many recent processors which implement a
 and ia64.  The default is @code{false}.
 @end deftypevr
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN (const_tree @var{typelist}, const_tree @var{funcdecl}, const_tree @var{val})
+@hook 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}.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_CONVERSION (const_tree @var{fromtype}, const_tree @var{totype})
+@hook 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.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_UNARY_OP (int @var{op}, const_tree @var{type})
+@hook 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}
 if validity should be determined by the front end.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_BINARY_OP (int @var{op}, const_tree @var{type1}, const_tree @var{type2})
+@hook 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
 the front end.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_PARAMETER_TYPE (const_tree @var{type})
+@hook TARGET_INVALID_PARAMETER_TYPE
 If defined, this macro returns the diagnostic message when it is
 invalid for functions to include parameters of type @var{type}, 
 or @code{NULL} if validity should be determined by
 the front end.  This is currently used only by the C and C++ front ends.
 @end deftypefn
 
-@deftypefn {Target Hook} {const char *} TARGET_INVALID_RETURN_TYPE (const_tree @var{type})
+@hook TARGET_INVALID_RETURN_TYPE
 If defined, this macro returns the diagnostic message when it is
 invalid for functions to have return type @var{type}, 
 or @code{NULL} if validity should be determined by
 the front end.  This is currently used only by the C and C++ front ends.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_PROMOTED_TYPE (const_tree @var{type})
+@hook TARGET_PROMOTED_TYPE
 If defined, this target hook returns the type to which values of 
 @var{type} should be promoted when they appear in expressions, 
 analogous to the integer promotions, or @code{NULL_TREE} to use the
@@ -11106,7 +11087,7 @@  target-specific types with special promo
 This is currently used only by the C and C++ front ends.
 @end deftypefn
 
-@deftypefn {Target Hook} tree TARGET_CONVERT_TO_TYPE (tree @var{type}, tree @var{expr})
+@hook TARGET_CONVERT_TO_TYPE
 If defined, this hook returns the result of converting @var{expr} to 
 @var{type}.  It should return the converted expression, 
 or @code{NULL_TREE} to apply the front end's normal conversion rules.
@@ -11133,19 +11114,19 @@  call stack unwinding.  It is used in dec
 and the associated definitions of those functions.
 @end defmac
 
-@deftypefn {Target Hook} void TARGET_UPDATE_STACK_BOUNDARY (void)
+@hook TARGET_UPDATE_STACK_BOUNDARY
 Define this macro to update the current function stack boundary if
 necessary.
 @end deftypefn
 
-@deftypefn {Target Hook} rtx TARGET_GET_DRAP_RTX (void)
+@hook 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
 is needed.
 @end deftypefn
 
-@deftypefn {Target Hook} bool TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS (void)
+@hook 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
@@ -11156,7 +11137,7 @@  to the stack.  Therefore, this hook shou
 false for naked functions.  The default implementation always returns true.
 @end deftypefn
 
-@deftypevr {Target Hook} {unsigned HOST_WIDE_INT} TARGET_CONST_ANCHOR
+@hook 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
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c	(revision 161494)
+++ gcc/c-family/c-common.c	(working copy)
@@ -4907,13 +4907,13 @@  c_common_nodes_and_builtins (void)
     (build_decl (UNKNOWN_LOCATION,
 		 TYPE_DECL, get_identifier ("__builtin_va_list"),
 		 va_list_type_node));
-  if (targetm.enum_va_list)
+  if (targetm.enum_va_list_p)
     {
       int l;
       const char *pname;
       tree ptype;
 
-      for (l = 0; targetm.enum_va_list (l, &pname, &ptype); ++l)
+      for (l = 0; targetm.enum_va_list_p (l, &pname, &ptype); ++l)
 	{
 	  lang_hooks.decls.pushdecl
 	    (build_decl (UNKNOWN_LOCATION,
Index: gcc/target.def
===================================================================
--- gcc/target.def	(revision 0)
+++ gcc/target.def	(revision 0)
@@ -0,0 +1,2319 @@ 
+/* Target hook definitions.
+   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
+   Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by the
+   Free Software Foundation; either version 3, or (at your option) any
+   later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.
+
+   In other words, you are welcome to use, share and improve this program.
+   You are forbidden to forbid anyone else to use, share and improve
+   what you give them.   Help stamp out software-hoarding!  */
+
+/* The following macros should be provided by the including file:
+
+   DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT): Define a function-valued hook.
+   DEFHOOKPOD(DOC, TYPE, NAME, INIT): Define a piece-of-data 'hook'.  */
+
+/* Defaults for optional macros:
+   DEFHOOKPODX(NAME, TYPE, INIT): Like DEFHOOKPOD, but share documentation
+   with the previous 'hook'.  */
+#ifndef DEFHOOKPODX
+#define DEFHOOKPODX(NAME, TYPE, INIT) DEFHOOKPOD (NAME, 0, TYPE, INIT)
+#endif
+   
+/* HOOKSTRUCT(FRAGMENT): Declarator fragments to encapsulate all the
+   members into a struct gcc_target, which in turn contains several
+   sub-structs.  */
+#ifndef HOOKSTRUCT
+#define HOOKSTRUCT(FRAGMENT)
+#endif
+/* HOOK_VECTOR: Start a struct declaration, which then gets its own initializer.
+   HOOK_VECTOR_END: Close a struct declaration, providing a member declarator
+                    name for nested use.  */
+#ifndef HOOK_VECTOR_1
+#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT(FRAGMENT)
+#endif
+#define HOOK_VECTOR(INIT_NAME, SNAME) HOOK_VECTOR_1 (INIT_NAME, struct SNAME {)
+#define HOOK_VECTOR_END(DECL_NAME) HOOK_VECTOR_1(,} DECL_NAME ;)
+
+HOOK_VECTOR (TARGET_INITIALIZER, gcc_target)
+
+/* FIXME: For pre-existing hooks, we can't place the documentation in the
+   documentation field here till we get permission from the FSF to include
+   it in GPLed software - the target hook documentation is so far only
+   available under the GFDL.  */
+
+/* A hook should generally be documented by a string in the DOC parameter,
+   which should contain texinfo markup.  If the documentation is only available
+   under the GPL, but not under the GFDL, put it in a comment above the hook
+   definition.  If the function declaration is available both under GPL and
+   GFDL, but the documentation is only available under the GFDL, put the
+   documentaton in tm.texi.in, heading with @hook <hookname> and closing
+   the paragraph with @end deftypefn / deftypevr as appropriate, and marking
+   the next autogenerated hook with @hook <hookname>.
+   In both these cases, leave the DOC string empty, i.e. "".
+   Sometimes, the function declaration itself is only available under the
+   GPL, and/or for some historic reason it has to be documented differently
+   than what it is.  In that case, use DEFHOOK_UNDOC to supress auto-generation
+   of documentation.  DEFHOOK_UNDOC takes a DOC string which it ignores, so
+   you can put GPLed documentation string there if you have hopes that you
+   can clear the declaration & documentation for GFDL distribution later,
+   in which case you can then simply change the DEFHOOK_UNDOC to DEFHOOK
+   to turn on the autogeneration of the documentation.
+
+   A documentation string of "*" means not to emit any documentation at all,
+   and is mainly used internally for DEFHOOK_UNDOC.  It should generally not
+   be used otherwise, but it has its use for exceptional cases where automatic
+   documentation is not wanted, and the real documentation is elsewere, like
+   for TARGET_ASM_{,UN}ALIGNED_INT_OP, which are hooks only for implementation
+   purposes; they refer to structs, the components of which are documented as
+   separate hooks TARGET_ASM_{,UN}ALIGNED_[HSDT]I_OP.
+   A DOC string of 0 is for internal use of DEFHOOKPODX and special table
+   entries only.  */
+
+/* Functions that output assembler for the target.  */
+#define HOOK_PREFIX "TARGET_ASM_"
+HOOK_VECTOR (TARGET_ASM_OUT, asm_out)
+
+/* Opening and closing parentheses for asm expression grouping.  */
+DEFHOOKPOD
+(open_paren,
+ "",
+ const char *, "(")
+DEFHOOKPODX (close_paren, const char *, ")")
+
+/* Assembler instructions for creating various kinds of integer object.  */
+DEFHOOKPOD
+(byte_op,
+ "",
+ const char *, "\t.byte\t")
+DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP)
+DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP)
+
+/* Try to output the assembler code for an integer object whose
+   value is given by X.  SIZE is the size of the object in bytes and
+   ALIGNED_P indicates whether it is aligned.  Return true if
+   successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
+   and UNALIGNED_OP are NULL.  */
+DEFHOOK
+(integer,
+ "",
+ /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are
+    NULL.  */
+ bool, (rtx x, unsigned int size, int aligned_p),
+ default_assemble_integer)
+
+/* Output code that will globalize a label.  */
+DEFHOOK
+(globalize_label,
+ "",
+ void, (FILE *stream, const char *name),
+ default_globalize_label)
+
+/* Output code that will globalize a declaration.  */
+DEFHOOK
+(globalize_decl_name,
+ "",
+ void, (FILE *stream, tree decl), default_globalize_decl_name)
+
+/* Output code that will emit a label for unwind info, if this
+   target requires such labels.  Second argument is the decl the
+   unwind info is associated with, third is a boolean: true if
+   this is for exception handling, fourth is a boolean: true if
+   this is only a placeholder for an omitted FDE.  */
+DEFHOOK
+(emit_unwind_label,
+ "",
+ void, (FILE *stream, tree decl, int for_eh, int empty),
+ default_emit_unwind_label)
+
+/* Output code that will emit a label to divide up the exception table.  */
+DEFHOOK
+(emit_except_table_label,
+ "",
+ void, (FILE *stream),
+ default_emit_except_table_label)
+
+/* Emit any directives required to unwind this instruction.  */
+DEFHOOK
+(unwind_emit,
+ "",
+ void, (FILE *stream, rtx insn),
+ default_unwind_emit)
+
+/* Output an internal label.  */
+DEFHOOK
+(internal_label,
+ "",
+ void, (FILE *stream, const char *prefix, unsigned long labelno),
+ default_internal_label)
+
+/* Output label for the constant.  */
+/* ??? The documentation uses a different name for the hook argument EXP.  */
+DEFHOOK_UNDOC
+(declare_constant_name,
+ "",
+ void, (FILE *file, const char *name, const_tree exp, HOST_WIDE_INT size),
+ default_asm_declare_constant_name)
+
+/* Emit a ttype table reference to a typeinfo object.  */
+DEFHOOK
+(ttype,
+ "",
+ bool, (rtx sym),
+ hook_bool_rtx_false)
+
+/* Emit an assembler directive to set visibility for the symbol
+   associated with the tree decl.  */
+DEFHOOK
+(assemble_visibility,
+ "",
+ void, (tree decl, int visibility),
+ default_assemble_visibility)
+
+/* Output the assembler code for entry to a function.  */
+DEFHOOK
+(function_prologue,
+ "",
+ void, (FILE *file, HOST_WIDE_INT size),
+ default_function_pro_epilogue)
+
+/* Output the assembler code for end of prologue.  */
+DEFHOOK
+(function_end_prologue,
+ "",
+ void, (FILE *file),
+ no_asm_to_stream)
+
+/* Output the assembler code for start of epilogue.  */
+DEFHOOK
+(function_begin_epilogue,
+ "",
+ void, (FILE *file),
+ no_asm_to_stream)
+
+/* Output the assembler code for function exit.  */
+DEFHOOK
+(function_epilogue,
+ "",
+ void, (FILE *file, HOST_WIDE_INT size),
+ default_function_pro_epilogue)
+
+/* Initialize target-specific sections.  */
+DEFHOOK
+(init_sections,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Tell assembler to change to section NAME with attributes FLAGS.
+   If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
+   which this section is associated.  */
+DEFHOOK
+(named_section,
+ "",
+ void, (const char *name, unsigned int flags, tree decl),
+ default_no_named_section)
+
+/* 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
+   local relocations should be placed in a read-write section.  */
+DEFHOOK
+(reloc_rw_mask,
+ "",
+ int, (void),
+ default_reloc_rw_mask)
+
+ /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
+    is nonzero if runtime relocations must be applied; bit 1 will be
+    set if the runtime relocations require non-local name resolution.
+    ALIGN is the required alignment of the data.  */
+DEFHOOK
+(select_section,
+ "",
+ section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align),
+ default_select_section)
+
+/* Return a section for X.  MODE is X's mode and ALIGN is its
+   alignment in bits.  */
+DEFHOOK
+(select_rtx_section,
+ "",
+ section *, (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align),
+ default_select_rtx_section)
+
+/* Select a unique section name for DECL.  RELOC is the same as
+   for SELECT_SECTION.  */
+DEFHOOK
+(unique_section,
+ "",
+ void, (tree decl, int reloc),
+ default_unique_section)
+
+/* Return the readonly data section associated with function DECL.  */
+DEFHOOK
+(function_rodata_section,
+ "",
+ section *, (tree decl),
+ default_function_rodata_section)
+
+/* Output a constructor for a symbol with a given priority.  */
+DEFHOOK
+(constructor,
+ "",
+ void, (rtx symbol, int priority), NULL)
+
+/* Output a destructor for a symbol with a given priority.  */
+DEFHOOK
+(destructor,
+ "",
+ void, (rtx symbol, int priority), NULL)
+
+/* Output the assembler code for a thunk function.  THUNK_DECL is the
+   declaration for the thunk function itself, FUNCTION is the decl for
+   the target function.  DELTA is an immediate constant offset to be
+   added to THIS.  If VCALL_OFFSET is nonzero, the word at
+   *(*this + vcall_offset) should be added to THIS.  */
+DEFHOOK
+(output_mi_thunk,
+ "",
+ void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
+	HOST_WIDE_INT vcall_offset, tree function),
+ NULL)
+
+/* Determine whether output_mi_thunk would succeed.  */
+/* ??? Ideally, this hook would not exist, and success or failure
+   would be returned from output_mi_thunk directly.  But there's
+   too much undo-able setup involved in invoking output_mi_thunk.
+   Could be fixed by making output_mi_thunk emit rtl instead of
+   text to the output file.  */
+DEFHOOK
+(can_output_mi_thunk,
+ "",
+ bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta,
+	HOST_WIDE_INT vcall_offset, const_tree function),
+ hook_bool_const_tree_hwi_hwi_const_tree_false)
+
+/* Output any boilerplate text needed at the beginning of a
+   translation unit.  */
+DEFHOOK
+(file_start,
+ "",
+ void, (void),
+ default_file_start)
+
+/* Output any boilerplate text needed at the end of a translation unit.  */
+DEFHOOK
+(file_end,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Output any boilerplate text needed at the beginning of an
+   LTO output stream.  */
+DEFHOOK
+(lto_start,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Output any boilerplate text needed at the end of an
+   LTO output stream.  */
+DEFHOOK
+(lto_end,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Output any boilerplace text needed at the end of a
+   translation unit before debug and unwind info is emitted.  */
+DEFHOOK
+(code_end,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Output an assembler pseudo-op to declare a library function name
+   external.  */
+DEFHOOK
+(external_libcall,
+ "",
+ void, (rtx symref),
+ default_external_libcall)
+
+/* Output an assembler directive to mark decl live. This instructs
+   linker to not dead code strip this symbol.  */
+DEFHOOK
+(mark_decl_preserved,
+ "",
+ void, (const char *symbol),
+ hook_void_constcharptr)
+
+/* Output a record of the command line switches that have been passed.  */
+DEFHOOK
+(record_gcc_switches,
+ "",
+ int, (print_switch_type type, const char *text),
+ NULL)
+
+/* The name of the section that the example ELF implementation of
+   record_gcc_switches will use to store the information.  Target
+   specific versions of record_gcc_switches may or may not use
+   this information.  */
+DEFHOOKPOD
+(record_gcc_switches_section,
+ "",
+ const char *, ".GCC.command.line")
+
+/* Output the definition of a section anchor.  */
+DEFHOOK
+(output_anchor,
+ "",
+ void, (rtx x),
+ default_asm_output_anchor)
+
+/* Output a DTP-relative reference to a TLS symbol.  */
+DEFHOOK
+(output_dwarf_dtprel,
+ "",
+ void, (FILE *file, int size, rtx x),
+ NULL)
+
+/* Some target machines need to postscan each insn after it is output.  */
+DEFHOOK
+(final_postscan_insn,
+ "",
+ void, (FILE *file, rtx insn, rtx *opvec, int noperands),
+ NULL)
+
+/* Emit the trampoline template.  This hook may be NULL.  */
+DEFHOOK
+(trampoline_template,
+ "",
+ void, (FILE *f),
+ NULL)
+
+/* ??? The TARGET_PRINT_OPERAND* hooks are part of the asm_out struct,
+   even though that is not reflected in the macro name to override their
+   initializers.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_"
+
+/* Emit a machine-specific insn operand.  */
+/* ??? Documenting the argument types for this hook requires a GFDL
+   license grant.  Also, the documentation documents this as a macro,
+   not a hook, and uses a different name for the hook argument FILE.  */
+DEFHOOK_UNDOC
+(print_operand,
+ "",
+ void, (FILE *file, rtx x, int code),
+ default_print_operand)
+
+/* Emit a machine-specific memory address.  */
+/* ??? Documenting the argument types for this hook requires a GFDL
+   license grant.  Also, the documentation documents this as a macro,
+   not a hook, and uses different hook argument names.  */
+DEFHOOK_UNDOC
+(print_operand_address,
+ "",
+ void, (FILE *file, rtx addr),
+ default_print_operand_address)
+
+/* Determine whether CODE is a valid punctuation character for the
+   `print_operand' hook.  */
+/* ??? Documenting the argument types for this hook requires a GFDL
+   license grant.  Also, the documentation documents this as a macro,
+   not a hook.  */
+DEFHOOK_UNDOC
+(print_operand_punct_valid_p,
+ "",
+ bool ,(unsigned char code),
+ default_print_operand_punct_valid_p)
+
+HOOK_VECTOR_END (asm_out)
+
+/* Functions relating to instruction scheduling.  All of these
+   default to null pointers, which haifa-sched.c looks for and handles.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_SCHED_"
+HOOK_VECTOR (TARGET_SCHED, sched)
+
+/* Given the current cost, COST, of an insn, INSN, calculate and
+   return a new cost based on its relationship to DEP_INSN through
+   the dependence LINK.  The default is to make no adjustment.  */
+DEFHOOK
+(adjust_cost,
+ "",
+ int, (rtx insn, rtx link, rtx dep_insn, int cost), NULL)
+
+/* Adjust the priority of an insn as you see fit.  Returns the new priority.  */
+DEFHOOK
+(adjust_priority,
+ "",
+ int, (rtx insn, int priority), NULL)
+
+/* Function which returns the maximum number of insns that can be
+   scheduled in the same machine cycle.  This must be constant
+   over an entire compilation.  The default is 1.  */
+DEFHOOK
+(issue_rate,
+ "",
+ int, (void), NULL)
+
+/* Calculate how much this insn affects how many more insns we
+   can emit this cycle.  Default is they all cost the same.  */
+DEFHOOK
+(variable_issue,
+ "",
+ int, (FILE *file, int verbose, rtx insn, int more), NULL)
+
+/* Initialize machine-dependent scheduling code.  */
+DEFHOOK
+(init,
+ "",
+ void, (FILE *file, int verbose, int max_ready), NULL)
+
+/* Finalize machine-dependent scheduling code.  */
+DEFHOOK
+(finish,
+ "",
+ void, (FILE *file, int verbose), NULL)
+
+ /* Initialize machine-dependent function wide scheduling code.  */
+DEFHOOK
+(init_global,
+ "",
+ void, (FILE *file, int verbose, int old_max_uid), NULL)
+
+/* Finalize machine-dependent function wide scheduling code.  */
+DEFHOOK
+(finish_global,
+ "",
+ void, (FILE *file, int verbose), NULL)
+
+/* Reorder insns in a machine-dependent fashion, in two different
+       places.  Default does nothing.  */
+DEFHOOK
+(reorder,
+ "",
+ int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL)
+
+DEFHOOK
+(reorder2,
+ "",
+ int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL)
+
+/* The following member value is a pointer to a function called
+   after evaluation forward dependencies of insns in chain given
+   by two parameter values (head and tail correspondingly).  */
+DEFHOOK
+(dependencies_evaluation_hook,
+ "",
+ void, (rtx head, rtx tail), NULL)
+
+/* The values of the following four members are pointers to functions
+   used to simplify the automaton descriptions.  dfa_pre_cycle_insn and
+   dfa_post_cycle_insn give functions returning insns which are used to
+   change the pipeline hazard recognizer state when the new simulated
+   processor cycle correspondingly starts and finishes.  The function
+   defined by init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are
+   used to initialize the corresponding insns.  The default values of
+   the members result in not changing the automaton state when the
+   new simulated processor cycle correspondingly starts and finishes.  */
+
+DEFHOOK
+(init_dfa_pre_cycle_insn,
+ "",
+ void, (void), NULL)
+
+DEFHOOK
+(dfa_pre_cycle_insn,
+ "",
+ rtx, (void), NULL)
+
+DEFHOOK
+(init_dfa_post_cycle_insn,
+ "",
+ void, (void), NULL)
+
+DEFHOOK
+(dfa_post_cycle_insn,
+ "",
+ rtx, (void), NULL)
+
+/* The values of the following two members are pointers to
+   functions used to simplify the automaton descriptions.
+   dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
+   immediately before and after cycle is advanced.  */
+
+DEFHOOK
+(dfa_pre_advance_cycle,
+ "",
+ void, (void), NULL)
+
+DEFHOOK
+(dfa_post_advance_cycle,
+ "",
+ void, (void), NULL)
+
+/* The following member value is a pointer to a function returning value
+   which defines how many insns in queue `ready' will we try for
+   multi-pass scheduling.  If the member value is nonzero and the
+   function returns positive value, the DFA based scheduler will make
+   multi-pass scheduling for the first cycle.  In other words, we will
+   try to choose ready insn which permits to start maximum number of
+   insns on the same cycle.  */
+DEFHOOK
+(first_cycle_multipass_dfa_lookahead,
+ "",
+ int, (void), NULL)
+
+/* The following member value is pointer to a function controlling
+   what insns from the ready insn queue will be considered for the
+   multipass insn scheduling.  If the hook returns zero for insn
+   passed as the parameter, the insn will be not chosen to be issued.  */
+DEFHOOK
+(first_cycle_multipass_dfa_lookahead_guard,
+ "",
+ int, (rtx insn), NULL)
+
+/* The following member value is pointer to a function called by
+   the insn scheduler before issuing insn passed as the third
+   parameter on given cycle.  If the hook returns nonzero, the
+   insn is not issued on given processors cycle.  Instead of that,
+   the processor cycle is advanced.  If the value passed through
+   the last parameter is zero, the insn ready queue is not sorted
+   on the new cycle start as usually.  The first parameter passes
+   file for debugging output.  The second one passes the scheduler
+   verbose level of the debugging output.  The forth and the fifth
+   parameter values are correspondingly processor cycle on which
+   the previous insn has been issued and the current processor cycle.  */
+/* ??? The documentation uses different names for dump_file,
+   last_sched_cycle and cur_cycle.  */
+DEFHOOK_UNDOC
+(dfa_new_cycle,
+ "",
+ int, (FILE *dump_file, int verbose, rtx insn, int last_sched_cycle,
+       int cur_cycle, int *sort_p),
+ NULL)
+
+/* The following member value is a pointer to a function called by the
+   insn scheduler.  It should return true if there exists a dependence
+   which is considered costly by the target, between the insn
+   DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP).  The first parameter is
+   the dep that represents the dependence between the two insns.  The
+   second argument is the cost of the dependence as estimated by
+   the scheduler.  The last argument is the distance in cycles
+   between the already scheduled insn (first parameter) and the
+   second insn (second parameter).  */
+DEFHOOK
+(is_costly_dependence,
+ "",
+ bool, (struct _dep *_dep, int cost, int distance), NULL)
+
+DEFHOOK_UNDOC
+(adjust_cost_2,
+ "Given the current cost, @var{cost}, of an insn, @var{insn}, calculate and\
+ return a new cost based on its relationship to @var{dep_insn} through the\
+ dependence of weakness @var{dw}.  The default is to make no adjustment.",
+ int, (rtx insn, int dep_type1, rtx dep_insn, int cost, int dw), NULL)
+
+/* The following member value is a pointer to a function called
+   by the insn scheduler. This hook is called to notify the backend
+   that new instructions were emitted.  */
+DEFHOOK
+(h_i_d_extended,
+ "",
+ void, (void), NULL)
+
+/* Next 5 functions are for multi-point scheduling.  */
+
+/* Allocate memory for scheduler context.  */
+DEFHOOK
+(alloc_sched_context,
+ "",
+ void *, (void), NULL)
+
+/* Fills the context from the local machine scheduler context.  */
+DEFHOOK
+(init_sched_context,
+ "",
+ void, (void *tc, bool clean_p), NULL)
+
+/* Sets local machine scheduler context to a saved value.  */
+DEFHOOK
+(set_sched_context,
+ "",
+ void, (void *tc), NULL)
+
+/* Clears a scheduler context so it becomes like after init.  */
+DEFHOOK
+(clear_sched_context,
+ "",
+ void, (void *tc), NULL)
+
+/* Frees the scheduler context.  */
+DEFHOOK
+(free_sched_context,
+ "",
+ void, (void *tc), NULL)
+
+/* The following member value is a pointer to a function called
+   by the insn scheduler.
+   The first parameter is an instruction, the second parameter is the type
+   of the requested speculation, and the third parameter is a pointer to the
+   speculative pattern of the corresponding type (set if return value == 1).
+   It should return
+   -1, if there is no pattern, that will satisfy the requested speculation type,
+   0, if current pattern satisfies the requested speculation type,
+   1, if pattern of the instruction should be changed to the newly
+   generated one.  */
+DEFHOOK
+(speculate_insn,
+ "",
+ int, (rtx insn, int request, rtx *new_pat), NULL)
+
+/* The following member value is a pointer to a function called
+   by the insn scheduler.  It should return true if the check instruction
+   passed as the parameter needs a recovery block.  */
+DEFHOOK
+(needs_block_p,
+ "",
+ bool, (int dep_status), NULL)
+
+/* The following member value is a pointer to a function called
+   by the insn scheduler.  It should return a pattern for the check
+   instruction.
+   The first parameter is a speculative instruction, the second parameter
+   is the label of the corresponding recovery block (or null, if it is a
+   simple check).  If the mutation of the check is requested (e.g. from
+   ld.c to chk.a), the third parameter is true - in this case the first
+   parameter is the previous check.  */
+DEFHOOK
+(gen_spec_check,
+ "",
+ rtx, (rtx insn, rtx label, int mutate_p), NULL)
+
+/* The following member value is a pointer to a function controlling
+   what insns from the ready insn queue will be considered for the
+   multipass insn scheduling.  If the hook returns zero for the insn
+   passed as the parameter, the insn will not be chosen to be
+   issued.  This hook is used to discard speculative instructions,
+   that stand at the first position of the ready list.  */
+DEFHOOK
+(first_cycle_multipass_dfa_lookahead_guard_spec,
+ "",
+ bool, (const_rtx insn), NULL)
+
+/* The following member value is a pointer to a function that provides
+   information about the speculation capabilities of the target.
+   The parameter is a pointer to spec_info variable.  */
+DEFHOOK
+(set_sched_flags,
+ "",
+ void, (struct spec_info_def *spec_info), NULL)
+
+DEFHOOK_UNDOC
+(get_insn_spec_ds,
+ "Return speculation types of instruction @var{insn}.",
+ int, (rtx insn), NULL)
+
+DEFHOOK_UNDOC
+(get_insn_checked_ds,
+ "Return speculation types that are checked for instruction @var{insn}",
+ int, (rtx insn), NULL)
+
+DEFHOOK_UNDOC
+(skip_rtx_p,
+ "Return bool if rtx scanning should just skip current layer and\
+ advance to the inner rtxes.",
+ bool, (const_rtx x), NULL)
+
+/* The following member value is a pointer to a function that provides
+   information about the target resource-based lower bound which is
+   used by the swing modulo scheduler.  The parameter is a pointer
+   to ddg variable.  */
+DEFHOOK
+(sms_res_mii,
+ "",
+ int, (struct ddg *g), NULL)
+
+HOOK_VECTOR_END (sched)
+
+/* Functions relating to vectorization.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_VECTORIZE_"
+HOOK_VECTOR (TARGET_VECTORIZE, vectorize)
+
+/* The following member value is a pointer to a function called
+   by the vectorizer, and return the decl of the target builtin
+   function.  */
+DEFHOOK
+(builtin_mask_for_load,
+ "",
+ tree, (void), NULL)
+
+/* Returns a code for builtin that realizes vectorized version of
+   function, or NULL_TREE if not available.  */
+DEFHOOK
+(builtin_vectorized_function,
+ "",
+ tree, (tree fndecl, tree vec_type_out, tree vec_type_in),
+ default_builtin_vectorized_function)
+
+/* Returns a function declaration for a builtin that realizes the
+   vector conversion, or NULL_TREE if not available.  */
+DEFHOOK
+(builtin_conversion,
+ "",
+ tree, (unsigned code, tree dest_type, tree src_type),
+ default_builtin_vectorized_conversion)
+
+/* Target builtin that implements vector widening multiplication.
+   builtin_mul_widen_eve computes the element-by-element products
+   for the even elements, and builtin_mul_widen_odd computes the
+   element-by-element products for the odd elements.  */
+DEFHOOK
+(builtin_mul_widen_even,
+ "",
+ tree, (tree x), NULL)
+
+DEFHOOK
+(builtin_mul_widen_odd,
+ "",
+ tree, (tree x), NULL)
+
+/* Cost of different vector/scalar statements in vectorization cost model.  */
+DEFHOOK
+(builtin_vectorization_cost,
+ "",
+ int, (enum vect_cost_for_stmt type_of_cost),
+ default_builtin_vectorization_cost)
+
+/* Return true if vector alignment is reachable (by peeling N
+   iterations) for the given type.  */
+DEFHOOK
+(vector_alignment_reachable,
+ "",
+ bool, (const_tree type, bool is_packed),
+ default_builtin_vector_alignment_reachable)
+
+/* Target builtin that implements vector permute.  */
+DEFHOOK
+(builtin_vec_perm,
+ "",
+ tree, (tree type, tree *mask_element_type), NULL)
+
+/* Return true if a vector created for builtin_vec_perm is valid.  */
+DEFHOOK
+(builtin_vec_perm_ok,
+ "",
+ bool, (tree vec_type, tree mask),
+ hook_bool_tree_tree_true)
+
+/* Return true if the target supports misaligned store/load of a
+   specific factor denoted in the third parameter.  The last parameter
+   is true if the access is defined in a packed struct.  */
+DEFHOOK
+(support_vector_misalignment,
+ "",
+ bool,
+ (enum machine_mode mode, const_tree type, int misalignment, bool is_packed),
+ default_builtin_support_vector_misalignment)
+
+HOOK_VECTOR_END (vectorize)
+
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_"
+
+/* The initial value of target_flags.  */
+DEFHOOKPOD
+(default_target_flags,
+ "",
+ int, 0)
+
+/* Allow target specific overriding of option settings after options have
+  been changed by an attribute or pragma or when it is reset at the
+  end of the code affected by an attribute or pragma.  */
+DEFHOOK
+(override_options_after_change,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Handle target switch CODE (an OPT_* value).  ARG is the argument
+   passed to the switch; it is NULL if no argument was.  VALUE is the
+   value of ARG if CODE specifies a UInteger option, otherwise it is
+   1 if the positive form of the switch was used and 0 if the negative
+   form was.  Return true if the switch was valid.  */
+DEFHOOK
+(handle_option,
+ "",
+ bool, (size_t code, const char *arg, int value),
+ hook_bool_size_t_constcharptr_int_true)
+
+/* ??? Documenting this hook requires a GFDL license grant.  */
+DEFHOOK_UNDOC
+(handle_ofast,
+ "Handle target-specific parts of specifying -Ofast.",
+ void, (void),
+ hook_void_void)
+
+/* Display extra, target specific information in response to a
+   --target-help switch.  */
+DEFHOOK
+(help,
+ "",
+ void, (void), NULL)
+
+DEFHOOK_UNDOC
+(eh_return_filter_mode,
+ "Return machine mode for filter value.",
+ enum machine_mode, (void),
+ default_eh_return_filter_mode)
+
+/* Return machine mode for libgcc expanded cmp instructions.  */
+DEFHOOK
+(libgcc_cmp_return_mode,
+ "",
+ enum machine_mode, (void),
+ default_libgcc_cmp_return_mode)
+
+/* Return machine mode for libgcc expanded shift instructions.  */
+DEFHOOK
+(libgcc_shift_count_mode,
+ "",
+ enum machine_mode, (void),
+ default_libgcc_shift_count_mode)
+
+/* Return machine mode to be used for _Unwind_Word type.  */
+DEFHOOK
+(unwind_word_mode,
+ "",
+ enum machine_mode, (void),
+ default_unwind_word_mode)
+
+/* Given two decls, merge their attributes and return the result.  */
+DEFHOOK
+(merge_decl_attributes,
+ "",
+ tree, (tree olddecl, tree newdecl),
+ merge_decl_attributes)
+
+/* Given two types, merge their attributes and return the result.  */
+DEFHOOK
+(merge_type_attributes,
+ "",
+ tree, (tree type1, tree type2),
+ merge_type_attributes)
+
+/* Table of machine attributes and functions to handle them.
+   Ignored if NULL.  */
+DEFHOOKPOD
+(attribute_table,
+ "",
+ const struct attribute_spec *, NULL)
+
+/* Return true iff attribute NAME expects a plain identifier as its first
+   argument.  */
+DEFHOOK
+(attribute_takes_identifier_p,
+ "",
+ bool, (const_tree name),
+ hook_bool_const_tree_false)
+
+/* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
+   one if they are compatible and two if they are nearly compatible
+   (which causes a warning to be generated).  */
+DEFHOOK
+(comp_type_attributes,
+ "",
+ int, (const_tree type1, const_tree type2),
+ hook_int_const_tree_const_tree_1)
+
+/* Assign default attributes to the newly defined TYPE.  */
+DEFHOOK
+(set_default_type_attributes,
+ "",
+ void, (tree type),
+ hook_void_tree)
+
+/* Insert attributes on the newly created DECL.  */
+DEFHOOK
+(insert_attributes,
+ "",
+ void, (tree node, tree *attr_ptr),
+ hook_void_tree_treeptr)
+
+/* Return true if FNDECL (which has at least one machine attribute)
+   can be inlined despite its machine attributes, false otherwise.  */
+DEFHOOK
+(function_attribute_inlinable_p,
+ "",
+ bool, (const_tree fndecl),
+ hook_bool_const_tree_false)
+
+/* Return true if bitfields in RECORD_TYPE should follow the
+   Microsoft Visual C++ bitfield layout rules.  */
+DEFHOOK
+(ms_bitfield_layout_p,
+ "",
+ bool, (const_tree record_type),
+ hook_bool_const_tree_false)
+
+/* True if the target supports decimal floating point.  */
+DEFHOOK
+(decimal_float_supported_p,
+ "",
+ bool, (void),
+ default_decimal_float_supported_p)
+
+/* True if the target supports fixed-point.  */
+DEFHOOK
+(fixed_point_supported_p,
+ "",
+ bool, (void),
+ default_fixed_point_supported_p)
+
+/* Return true if anonymous bitfields affect structure alignment.  */
+DEFHOOK
+(align_anon_bitfield,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Return true if volatile bitfields should use the narrowest type possible.
+   Return false if they should use the container type.  */
+DEFHOOK
+(narrow_volatile_bitfield,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Set up target-specific built-in functions.  */
+DEFHOOK
+(init_builtins,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Initialize (if INITIALIZE_P is true) and return the target-specific
+   built-in function decl for CODE.
+   Return NULL if that is not possible.  Return error_mark_node if CODE
+   is outside of the range of valid target builtin function codes.  */
+DEFHOOK
+(builtin_decl,
+ "",
+ tree, (unsigned code, bool initialize_p), NULL)
+
+/* Expand a target-specific builtin.  */
+DEFHOOK
+(expand_builtin,
+ "",
+ rtx,
+ (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore),
+ default_expand_builtin)
+
+/* Select a replacement for a target-specific builtin.  This is done
+   *before* regular type checking, and so allows the target to
+   implement a crude form of function overloading.  The result is a
+   complete expression that implements the operation.  PARAMS really
+   has type VEC(tree,gc)*, but we don't want to include tree.h here.  */
+ /* ??? params is called differently in the documentation, and we can't
+    fix that because of GPL / GFDL incompatibility.  */
+DEFHOOK_UNDOC
+(resolve_overloaded_builtin,
+ "",
+ tree, (unsigned int /*location_t*/ loc, tree fndecl, void *params), NULL)
+
+/* Fold a target-specific builtin.  */
+/* ??? The documentation uses a different name for nargs.  */
+DEFHOOK_UNDOC
+(fold_builtin,
+ "",
+ tree, (tree fndecl, int nargs, tree *argp, bool ignore),
+ hook_tree_tree_int_treep_bool_null)
+
+/* Returns a code for a target-specific builtin that implements
+   reciprocal of the function, or NULL_TREE if not available.  */
+/* ??? The documentation uses a different name for tm_fn.  */
+DEFHOOK_UNDOC
+(builtin_reciprocal,
+ "",
+ tree, (unsigned fn, bool tm_fn, bool sqrt),
+ default_builtin_reciprocal)
+
+/* For a vendor-specific TYPE, return a pointer to a statically-allocated
+   string containing the C++ mangling for TYPE.  In all other cases, return
+   NULL.  */
+DEFHOOK
+(mangle_type,
+ "",
+ const char *, (const_tree type),
+ hook_constcharptr_const_tree_null)
+
+/* Make any adjustments to libfunc names needed for this target.  */
+DEFHOOK
+(init_libfuncs,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Given a decl, a section name, and whether the decl initializer
+   has relocs, choose attributes for the section.  */
+/* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
+DEFHOOK
+(section_type_flags,
+ "",
+ unsigned int, (tree decl, const char *name, int reloc),
+ default_section_type_flags)
+
+/* True if new jumps cannot be created, to replace existing ones or
+   not, at the current point in the compilation.  */
+DEFHOOK
+(cannot_modify_jumps_p,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Return a register class for which branch target register
+   optimizations should be applied.  */
+DEFHOOK
+(branch_target_register_class,
+ "",
+ enum reg_class, (void),
+ default_branch_target_register_class)
+
+/* Return true if branch target register optimizations should include
+   callee-saved registers that are not already live during the current
+   function.  AFTER_PE_GEN is true if prologues and epilogues have
+   already been generated.  */
+DEFHOOK
+(branch_target_register_callee_saved,
+ "",
+ bool, (bool after_prologue_epilogue_gen),
+ hook_bool_bool_false)
+
+/* Return true if the target supports conditional execution.  */
+DEFHOOK
+(have_conditional_execution,
+ "",
+ bool, (void),
+ default_have_conditional_execution)
+
+/* Return a new value for loop unroll size.  */
+DEFHOOK
+(loop_unroll_adjust,
+ "",
+ unsigned, (unsigned nunroll, struct loop *loop),
+ NULL)
+
+/* True if the constant X cannot be placed in the constant pool.  */
+DEFHOOK
+(cannot_force_const_mem,
+ "",
+ bool, (rtx x),
+ hook_bool_rtx_false)
+
+DEFHOOK_UNDOC
+(cannot_copy_insn_p,
+ "True if the insn @var{x} cannot be duplicated.",
+ bool, (rtx), NULL)
+
+/* True if X is considered to be commutative.  */
+DEFHOOK
+(commutative_p,
+ "",
+ bool, (const_rtx x, int outer_code),
+ hook_bool_const_rtx_commutative_p)
+
+/* True if ADDR is an address-expression whose effect depends
+   on the mode of the memory reference it is used in.  */
+DEFHOOK
+(mode_dependent_address_p,
+ "",
+ bool, (const_rtx addr),
+ default_mode_dependent_address_p)
+
+/* Given an invalid address X for a given machine mode, try machine-specific
+   ways to make it legitimate.  Return X or an invalid address on failure.  */
+DEFHOOK
+(legitimize_address,
+ "",
+ rtx, (rtx x, rtx oldx, enum machine_mode mode),
+ default_legitimize_address)
+
+/* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
+DEFHOOK
+(delegitimize_address,
+ "",
+ rtx, (rtx x),
+ delegitimize_mem_from_attrs)
+
+/* Given an address RTX, say whether it is valid.  */
+DEFHOOK
+(legitimate_address_p,
+ "",
+ bool, (enum machine_mode mode, rtx x, bool strict),
+ default_legitimate_address_p)
+
+/* True if the given constant can be put into an object_block.  */
+DEFHOOK
+(use_blocks_for_constant_p,
+ "",
+ bool, (enum machine_mode mode, const_rtx x),
+ hook_bool_mode_const_rtx_false)
+
+/* The minimum and maximum byte offsets for anchored addresses.  */
+DEFHOOKPOD
+(min_anchor_offset,
+ "",
+ HOST_WIDE_INT, 0)
+
+DEFHOOKPOD
+(max_anchor_offset,
+ "",
+ HOST_WIDE_INT, 0)
+
+/* True if section anchors can be used to access the given symbol.  */
+DEFHOOK
+(use_anchors_for_symbol_p,
+ "",
+ bool, (const_rtx x),
+ default_use_anchors_for_symbol_p)
+
+/* True if it is OK to do sibling call optimization for the specified
+   call expression EXP.  DECL will be the called function, or NULL if
+   this is an indirect call.  */
+DEFHOOK
+(function_ok_for_sibcall,
+ "",
+ bool, (tree decl, tree exp),
+ hook_bool_tree_tree_false)
+
+/* Establish appropriate back-end context for processing the function
+   FNDECL.  The argument might be NULL to indicate processing at top
+   level, outside of any function scope.  */
+DEFHOOK
+(set_current_function,
+ "",
+ void, (tree decl), hook_void_tree)
+
+/* True if EXP should be placed in a "small data" section.  */
+DEFHOOK
+(in_small_data_p,
+ "",
+ bool, (const_tree exp),
+ hook_bool_const_tree_false)
+
+/* True if EXP names an object for which name resolution must resolve
+   to the current executable or shared library.  */
+DEFHOOK
+(binds_local_p,
+ "",
+ bool, (const_tree exp),
+ default_binds_local_p)
+
+/* Modify and return the identifier of a DECL's external name,
+   originally identified by ID, as required by the target,
+   (eg, append @nn to windows32 stdcall function names).
+   The default is to return ID without modification. */
+DEFHOOK
+(mangle_decl_assembler_name,
+ "",
+ tree, (tree decl, tree  id),
+ default_mangle_decl_assembler_name)
+
+/* Do something target-specific to record properties of the DECL into
+   the associated SYMBOL_REF.  */
+DEFHOOK
+(encode_section_info,
+ "",
+ void, (tree decl, rtx rtl, int new_decl_p),
+ default_encode_section_info)
+
+/* Undo the effects of encode_section_info on the symbol string.  */
+DEFHOOK
+(strip_name_encoding,
+ "",
+ const char *, (const char *name),
+ default_strip_name_encoding)
+
+/* If shift optabs for MODE are known to always truncate the shift count,
+   return the mask that they apply.  Return 0 otherwise.  */
+DEFHOOK
+(shift_truncation_mask,
+ "",
+ unsigned HOST_WIDE_INT, (enum machine_mode mode),
+ default_shift_truncation_mask)
+
+/* Return the number of divisions in the given MODE that should be present,
+   so that it is profitable to turn the division into a multiplication by
+   the reciprocal.  */
+DEFHOOK
+(min_divisions_for_recip_mul,
+ "",
+ unsigned int, (enum machine_mode mode),
+ default_min_divisions_for_recip_mul)
+
+/* If the representation of integral MODE is such that values are
+   always sign-extended to a wider mode MODE_REP then return
+   SIGN_EXTEND.  Return UNKNOWN otherwise.  */
+/* Note that the return type ought to be RTX_CODE, but that's not
+   necessarily defined at this point.  */
+DEFHOOK
+(mode_rep_extended,
+ "",
+ int, (enum machine_mode mode, enum machine_mode rep_mode),
+ default_mode_rep_extended)
+
+/* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
+DEFHOOK
+(valid_pointer_mode,
+ "",
+ bool, (enum machine_mode mode),
+ default_valid_pointer_mode)
+
+/* Support for named address spaces.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_ADDR_SPACE_"
+HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space)
+
+/* MODE to use for a pointer into another address space.  */
+DEFHOOK
+(pointer_mode,
+ "",
+ enum machine_mode, (addr_space_t address_space),
+ default_addr_space_pointer_mode)
+
+/* MODE to use for an address in another address space.  */
+DEFHOOK
+(address_mode,
+ "",
+ enum machine_mode, (addr_space_t address_space),
+ default_addr_space_address_mode)
+
+/* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
+   in another address space.  */
+DEFHOOK
+(valid_pointer_mode,
+ "",
+ bool, (enum machine_mode mode, addr_space_t as),
+ default_addr_space_valid_pointer_mode)
+
+/* True if an address is a valid memory address to a given named address
+   space for a given mode.  */
+DEFHOOK
+(legitimate_address_p,
+ "",
+ bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as),
+ default_addr_space_legitimate_address_p)
+
+/* Return an updated address to convert an invalid pointer to a named
+   address space to a valid one.  If NULL_RTX is returned use machine
+   independent methods to make the address valid.  */
+DEFHOOK
+(legitimize_address,
+ "",
+ rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as),
+ default_addr_space_legitimize_address)
+
+/* True if one named address space is a subset of another named address. */
+DEFHOOK
+(subset_p,
+ "",
+ bool, (addr_space_t superset, addr_space_t subset),
+ default_addr_space_subset_p)
+
+/* Function to convert an rtl expression from one address space to another.  */
+DEFHOOK
+(convert,
+ "",
+ rtx, (rtx op, tree from_type, tree to_type),
+ default_addr_space_convert)
+
+HOOK_VECTOR_END (addr_space)
+
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_"
+
+/* True if MODE is valid for the target.  By "valid", we mean able to
+   be manipulated in non-trivial ways.  In particular, this means all
+   the arithmetic is supported.  */
+DEFHOOK
+(scalar_mode_supported_p,
+ "",
+ bool, (enum machine_mode mode),
+ default_scalar_mode_supported_p)
+
+/* Similarly for vector modes.  "Supported" here is less strict.  At
+   least some operations are supported; need to check optabs or builtins
+   for further details.  */
+DEFHOOK
+(vector_mode_supported_p,
+ "",
+ bool, (enum machine_mode mode),
+ hook_bool_mode_false)
+
+/* Compute cost of moving data from a register of class FROM to one of
+   TO, using MODE.  */
+DEFHOOK
+(register_move_cost,
+ "",
+ int, (enum machine_mode mode, enum reg_class from, enum reg_class to),
+ default_register_move_cost)
+
+/* Compute cost of moving registers to/from memory.  */
+/* ??? Documenting the argument types for this hook requires a GFDL
+   license grant.  Also, the documentation uses a different name for RCLASS.  */
+DEFHOOK_UNDOC
+(memory_move_cost,
+ "",
+ int, (enum machine_mode mode, enum reg_class rclass, bool in),
+ default_memory_move_cost)
+
+/* True for MODE if the target expects that registers in this mode will
+   be allocated to registers in a small register class.  The compiler is
+   allowed to use registers explicitly used in the rtl as spill registers
+   but it should prevent extending the lifetime of these registers.  */
+DEFHOOK
+(small_register_classes_for_mode_p,
+ "",
+ bool, (enum machine_mode mode),
+ hook_bool_mode_false)
+
+/* Compute a (partial) cost for rtx X.  Return true if the complete
+   cost has been computed, and false if subexpressions should be
+   scanned.  In either case, *TOTAL contains the cost result.  */
+/* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
+   not necessarily defined at this point.  */
+DEFHOOK
+(rtx_costs,
+ "",
+ bool, (rtx x, int code, int outer_code, int *total, bool speed),
+ hook_bool_rtx_int_int_intp_bool_false)
+
+/* Compute the cost of X, used as an address.  Never called with
+   invalid addresses.  */
+DEFHOOK
+(address_cost,
+ "",
+ int, (rtx address, bool speed),
+ default_address_cost)
+
+/* Return where to allocate pseudo for a given hard register initial value.  */
+DEFHOOK
+(allocate_initial_value,
+ "",
+ rtx, (rtx hard_reg), NULL)
+
+/* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
+   FLAGS has the same meaning as in rtlanal.c: may_trap_p_1.  */
+DEFHOOK
+(unspec_may_trap_p,
+ "",
+ int, (const_rtx x, unsigned flags),
+ default_unspec_may_trap_p)
+
+/* 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 locations, or if the register should be
+   represented in more than one register in Dwarf.  Otherwise, this
+   hook should return NULL_RTX.  */
+DEFHOOK
+(dwarf_register_span,
+ "",
+ rtx, (rtx reg),
+ hook_rtx_rtx_null)
+
+/* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
+   entries not corresponding directly to registers below
+   FIRST_PSEUDO_REGISTER, this hook should generate the necessary
+   code, given the address of the table.  */
+DEFHOOK
+(init_dwarf_reg_sizes_extra,
+ "",
+ void, (tree address),
+ hook_void_tree)
+
+/* Fetch the fixed register(s) which hold condition codes, for
+   targets where it makes sense to look for duplicate assignments to
+   the condition codes.  This should return true if there is such a
+   register, false otherwise.  The arguments should be set to the
+   fixed register numbers.  Up to two condition code registers are
+   supported.  If there is only one for this target, the int pointed
+   at by the second argument should be set to -1.  */
+DEFHOOK
+(fixed_condition_code_regs,
+ "",
+ bool, (unsigned int *p1, unsigned int *p2),
+ hook_bool_uintp_uintp_false)
+
+/* If two condition code modes are compatible, return a condition
+     code mode which is compatible with both, such that a comparison
+     done in the returned mode will work for both of the original
+     modes.  If the condition code modes are not compatible, return
+     VOIDmode.  */
+DEFHOOK
+(cc_modes_compatible,
+ "",
+ enum machine_mode, (enum machine_mode m1, enum machine_mode m2),
+ default_cc_modes_compatible)
+
+/* Do machine-dependent code transformations.  Called just before
+     delayed-branch scheduling.  */
+DEFHOOK
+(machine_dependent_reorg,
+ "",
+ void, (void), NULL)
+
+/* Create the __builtin_va_list type.  */
+DEFHOOK
+(build_builtin_va_list,
+ "",
+ tree, (void),
+ std_build_builtin_va_list)
+
+/* Enumerate the va list variants.  */
+/* ??? The documentation gets the type of ptree wrong.  */
+DEFHOOK_UNDOC
+(enum_va_list_p,
+ "",
+ int, (int idx, const char **pname, tree *ptree),
+ NULL)
+
+/* Get the cfun/fndecl calling abi __builtin_va_list type.  */
+DEFHOOK
+(fn_abi_va_list,
+ "",
+ tree, (tree fndecl),
+ std_fn_abi_va_list)
+
+/* Get the __builtin_va_list type dependent on input type.  */
+DEFHOOK
+(canonical_va_list_type,
+ "",
+ tree, (tree type),
+ std_canonical_va_list_type)
+
+/* ??? Documenting this hook requires a GFDL license grant.  */
+DEFHOOK_UNDOC
+(expand_builtin_va_start,
+"Expand the @code{__builtin_va_start} builtin.",
+ void, (tree valist, rtx nextarg), NULL)
+
+/* Gimplifies a VA_ARG_EXPR.  */
+DEFHOOK
+(gimplify_va_arg_expr,
+ "",
+ tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p),
+ std_gimplify_va_arg_expr)
+
+/* Validity-checking routines for PCH files, target-specific.
+   get_pch_validity returns a pointer to the data to be stored,
+   and stores the size in its argument.  pch_valid_p gets the same
+   information back and returns NULL if the PCH is valid,
+   or an error message if not.  */
+DEFHOOK
+(get_pch_validity,
+ "",
+ void *, (size_t *sz),
+ default_get_pch_validity)
+
+DEFHOOK
+(pch_valid_p,
+ "",
+ const char *, (const void *data, size_t sz),
+ default_pch_valid_p)
+
+/* If nonnull, this function checks whether a PCH file with the
+   given set of target flags can be used.  It returns NULL if so,
+   otherwise it returns an error message.  */
+DEFHOOK
+(check_pch_target_flags,
+ "",
+ const char *, (int pch_flags), NULL)
+
+/* True if the compiler should give an enum type only as many
+   bytes as it takes to represent the range of possible values of
+   that type.  */
+DEFHOOK
+(default_short_enums,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* This target hook returns an rtx that is used to store the address
+   of the current frame into the built-in setjmp buffer.  */
+DEFHOOK
+(builtin_setjmp_frame_value,
+ "",
+ rtx, (void),
+ default_builtin_setjmp_frame_value)
+
+/* This target hook should add STRING_CST trees for any hard regs
+   the port wishes to automatically clobber for an asm.  */
+DEFHOOK
+(md_asm_clobbers,
+ "",
+ tree, (tree outputs, tree inputs, tree clobbers),
+ hook_tree_tree_tree_tree_3rd_identity)
+
+/* This target hook allows the backend to specify a calling convention
+   in the debug information.  This function actually returns an
+   enum dwarf_calling_convention, but because of forward declarations
+   and not wanting to include dwarf2.h everywhere target.h is included
+   the function is being declared as an int.  */
+DEFHOOK
+(dwarf_calling_convention,
+ "",
+ int, (const_tree function),
+ hook_int_const_tree_0)
+
+/* This target hook allows the backend to emit frame-related insns that
+   contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
+   engine will invoke it on insns of the form
+     (set (reg) (unspec [...] UNSPEC_INDEX))
+   and
+     (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
+   to let the backend emit the call frame instructions.  */
+DEFHOOK
+(dwarf_handle_frame_unspec,
+ "",
+ void, (const char *label, rtx pattern, int index), NULL)
+
+/* ??? Documenting this hook requires a GFDL license grant.  */
+DEFHOOK_UNDOC
+(stdarg_optimize_hook,
+"Perform architecture specific checking of statements gimplified\
+ from @code{VA_ARG_EXPR}.  @var{stmt} is the statement.  Returns true if\
+ the statement doesn't need to be checked for @code{va_list} references.",
+ bool, (struct stdarg_info *ai, const_gimple stmt), NULL)
+
+/* This target hook allows the operating system to override the DECL
+   that represents the external variable that contains the stack
+   protection guard variable.  The type of this DECL is ptr_type_node.  */
+DEFHOOK
+(stack_protect_guard,
+ "",
+ tree, (void),
+ default_stack_protect_guard)
+
+/* This target hook allows the operating system to override the CALL_EXPR
+   that is invoked when a check vs the guard variable fails.  */
+DEFHOOK
+(stack_protect_fail,
+ "",
+ tree, (void),
+ default_external_stack_protect_fail)
+
+/* Returns NULL if target supports the insn within a doloop block,
+   otherwise it returns an error message.  */
+DEFHOOK
+(invalid_within_doloop,
+ "",
+ const char *, (const_rtx insn),
+ default_invalid_within_doloop)
+
+DEFHOOK
+(valid_dllimport_attribute_p,
+"@var{decl} is a variable or function with @code{__attribute__((dllimport))}\
+ specified.  Use this hook if the target needs to add extra validation\
+ checks to @code{handle_dll_attribute}.",
+ bool, (const_tree decl),
+ hook_bool_const_tree_true)
+
+/* If non-zero, align constant anchors in CSE to a multiple of this
+   value.  */
+DEFHOOKPOD
+(const_anchor,
+ "",
+ unsigned HOST_WIDE_INT, 0)
+
+/* Functions relating to calls - argument passing, returns, etc.  */
+/* Members of struct call have no special macro prefix.  */
+HOOK_VECTOR (TARGET_CALLS, calls)
+
+DEFHOOK
+(promote_function_mode,
+ "",
+ enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp,
+		     const_tree funtype, int for_return),
+ default_promote_function_mode)
+
+DEFHOOK
+(promote_prototypes,
+ "",
+ bool, (const_tree fntype),
+ hook_bool_const_tree_false)
+
+DEFHOOK
+(struct_value_rtx,
+ "",
+ rtx, (tree fndecl, int incoming),
+ hook_rtx_tree_int_null)
+DEFHOOK
+(return_in_memory,
+ "",
+ bool, (const_tree type, const_tree fntype),
+ default_return_in_memory)
+
+DEFHOOK
+(return_in_msb,
+ "",
+ bool, (const_tree type),
+ hook_bool_const_tree_false)
+
+/* Return true if a parameter must be passed by reference.  TYPE may
+   be null if this is a libcall.  CA may be null if this query is
+   from __builtin_va_arg.  */
+/* ??? The documentation disagrees on the type of 'type'.  */
+DEFHOOK_UNDOC
+(pass_by_reference,
+ "",
+ bool,
+ (CUMULATIVE_ARGS *cum, enum machine_mode mode, const_tree type, bool named),
+ hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
+
+DEFHOOK
+(expand_builtin_saveregs,
+ "",
+ rtx, (void),
+ default_expand_builtin_saveregs)
+
+/* Returns pretend_argument_size.  */
+DEFHOOK
+(setup_incoming_varargs,
+ "",
+ void, (CUMULATIVE_ARGS *args_so_far, enum machine_mode mode, tree type,
+	int *pretend_args_size, int second_time),
+ default_setup_incoming_varargs)
+
+DEFHOOK
+(strict_argument_naming,
+ "",
+ bool, (CUMULATIVE_ARGS *ca),
+ hook_bool_CUMULATIVE_ARGS_false)
+
+/* Returns true if we should use
+   targetm.calls.setup_incoming_varargs() and/or
+   targetm.calls.strict_argument_naming().  */
+DEFHOOK
+(pretend_outgoing_varargs_named,
+ "",
+ bool, (CUMULATIVE_ARGS *ca),
+ default_pretend_outgoing_varargs_named)
+
+/* Given a complex type T, return true if a parameter of type T
+   should be passed as two scalars.  */
+DEFHOOK
+(split_complex_arg,
+ "",
+ bool, (const_tree type), NULL)
+
+/* Return true if type T, mode MODE, may not be passed in registers,
+   but must be passed on the stack.  */
+/* ??? This predicate should be applied strictly after pass-by-reference.
+   Need audit to verify that this is the case.  */
+DEFHOOK
+(must_pass_in_stack,
+ "",
+ bool, (enum machine_mode mode, const_tree type),
+ must_pass_in_stack_var_size_or_pad)
+
+/* Return true if type TYPE, mode MODE, which is passed by reference,
+   should have the object copy generated by the callee rather than
+   the caller.  It is never called for TYPE requiring constructors.  */
+DEFHOOK
+(callee_copies,
+ "",
+ bool,
+ (CUMULATIVE_ARGS *cum, enum machine_mode mode, const_tree type, bool named),
+ hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false)
+
+/* Return zero for arguments passed entirely on the stack or entirely
+   in registers.  If passed in both, return the number of bytes passed
+   in registers; the balance is therefore passed on the stack.  */
+DEFHOOK
+(arg_partial_bytes,
+ "",
+ int, (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type, bool named),
+ hook_int_CUMULATIVE_ARGS_mode_tree_bool_0)
+
+/* Return the diagnostic message string if function without a prototype
+   is not allowed for this 'val' argument; NULL otherwise. */
+DEFHOOK
+(invalid_arg_for_unprototyped_fn,
+ "",
+ const char *, (const_tree typelist, const_tree funcdecl, const_tree val),
+ hook_invalid_arg_for_unprototyped_fn)
+
+/* Return an rtx for the return value location of the function
+   specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
+DEFHOOK
+(function_value,
+ "",
+ rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing),
+ default_function_value)
+
+/* Return the rtx for the result of a libcall of mode MODE,
+   calling the function FN_NAME.  */
+DEFHOOK
+(libcall_value,
+ "",
+ rtx, (enum machine_mode mode, const_rtx fun),
+ default_libcall_value)
+
+/* Return true if REGNO is a possible register number for
+   a function value as seen by the caller.  */
+DEFHOOK
+(function_value_regno_p,
+ "",
+ bool, (const unsigned int regno),
+ default_function_value_regno_p)
+
+/* ??? Documenting this hook requires a GFDL license grant.  */
+DEFHOOK_UNDOC
+(internal_arg_pointer,
+"Return an rtx for the argument pointer incoming to the\
+ current function.",
+ rtx, (void),
+ default_internal_arg_pointer)
+
+/* Update the current function stack boundary if needed.  */
+DEFHOOK
+(update_stack_boundary,
+ "",
+ void, (void), NULL)
+
+/* Handle stack alignment and return an rtx for Dynamic Realign
+   Argument Pointer if necessary.  */
+DEFHOOK
+(get_drap_rtx,
+ "",
+ rtx, (void), NULL)
+
+/* Return true if all function parameters should be spilled to the
+   stack.  */
+DEFHOOK
+(allocate_stack_slots_for_args,
+ "",
+ bool, (void),
+ hook_bool_void_true)
+
+/* Return an rtx for the static chain for FNDECL.  If INCOMING_P is true,
+       then it should be for the callee; otherwise for the caller.  */
+DEFHOOK
+(static_chain,
+ "",
+ rtx, (const_tree fndecl, bool incoming_p),
+ default_static_chain)
+
+/* Fill in the trampoline at MEM with a call to FNDECL and a
+   static chain value of CHAIN.  */
+DEFHOOK
+(trampoline_init,
+ "",
+ void, (rtx m_tramp, tree fndecl, rtx static_chain),
+ default_trampoline_init)
+
+/* Adjust the address of the trampoline in a target-specific way.  */
+DEFHOOK
+(trampoline_adjust_address,
+ "",
+ rtx, (rtx addr), NULL)
+HOOK_VECTOR_END (calls)
+
+/* Return the diagnostic message string if conversion from FROMTYPE
+   to TOTYPE is not allowed, NULL otherwise.  */
+DEFHOOK
+(invalid_conversion,
+ "",
+ const char *, (const_tree fromtype, const_tree totype),
+ hook_constcharptr_const_tree_const_tree_null)
+
+/* Return the diagnostic message string if the unary operation OP is
+   not permitted on TYPE, NULL otherwise.  */
+DEFHOOK
+(invalid_unary_op,
+ "",
+ const char *, (int op, const_tree type),
+ hook_constcharptr_int_const_tree_null)
+
+/* Return the diagnostic message string if the binary operation OP
+   is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
+DEFHOOK
+(invalid_binary_op,
+ "",
+ const char *, (int op, const_tree type1, const_tree type2),
+ hook_constcharptr_int_const_tree_const_tree_null)
+
+/* Return the diagnostic message string if TYPE is not valid as a
+   function parameter type, NULL otherwise.  */
+DEFHOOK
+(invalid_parameter_type,
+ "",
+ const char *, (const_tree type),
+ hook_constcharptr_const_tree_null)
+
+/* Return the diagnostic message string if TYPE is not valid as a
+   function return type, NULL otherwise.  */
+DEFHOOK
+(invalid_return_type,
+ "",
+ const char *, (const_tree type),
+ hook_constcharptr_const_tree_null)
+
+/* If values of TYPE are promoted to some other type when used in
+   expressions (analogous to the integer promotions), return that type,
+   or NULL_TREE otherwise.  */
+DEFHOOK
+(promoted_type,
+ "",
+ tree, (const_tree type),
+ hook_tree_const_tree_null)
+
+/* Convert EXPR to TYPE, if target-specific types with special conversion
+   rules are involved.  Return the converted expression, or NULL to apply
+   the standard conversion rules.  */
+DEFHOOK
+(convert_to_type,
+ "",
+ tree, (tree type, tree expr),
+ hook_tree_tree_tree_null)
+
+/* Return the array of IRA cover classes for the current target.  */
+DEFHOOK
+(ira_cover_classes,
+ "",
+ const enum reg_class *, (void),
+ default_ira_cover_classes)
+
+/* Return the class for a secondary reload, and fill in extra information.  */
+DEFHOOK
+(secondary_reload,
+ "",
+ enum reg_class,
+ (bool in_p, rtx x, enum reg_class reload_class, enum machine_mode reload_mode,
+  secondary_reload_info *sri),
+ default_secondary_reload)
+
+/* This target hook allows the backend to perform additional
+   processing while initializing for variable expansion.  */
+DEFHOOK
+(expand_to_rtl_hook,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* This target hook allows the backend to perform additional
+   instantiations on rtx that are not actually in insns yet,
+   but will be later.  */
+DEFHOOK
+(instantiate_decls,
+ "",
+ void, (void),
+ hook_void_void)
+
+/* Return true if is OK to use a hard register REGNO as scratch register
+   in peephole2.  */
+DEFHOOK
+(hard_regno_scratch_ok,
+ "",
+ bool, (unsigned int regno),
+ default_hard_regno_scratch_ok)
+
+/* Return the smallest number of different values for which it is best to
+   use a jump-table instead of a tree of conditional branches.  */
+DEFHOOK
+(case_values_threshold,
+ "",
+ unsigned int, (void),
+ default_case_values_threshold)
+
+/* Retutn true if a function must have and use a frame pointer.  */
+DEFHOOK
+(frame_pointer_required,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Returns true if the compiler is allowed to try to replace register number
+   from-reg with register number to-reg.  */
+DEFHOOK
+(can_eliminate,
+ "",
+ bool, (const int from_reg, const int to_reg),
+ hook_bool_const_int_const_int_true)
+
+/* Functions specific to the C family of frontends.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_C_"
+HOOK_VECTOR (TARGET_C, c)
+
+/* ??? Documenting this hook requires a GFDL license grant.  */
+DEFHOOK_UNDOC
+(mode_for_suffix,
+"Return machine mode for non-standard constant literal suffix @var{c},\
+ or VOIDmode if non-standard suffixes are unsupported.",
+ enum machine_mode, (char c),
+ default_mode_for_suffix)
+
+HOOK_VECTOR_END (c)
+
+/* Functions specific to the C++ frontend.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_CXX_"
+HOOK_VECTOR (TARGET_CXX, cxx)
+
+/* Return the integer type used for guard variables.  */
+DEFHOOK
+(guard_type,
+ "",
+ tree, (void),
+ default_cxx_guard_type)
+
+/* Return true if only the low bit of the guard should be tested.  */
+DEFHOOK
+(guard_mask_bit,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Returns the size of the array cookie for an array of type.  */
+DEFHOOK
+(get_cookie_size,
+ "",
+ tree, (tree type),
+ default_cxx_get_cookie_size)
+
+/* Returns true if the element size should be stored in the array cookie.  */
+DEFHOOK
+(cookie_has_size,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Allows backends to perform additional processing when
+   deciding if a class should be exported or imported.  */
+DEFHOOK
+(import_export_class,
+ "",
+ int, (tree type, int import_export), NULL)
+
+/* Returns true if constructors and destructors return "this".  */
+DEFHOOK
+(cdtor_returns_this,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Returns true if the key method for a class can be an inline
+   function, so long as it is not declared inline in the class
+   itself.  Returning true is the behavior required by the Itanium C++ ABI.  */
+DEFHOOK
+(key_method_may_be_inline,
+ "",
+ bool, (void),
+ hook_bool_void_true)
+
+DEFHOOK
+(determine_class_data_visibility,
+"@var{decl} is a virtual table, virtual table table, typeinfo object,\
+ or other similar implicit class data object that will be emitted with\
+ external linkage in this translation unit.  No ELF visibility has been\
+ explicitly specified.  If the target needs to specify a visibility\
+ other than that of the containing class, use this hook to set\
+ @code{DECL_VISIBILITY} and @code{DECL_VISIBILITY_SPECIFIED}.",
+ void, (tree decl),
+ hook_void_tree)
+
+/* 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 classes whose virtual table will be emitted in
+   only one translation unit will not be COMDAT.  */
+DEFHOOK
+(class_data_always_comdat,
+ "",
+ bool, (void),
+ hook_bool_void_true)
+
+/* Returns true (the default) if the RTTI for the basic types,
+   which is always defined in the C++ runtime, should be COMDAT;
+   false if it should not be COMDAT.  */
+DEFHOOK
+(library_rtti_comdat,
+ "",
+ bool, (void),
+ hook_bool_void_true)
+
+/* Returns true if __aeabi_atexit should be used to register static
+   destructors.  */
+DEFHOOK
+(use_aeabi_atexit,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+/* Returns true if target may use atexit in the same manner as
+   __cxa_atexit  to register static destructors.  */
+DEFHOOK
+(use_atexit_for_cxa_atexit,
+ "",
+ bool, (void),
+ hook_bool_void_false)
+
+DEFHOOK
+(adjust_class_at_definition,
+"@var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just\
+ been defined.  Use this hook to make adjustments to the class (eg, tweak\
+ visibility or perform any other required target modifications).",
+ void, (tree type),
+ hook_void_tree)
+
+HOOK_VECTOR_END (cxx)
+
+/* Functions and data for emulated TLS support.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_EMUTLS_"
+HOOK_VECTOR (TARGET_EMUTLS, emutls)
+
+/* Name of the address and common functions.  */
+DEFHOOKPOD
+(get_address,
+ "",
+ const char *, "__builtin___emutls_get_address")
+
+DEFHOOKPOD
+(register_common,
+ "",
+ const char *, "__builtin___emutls_register_common")
+
+/* Prefixes for proxy variable and template.  */
+DEFHOOKPOD
+(var_section,
+ "",
+ const char *, NULL)
+
+DEFHOOKPOD
+(tmpl_section,
+ "",
+ const char *, NULL)
+
+/* Prefixes for proxy variable and template.  */
+DEFHOOKPOD
+(var_prefix,
+ "",
+ const char *, NULL)
+
+DEFHOOKPOD
+(tmpl_prefix,
+ "",
+ const char *, NULL)
+
+/* Function to generate field definitions of the proxy variable.  */
+DEFHOOK
+(var_fields,
+ "",
+ tree, (tree type, tree *name),
+ default_emutls_var_fields)
+
+/* Function to initialize a proxy variable.  */
+DEFHOOK
+(var_init,
+ "",
+ tree, (tree var, tree decl, tree tmpl_addr),
+ default_emutls_var_init)
+
+/* Whether we are allowed to alter the usual alignment of the
+   proxy variable.  */
+DEFHOOKPOD
+(var_align_fixed,
+ "",
+ bool, false)
+
+/* Whether we can emit debug information for TLS vars.  */
+DEFHOOKPOD
+(debug_form_tls_address,
+ "",
+ bool, false)
+
+HOOK_VECTOR_END (emutls)
+
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_OPTION_"
+HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks)
+
+/* Function to validate the attribute((option(...))) strings or NULL.  If
+   the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
+   be filled in in the function decl node.  */
+DEFHOOK
+(valid_attribute_p,
+ "",
+ bool, (tree fndecl, tree name, tree args, int flags),
+ default_target_option_valid_attribute_p)
+
+/* Function to save any extra target state in the target options structure.  */
+DEFHOOK
+(save,
+ "",
+ void, (struct cl_target_option *ptr), NULL)
+
+/* Function to restore any extra target state from the target options
+   structure.  */
+DEFHOOK
+(restore,
+ "",
+ void, (struct cl_target_option *ptr), NULL)
+
+/* Function to print any extra target state from the target options
+   structure.  */
+DEFHOOK
+(print,
+ "",
+ void, (FILE *file, int indent, struct cl_target_option *ptr), NULL)
+
+/* Function to parse arguments to be validated for #pragma option, and to
+   change the state if the options are valid.  If the first argument is
+   NULL, the second argument specifies the default options to use.  Return
+   true if the options are valid, and set the current state.  */
+/* ??? The documentation disagrees on the signature of this hook.  */
+DEFHOOK_UNDOC
+(pragma_parse,
+ "",
+ bool, (tree args, tree pop_target),
+ default_target_option_pragma_parse)
+
+/* Function to determine if one function can inline another function.  */
+#undef HOOK_PREFIX
+#define HOOK_PREFIX "TARGET_"
+DEFHOOK
+(can_inline_p,
+ "",
+ bool, (tree caller, tree callee),
+ default_target_can_inline_p)
+
+HOOK_VECTOR_END (target_option)
+
+/* For targets that need to mark extra registers as live on entry to
+   the function, they should define this target hook and set their
+   bits in the bitmap passed in. */
+DEFHOOK
+(extra_live_on_entry,
+ "",
+ void, (bitmap regs),
+ hook_void_bitmap)
+
+/* Leave the boolean fields at the end.  */
+
+/* True if unwinding tables should be generated by default.  */
+DEFHOOKPOD
+(unwind_tables_default,
+ "",
+ bool, false)
+
+/* True if arbitrary sections are supported.  */
+DEFHOOKPOD
+(have_named_sections,
+ "",
+ bool, false)
+
+/* True if we can create zeroed data by switching to a BSS section
+   and then using ASM_OUTPUT_SKIP to allocate the space.  */
+DEFHOOKPOD
+(have_switchable_bss_sections,
+ "",
+ bool, false)
+
+/* True if "native" constructors and destructors are supported,
+   false if we're using collect2 for the job.  */
+DEFHOOKPOD
+(have_ctors_dtors,
+ "",
+ bool, false)
+
+/* True if thread-local storage is supported.  */
+DEFHOOKPOD
+(have_tls,
+ "",
+ bool, false)
+
+/* True if a small readonly data section is supported.  */
+DEFHOOKPOD
+(have_srodata_section,
+ "",
+ bool, false)
+
+/* True if EH frame info sections should be zero-terminated.  */
+DEFHOOKPOD
+(terminate_dw2_eh_frame_info,
+ "",
+ bool, true)
+
+/* True if #NO_APP should be emitted at the beginning of assembly output.  */
+DEFHOOKPOD
+(asm_file_start_app_off,
+ "",
+ bool, false)
+
+/* True if output_file_directive should be called for main_input_filename
+   at the beginning of assembly output.  */
+DEFHOOKPOD
+(asm_file_start_file_directive,
+ "",
+ bool, false)
+
+DEFHOOKPOD
+(handle_pragma_extern_prefix,
+"True if @code{#pragma extern_prefix} is to be supported.",
+ bool, 0)
+
+/* True if the target is allowed to reorder memory accesses unless
+   synchronization is explicitly requested.  */
+DEFHOOKPOD
+(relaxed_ordering,
+ "",
+ bool, false)
+
+/* Returns true if we should generate exception tables for use with the
+   ARM EABI.  The effects the encoding of function exception specifications.  */
+DEFHOOKPOD
+(arm_eabi_unwinder,
+ "",
+ bool, false)
+
+/* Leave the boolean fields at the end.  */
+
+/* Empty macro arguments are undefined in C90, so use an empty macro.  */
+#define C90_EMPTY_HACK
+/* Close the 'struct gcc_target' definition.  */
+HOOK_VECTOR_END (C90_EMPTY_HACK)
+
+HOOK_VECTOR (TARGETCM_INITIALIZER, gcc_targetcm)
+
+/* Handle target switch CODE (an OPT_* value).  ARG is the argument
+   passed to the switch; it is NULL if no argument was.  VALUE is the
+   value of ARG if CODE specifies a UInteger option, otherwise it is
+   1 if the positive form of the switch was used and 0 if the negative
+   form was.  Return true if the switch was valid.  */
+DEFHOOK
+(handle_c_option,
+ "",
+ bool, (size_t code, const char *arg, int value),
+ default_handle_c_option)
+
+HOOK_VECTOR_END (C90_EMPTY_HACK)
Index: gcc/target.h
===================================================================
--- gcc/target.h	(revision 161494)
+++ gcc/target.h	(working copy)
@@ -128,1185 +128,15 @@  enum vect_cost_for_stmt
 };
 
 /* The target structure.  This holds all the backend hooks.  */
+#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) TYPE NAME;
+#define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) TYPE (* NAME) PARAMS;
+#define DEFHOOK_UNDOC DEFHOOK
+#define HOOKSTRUCT(FRAGMENT) FRAGMENT
 
-struct gcc_target
-{
-  /* Functions that output assembler for the target.  */
-  struct asm_out
-  {
-    /* Opening and closing parentheses for asm expression grouping.  */
-    const char *open_paren, *close_paren;
-
-    /* Assembler instructions for creating various kinds of integer object.  */
-    const char *byte_op;
-    struct asm_int_op aligned_op, unaligned_op;
-
-    /* Try to output the assembler code for an integer object whose
-       value is given by X.  SIZE is the size of the object in bytes and
-       ALIGNED_P indicates whether it is aligned.  Return true if
-       successful.  Only handles cases for which BYTE_OP, ALIGNED_OP
-       and UNALIGNED_OP are NULL.  */
-    bool (* integer) (rtx x, unsigned int size, int aligned_p);
-
-    /* Output code that will globalize a label.  */
-    void (* globalize_label) (FILE *, const char *);
-
-    /* Output code that will globalize a declaration.  */
-    void (* globalize_decl_name) (FILE *, tree);
-
-    /* Output code that will emit a label for unwind info, if this
-       target requires such labels.  Second argument is the decl the
-       unwind info is associated with, third is a boolean: true if
-       this is for exception handling, fourth is a boolean: true if
-       this is only a placeholder for an omitted FDE.  */
-    void (* unwind_label) (FILE *, tree, int, int);
-
-    /* Output code that will emit a label to divide up the exception
-       table.  */
-    void (* except_table_label) (FILE *);
-
-    /* Emit any directives required to unwind this instruction.  */
-    void (* unwind_emit) (FILE *, rtx);
-
-    /* Output an internal label.  */
-    void (* internal_label) (FILE *, const char *, unsigned long);
-
-    /* Output label for the constant.  */
-    void (* declare_constant_name) (FILE *, const char *, const_tree, 
-				    HOST_WIDE_INT);
-
-    /* Emit a ttype table reference to a typeinfo object.  */
-    bool (* ttype) (rtx);
-
-    /* Emit an assembler directive to set visibility for the symbol
-       associated with the tree decl.  */
-    void (* visibility) (tree, int);
-
-    /* Output the assembler code for entry to a function.  */
-    void (* function_prologue) (FILE *, HOST_WIDE_INT);
-
-    /* Output the assembler code for end of prologue.  */
-    void (* function_end_prologue) (FILE *);
-
-    /* Output the assembler code for start of epilogue.  */
-    void (* function_begin_epilogue) (FILE *);
-
-    /* Output the assembler code for function exit.  */
-    void (* function_epilogue) (FILE *, HOST_WIDE_INT);
-
-    /* Initialize target-specific sections.  */
-    void (* init_sections) (void);
-
-    /* Tell assembler to change to section NAME with attributes FLAGS.
-       If DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with
-       which this section is associated.  */
-    void (* named_section) (const char *name, unsigned int flags, tree decl);
-
-    /* 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
-       local relocations should be placed in a read-write section.  */
-    int (*reloc_rw_mask) (void);
-
-    /* Return a section for EXP.  It may be a DECL or a constant.  RELOC
-       is nonzero if runtime relocations must be applied; bit 1 will be
-       set if the runtime relocations require non-local name resolution.
-       ALIGN is the required alignment of the data.  */
-    section *(* select_section) (tree, int, unsigned HOST_WIDE_INT);
-
-    /* Return a section for X.  MODE is X's mode and ALIGN is its
-       alignment in bits.  */
-    section *(* select_rtx_section) (enum machine_mode, rtx,
-				     unsigned HOST_WIDE_INT);
-
-    /* Select a unique section name for DECL.  RELOC is the same as
-       for SELECT_SECTION.  */
-    void (* unique_section) (tree, int);
-
-    /* Return the readonly data section associated with function DECL.  */
-    section *(* function_rodata_section) (tree);
-
-    /* Output a constructor for a symbol with a given priority.  */
-    void (* constructor) (rtx, int);
-
-    /* Output a destructor for a symbol with a given priority.  */
-    void (* destructor) (rtx, int);
-
-    /* Output the assembler code for a thunk function.  THUNK_DECL is the
-       declaration for the thunk function itself, FUNCTION is the decl for
-       the target function.  DELTA is an immediate constant offset to be
-       added to THIS.  If VCALL_OFFSET is nonzero, the word at
-       *(*this + vcall_offset) should be added to THIS.  */
-    void (* output_mi_thunk) (FILE *file, tree thunk_decl,
-			      HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
-			      tree function_decl);
-
-    /* Determine whether output_mi_thunk would succeed.  */
-    /* ??? Ideally, this hook would not exist, and success or failure
-       would be returned from output_mi_thunk directly.  But there's
-       too much undo-able setup involved in invoking output_mi_thunk.
-       Could be fixed by making output_mi_thunk emit rtl instead of
-       text to the output file.  */
-    bool (* can_output_mi_thunk) (const_tree thunk_decl, HOST_WIDE_INT delta,
-				  HOST_WIDE_INT vcall_offset,
-				  const_tree function_decl);
-
-    /* Output any boilerplate text needed at the beginning of a
-       translation unit.  */
-    void (*file_start) (void);
-
-    /* Output any boilerplate text needed at the end of a
-       translation unit.  */
-    void (*file_end) (void);
-
-    /* Output any boilerplate text needed at the beginning of an
-       LTO output stream.  */
-    void (*lto_start) (void);
-
-    /* Output any boilerplate text needed at the end of an
-       LTO output stream.  */
-    void (*lto_end) (void);
-
-    /* Output any boilerplace text needed at the end of a
-       translation unit before debug and unwind info is emitted.  */
-    void (*code_end) (void);
-
-    /* Output an assembler pseudo-op to declare a library function name
-       external.  */
-    void (*external_libcall) (rtx);
-
-    /* Output an assembler directive to mark decl live. This instructs
-	linker to not dead code strip this symbol.  */
-    void (*mark_decl_preserved) (const char *);
-
-    /* Output a record of the command line switches that have been passed.  */
-    print_switch_fn_type record_gcc_switches;
-    /* The name of the section that the example ELF implementation of
-       record_gcc_switches will use to store the information.  Target
-       specific versions of record_gcc_switches may or may not use
-       this information.  */
-    const char * record_gcc_switches_section;
-
-    /* Output the definition of a section anchor.  */
-    void (*output_anchor) (rtx);
-
-    /* Output a DTP-relative reference to a TLS symbol.  */
-    void (*output_dwarf_dtprel) (FILE *file, int size, rtx x);
-
-    /* Some target machines need to postscan each insn after it is output.  */
-    void (*final_postscan_insn) (FILE *, rtx, rtx *, int);
-
-    /* Emit the trampoline template.  This hook may be NULL.  */
-    void (*trampoline_template) (FILE *);
-
-    /* Emit a machine-specific insn operand.  */
-    void (*print_operand) (FILE *, rtx, int);
-
-    /* Emit a machine-specific memory address.  */
-    void (*print_operand_address) (FILE *, rtx);
-
-    /* Determine whether CODE is a valid punctuation character for the
-       `print_operand' hook.  */
-    bool (*print_operand_punct_valid_p)(unsigned char code);
-  } asm_out;
-
-  /* Functions relating to instruction scheduling.  */
-  struct sched
-  {
-    /* Given the current cost, COST, of an insn, INSN, calculate and
-       return a new cost based on its relationship to DEP_INSN through
-       the dependence LINK.  The default is to make no adjustment.  */
-    int (* adjust_cost) (rtx insn, rtx link, rtx dep_insn, int cost);
-
-    /* Adjust the priority of an insn as you see fit.  Returns the new
-       priority.  */
-    int (* adjust_priority) (rtx, int);
-
-    /* Function which returns the maximum number of insns that can be
-       scheduled in the same machine cycle.  This must be constant
-       over an entire compilation.  The default is 1.  */
-    int (* issue_rate) (void);
-
-    /* Calculate how much this insn affects how many more insns we
-       can emit this cycle.  Default is they all cost the same.  */
-    int (* variable_issue) (FILE *, int, rtx, int);
-
-    /* Initialize machine-dependent scheduling code.  */
-    void (* md_init) (FILE *, int, int);
-
-    /* Finalize machine-dependent scheduling code.  */
-    void (* md_finish) (FILE *, int);
-
-    /* Initialize machine-dependent function wide scheduling code.  */
-    void (* md_init_global) (FILE *, int, int);
-
-    /* Finalize machine-dependent function wide scheduling code.  */
-    void (* md_finish_global) (FILE *, int);
-
-    /* Reorder insns in a machine-dependent fashion, in two different
-       places.  Default does nothing.  */
-    int (* reorder) (FILE *, int, rtx *, int *, int);
-    int (* reorder2) (FILE *, int, rtx *, int *, int);
-
-    /* The following member value is a pointer to a function called
-       after evaluation forward dependencies of insns in chain given
-       by two parameter values (head and tail correspondingly).  */
-    void (* dependencies_evaluation_hook) (rtx, rtx);
-
-    /* The values of the following four members are pointers to
-       functions used to simplify the automaton descriptions.
-       dfa_pre_cycle_insn and dfa_post_cycle_insn give functions
-       returning insns which are used to change the pipeline hazard
-       recognizer state when the new simulated processor cycle
-       correspondingly starts and finishes.  The function defined by
-       init_dfa_pre_cycle_insn and init_dfa_post_cycle_insn are used
-       to initialize the corresponding insns.  The default values of
-       the members result in not changing the automaton state when
-       the new simulated processor cycle correspondingly starts and
-       finishes.  */
-    void (* init_dfa_pre_cycle_insn) (void);
-    rtx (* dfa_pre_cycle_insn) (void);
-    void (* init_dfa_post_cycle_insn) (void);
-    rtx (* dfa_post_cycle_insn) (void);
-
-    /* The values of the following two members are pointers to
-       functions used to simplify the automaton descriptions.
-       dfa_pre_advance_cycle and dfa_post_advance_cycle are getting called
-       immediately before and after cycle is advanced.  */
-    void (* dfa_pre_advance_cycle) (void);
-    void (* dfa_post_advance_cycle) (void);
-
-    /* The following member value is a pointer to a function returning value
-       which defines how many insns in queue `ready' will we try for
-       multi-pass scheduling.  If the member value is nonzero and the
-       function returns positive value, the DFA based scheduler will make
-       multi-pass scheduling for the first cycle.  In other words, we will
-       try to choose ready insn which permits to start maximum number of
-       insns on the same cycle.  */
-    int (* first_cycle_multipass_dfa_lookahead) (void);
-
-    /* The following member value is pointer to a function controlling
-       what insns from the ready insn queue will be considered for the
-       multipass insn scheduling.  If the hook returns zero for insn
-       passed as the parameter, the insn will be not chosen to be
-       issued.  */
-    int (* first_cycle_multipass_dfa_lookahead_guard) (rtx);
-
-    /* The following member value is pointer to a function called by
-       the insn scheduler before issuing insn passed as the third
-       parameter on given cycle.  If the hook returns nonzero, the
-       insn is not issued on given processors cycle.  Instead of that,
-       the processor cycle is advanced.  If the value passed through
-       the last parameter is zero, the insn ready queue is not sorted
-       on the new cycle start as usually.  The first parameter passes
-       file for debugging output.  The second one passes the scheduler
-       verbose level of the debugging output.  The forth and the fifth
-       parameter values are correspondingly processor cycle on which
-       the previous insn has been issued and the current processor
-       cycle.  */
-    int (* dfa_new_cycle) (FILE *, int, rtx, int, int, int *);
-
-    /* The following member value is a pointer to a function called by the
-       insn scheduler.  It should return true if there exists a dependence
-       which is considered costly by the target, between the insn
-       DEP_PRO (&_DEP), and the insn DEP_CON (&_DEP).  The first parameter is
-       the dep that represents the dependence between the two insns.  The
-       second argument is the cost of the dependence as estimated by
-       the scheduler.  The last argument is the distance in cycles
-       between the already scheduled insn (first parameter) and the
-       second insn (second parameter).  */
-    bool (* is_costly_dependence) (struct _dep *_dep, int, int);
-
-    /* Given the current cost, COST, of an insn, INSN, calculate and
-       return a new cost based on its relationship to DEP_INSN through the
-       dependence of type DEP_TYPE.  The default is to make no adjustment.  */
-    int (* adjust_cost_2) (rtx insn, int, rtx dep_insn, int cost, int dw);
-
-    /* The following member value is a pointer to a function called
-       by the insn scheduler. This hook is called to notify the backend
-       that new instructions were emitted.  */
-    void (* h_i_d_extended) (void);
-
-    /* Next 5 functions are for multi-point scheduling.  */
-
-    /* Allocate memory for scheduler context.  */
-    void *(* alloc_sched_context) (void);
-
-    /* Fills the context from the local machine scheduler context.  */
-    void (* init_sched_context) (void *, bool);
-
-    /* Sets local machine scheduler context to a saved value.  */
-    void (* set_sched_context) (void *);
-
-    /* Clears a scheduler context so it becomes like after init.  */
-    void (* clear_sched_context) (void *);
-
-    /* Frees the scheduler context.  */
-    void (* free_sched_context) (void *);
-
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.
-       The first parameter is an instruction, the second parameter is the type
-       of the requested speculation, and the third parameter is a pointer to the
-       speculative pattern of the corresponding type (set if return value == 1).
-       It should return
-       -1, if there is no pattern, that will satisfy the requested speculation
-       type,
-       0, if current pattern satisfies the requested speculation type,
-       1, if pattern of the instruction should be changed to the newly
-       generated one.  */
-    int (* speculate_insn) (rtx, int, rtx *);
-
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.  It should return true if the check instruction
-       passed as the parameter needs a recovery block.  */
-    bool (* needs_block_p) (int);
-
-    /* The following member value is a pointer to a function called
-       by the insn scheduler.  It should return a pattern for the check
-       instruction.
-       The first parameter is a speculative instruction, the second parameter
-       is the label of the corresponding recovery block (or null, if it is a
-       simple check).  If the mutation of the check is requested (e.g. from
-       ld.c to chk.a), the third parameter is true - in this case the first
-       parameter is the previous check.  */
-    rtx (* gen_spec_check) (rtx, rtx, int);
-
-    /* The following member value is a pointer to a function controlling
-       what insns from the ready insn queue will be considered for the
-       multipass insn scheduling.  If the hook returns zero for the insn
-       passed as the parameter, the insn will not be chosen to be
-       issued.  This hook is used to discard speculative instructions,
-       that stand at the first position of the ready list.  */
-    bool (* first_cycle_multipass_dfa_lookahead_guard_spec) (const_rtx);
-
-    /* The following member value is a pointer to a function that provides
-       information about the speculation capabilities of the target.
-       The parameter is a pointer to spec_info variable.  */
-    void (* set_sched_flags) (struct spec_info_def *);
-
-    /* Return speculation types of the instruction passed as the parameter.  */
-    int (* get_insn_spec_ds) (rtx);
-
-    /* Return speculation types that are checked for the instruction passed as
-       the parameter.  */
-    int (* get_insn_checked_ds) (rtx);
-
-    /* Return bool if rtx scanning should just skip current layer and
-       advance to the inner rtxes.  */
-    bool (* skip_rtx_p) (const_rtx);
-
-    /* The following member value is a pointer to a function that provides
-       information about the target resource-based lower bound which is
-       used by the swing modulo scheduler.  The parameter is a pointer
-       to ddg variable.  */
-    int (* sms_res_mii) (struct ddg *);
-  } sched;
-
-  /* Functions relating to vectorization.  */
-  struct vectorize
-  {
-    /* The following member value is a pointer to a function called
-       by the vectorizer, and return the decl of the target builtin
-       function.  */
-    tree (* builtin_mask_for_load) (void);
-
-    /* Returns a code for builtin that realizes vectorized version of
-       function, or NULL_TREE if not available.  */
-    tree (* builtin_vectorized_function) (tree, tree, tree);
-
-    /* Returns a function declaration for a builtin that realizes the
-       vector conversion, or NULL_TREE if not available.  */
-    tree (* builtin_conversion) (unsigned, tree, tree);
-
-    /* Target builtin that implements vector widening multiplication.
-       builtin_mul_widen_eve computes the element-by-element products
-       for the even elements, and builtin_mul_widen_odd computes the
-       element-by-element products for the odd elements.  */
-    tree (* builtin_mul_widen_even) (tree);
-    tree (* builtin_mul_widen_odd) (tree);
-
-    /* Cost of different vector/scalar statements in vectorization cost
-       model.  */ 
-    int (* builtin_vectorization_cost) (enum vect_cost_for_stmt);
-
-    /* Return true if vector alignment is reachable (by peeling N
-       iterations) for the given type.  */
-    bool (* vector_alignment_reachable) (const_tree, bool);
-
-    /* Target builtin that implements vector permute.  */
-    tree (* builtin_vec_perm) (tree, tree*);
-
-    /* Return true if a vector created for builtin_vec_perm is valid.  */
-    bool (* builtin_vec_perm_ok) (tree, tree);
-
-    /* Return true if the target supports misaligned store/load of a
-       specific factor denoted in the third parameter.  The last parameter
-       is true if the access is defined in a packed struct.  */
-    bool (* builtin_support_vector_misalignment) (enum machine_mode,
-                                                  const_tree, int, bool);
-  } vectorize;
-
-  /* The initial value of target_flags.  */
-  int default_target_flags;
-
-  /* Allow target specific overriding of option settings after options have
-     been changed by an attribute or pragma or when it is reset at the
-     end of the code affected by an attribute or pragma.  */
-  void (* override_options_after_change) (void);
-
-  /* Handle target switch CODE (an OPT_* value).  ARG is the argument
-     passed to the switch; it is NULL if no argument was.  VALUE is the
-     value of ARG if CODE specifies a UInteger option, otherwise it is
-     1 if the positive form of the switch was used and 0 if the negative
-     form was.  Return true if the switch was valid.  */
-  bool (* handle_option) (size_t code, const char *arg, int value);
-
-  /* Handle target-specific parts of specifying -Ofast.  */
-  void (* handle_ofast) (void);
-
-  /* Display extra, target specific information in response to a
-     --target-help switch.  */
-  void (* target_help) (void);
-
-  /* Return machine mode for filter value.  */
-  enum machine_mode (* eh_return_filter_mode) (void);
-
-  /* Return machine mode for libgcc expanded cmp instructions.  */
-  enum machine_mode (* libgcc_cmp_return_mode) (void);
-
-  /* Return machine mode for libgcc expanded shift instructions.  */
-  enum machine_mode (* libgcc_shift_count_mode) (void);
-
-  /* Return machine mode to be used for _Unwind_Word type.  */
-  enum machine_mode (* unwind_word_mode) (void);
-
-  /* Given two decls, merge their attributes and return the result.  */
-  tree (* merge_decl_attributes) (tree, tree);
-
-  /* Given two types, merge their attributes and return the result.  */
-  tree (* merge_type_attributes) (tree, tree);
-
-  /* Table of machine attributes and functions to handle them.
-     Ignored if NULL.  */
-  const struct attribute_spec *attribute_table;
-
-  /* Return true iff attribute NAME expects a plain identifier as its first
-     argument.  */
-  bool (*attribute_takes_identifier_p) (const_tree name);
-
-  /* Return zero if the attributes on TYPE1 and TYPE2 are incompatible,
-     one if they are compatible and two if they are nearly compatible
-     (which causes a warning to be generated).  */
-  int (* comp_type_attributes) (const_tree type1, const_tree type2);
-
-  /* Assign default attributes to the newly defined TYPE.  */
-  void (* set_default_type_attributes) (tree type);
-
-  /* Insert attributes on the newly created DECL.  */
-  void (* insert_attributes) (tree decl, tree *attributes);
-
-  /* Return true if FNDECL (which has at least one machine attribute)
-     can be inlined despite its machine attributes, false otherwise.  */
-  bool (* function_attribute_inlinable_p) (const_tree fndecl);
-
-  /* Return true if bitfields in RECORD_TYPE should follow the
-     Microsoft Visual C++ bitfield layout rules.  */
-  bool (* ms_bitfield_layout_p) (const_tree record_type);
-
-  /* True if the target supports decimal floating point.  */
-  bool (* decimal_float_supported_p) (void);
-
-  /* True if the target supports fixed-point.  */
-  bool (* fixed_point_supported_p) (void);
-
-  /* Return true if anonymous bitfields affect structure alignment.  */
-  bool (* align_anon_bitfield) (void);
-
-  /* Return true if volatile bitfields should use the narrowest type possible.
-     Return false if they should use the container type.  */
-  bool (* narrow_volatile_bitfield) (void);
-
-  /* Set up target-specific built-in functions.  */
-  void (* init_builtins) (void);
-
-  /* Initialize (if INITIALIZE_P is true) and return the target-specific
-     built-in function decl for CODE.
-     Return NULL if that is not possible.  Return error_mark_node if CODE
-     is outside of the range of valid target builtin function codes.  */
-  tree (* builtin_decl) (unsigned code, bool initialize_p);
-
-  /* Expand a target-specific builtin.  */
-  rtx (* expand_builtin) (tree exp, rtx target, rtx subtarget,
-			  enum machine_mode mode, int ignore);
-
-  /* Select a replacement for a target-specific builtin.  This is done
-     *before* regular type checking, and so allows the target to
-     implement a crude form of function overloading.  The result is a
-     complete expression that implements the operation.  PARAMS really
-     has type VEC(tree,gc)*, but we don't want to include tree.h
-     here.  */
-  tree (*resolve_overloaded_builtin) (unsigned int /*location_t*/,
-      				      tree decl, void *params);
-
-  /* Fold a target-specific builtin.  */
-  tree (* fold_builtin) (tree fndecl, int nargs, tree *argp, bool ignore);
-
-  /* Returns a code for a target-specific builtin that implements
-     reciprocal of the function, or NULL_TREE if not available.  */
-  tree (* builtin_reciprocal) (unsigned, bool, bool);
-
-  /* For a vendor-specific TYPE, return a pointer to a statically-allocated
-     string containing the C++ mangling for TYPE.  In all other cases, return
-     NULL.  */
-  const char * (* mangle_type) (const_tree type);
-
-  /* Make any adjustments to libfunc names needed for this target.  */
-  void (* init_libfuncs) (void);
-
-  /* Given a decl, a section name, and whether the decl initializer
-     has relocs, choose attributes for the section.  */
-  /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION.  */
-  unsigned int (* section_type_flags) (tree, const char *, int);
-
-  /* True if new jumps cannot be created, to replace existing ones or
-     not, at the current point in the compilation.  */
-  bool (* cannot_modify_jumps_p) (void);
-
-  /* Return a register class for which branch target register
-     optimizations should be applied.  */
-  enum reg_class (* branch_target_register_class) (void);
-
-  /* Return true if branch target register optimizations should include
-     callee-saved registers that are not already live during the current
-     function.  AFTER_PE_GEN is true if prologues and epilogues have
-     already been generated.  */
-  bool (* branch_target_register_callee_saved) (bool after_pe_gen);
-
-  /* Return true if the target supports conditional execution.  */
-  bool (* have_conditional_execution) (void);
-
-  /* Return a new value for loop unroll size.  */
-  unsigned (* loop_unroll_adjust) (unsigned nunroll, struct loop *loop);
-
-  /* True if the constant X cannot be placed in the constant pool.  */
-  bool (* cannot_force_const_mem) (rtx);
-
-  /* True if the insn X cannot be duplicated.  */
-  bool (* cannot_copy_insn_p) (rtx);
-
-  /* True if X is considered to be commutative.  */
-  bool (* commutative_p) (const_rtx, int);
-  
-  /* True if ADDR is an address-expression whose effect depends
-     on the mode of the memory reference it is used in.  */
-  bool (* mode_dependent_address_p) (const_rtx addr);
-
-  /* Given an invalid address X for a given machine mode, try machine-specific
-     ways to make it legitimate.  Return X or an invalid address on failure.  */
-  rtx (* legitimize_address) (rtx, rtx, enum machine_mode);
-
-  /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS.  */
-  rtx (* delegitimize_address) (rtx);
-
-  /* Given an address RTX, say whether it is valid.  */
-  bool (* legitimate_address_p) (enum machine_mode, rtx, bool);
-
-  /* True if the given constant can be put into an object_block.  */
-  bool (* use_blocks_for_constant_p) (enum machine_mode, const_rtx);
-
-  /* The minimum and maximum byte offsets for anchored addresses.  */
-  HOST_WIDE_INT min_anchor_offset;
-  HOST_WIDE_INT max_anchor_offset;
-
-  /* True if section anchors can be used to access the given symbol.  */
-  bool (* use_anchors_for_symbol_p) (const_rtx);
-
-  /* True if it is OK to do sibling call optimization for the specified
-     call expression EXP.  DECL will be the called function, or NULL if
-     this is an indirect call.  */
-  bool (*function_ok_for_sibcall) (tree decl, tree exp);
-
-  /* Establish appropriate back-end context for processing the function
-     FNDECL.  The argument might be NULL to indicate processing at top
-     level, outside of any function scope.  */
-  void (*set_current_function) (tree fndecl);
-
-  /* True if EXP should be placed in a "small data" section.  */
-  bool (* in_small_data_p) (const_tree);
-
-  /* True if EXP names an object for which name resolution must resolve
-     to the current executable or shared library.  */
-  bool (* binds_local_p) (const_tree);
-
-  /* Modify and return the identifier of a DECL's external name,
-     originally identified by ID, as required by the target,
-    (eg, append @nn to windows32 stdcall function names).
-     The default is to return ID without modification. */
-   tree (* mangle_decl_assembler_name) (tree decl, tree  id);
-
-  /* Do something target-specific to record properties of the DECL into
-     the associated SYMBOL_REF.  */
-  void (* encode_section_info) (tree, rtx, int);
-
-  /* Undo the effects of encode_section_info on the symbol string.  */
-  const char * (* strip_name_encoding) (const char *);
-
-  /* If shift optabs for MODE are known to always truncate the shift count,
-     return the mask that they apply.  Return 0 otherwise.  */
-  unsigned HOST_WIDE_INT (* shift_truncation_mask) (enum machine_mode mode);
-
-  /* Return the number of divisions in the given MODE that should be present,
-     so that it is profitable to turn the division into a multiplication by
-     the reciprocal.  */
-  unsigned int (* min_divisions_for_recip_mul) (enum machine_mode mode);
-
-  /* If the representation of integral MODE is such that values are
-     always sign-extended to a wider mode MODE_REP then return
-     SIGN_EXTEND.  Return UNKNOWN otherwise.  */
-  /* Note that the return type ought to be RTX_CODE, but that's not
-     necessarily defined at this point.  */
-  int (* mode_rep_extended) (enum machine_mode mode,
-			     enum machine_mode mode_rep);
-
-  /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))).  */
-  bool (* valid_pointer_mode) (enum machine_mode mode);
-
-  /* Support for named address spaces.  */
-  struct addr_space {
-    /* MODE to use for a pointer into another address space.  */
-    enum machine_mode (* pointer_mode) (addr_space_t);
-
-    /* MODE to use for an address in another address space.  */
-    enum machine_mode (* address_mode) (addr_space_t);
-
-    /* True if MODE is valid for a pointer in __attribute__((mode("MODE")))
-       in another address space.  */
-    bool (* valid_pointer_mode) (enum machine_mode, addr_space_t);
-
-    /* True if an address is a valid memory address to a given named address
-       space for a given mode.  */
-    bool (* legitimate_address_p) (enum machine_mode, rtx, bool, addr_space_t);
-
-    /* Return an updated address to convert an invalid pointer to a named
-       address space to a valid one.  If NULL_RTX is returned use machine
-       independent methods to make the address valid.  */
-    rtx (* legitimize_address) (rtx, rtx, enum machine_mode, addr_space_t);
-
-    /* True if one named address space is a subset of another named address. */
-    bool (* subset_p) (addr_space_t, addr_space_t);
-
-    /* Function to convert an rtl expression from one address space to
-       another.  */
-    rtx (* convert) (rtx, tree, tree);
-
-  } addr_space;
-
-  /* True if MODE is valid for the target.  By "valid", we mean able to
-     be manipulated in non-trivial ways.  In particular, this means all
-     the arithmetic is supported.  */
-  bool (* scalar_mode_supported_p) (enum machine_mode mode);
-
-  /* Similarly for vector modes.  "Supported" here is less strict.  At
-     least some operations are supported; need to check optabs or builtins
-     for further details.  */
-  bool (* vector_mode_supported_p) (enum machine_mode mode);
-
-  /* Compute cost of moving data from a register of class FROM to one of
-     TO, using MODE.  */
-  int (* register_move_cost) (enum machine_mode, enum reg_class,
-			      enum reg_class);
-
-  /* Compute cost of moving registers to/from memory.  */
-  int (* memory_move_cost) (enum machine_mode, enum reg_class, bool);
-
-  /* True for MODE if the target expects that registers in this mode will
-     be allocated to registers in a small register class.  The compiler is
-     allowed to use registers explicitly used in the rtl as spill registers
-     but it should prevent extending the lifetime of these registers.  */
-  bool (* small_register_classes_for_mode_p) (enum machine_mode mode);
-
-  /* Compute a (partial) cost for rtx X.  Return true if the complete
-     cost has been computed, and false if subexpressions should be
-     scanned.  In either case, *TOTAL contains the cost result.  */
-  /* Note that CODE and OUTER_CODE ought to be RTX_CODE, but that's
-     not necessarily defined at this point.  */
-  bool (* rtx_costs) (rtx x, int code, int outer_code, int *total, bool speed);
-
-  /* Compute the cost of X, used as an address.  Never called with
-     invalid addresses.  */
-  int (* address_cost) (rtx x, bool speed);
-
-  /* Return where to allocate pseudo for a given hard register initial
-     value.  */
-  rtx (* allocate_initial_value) (rtx x);
-
-  /* Return nonzero if evaluating UNSPEC[_VOLATILE] X might cause a trap.
-     FLAGS has the same meaning as in rtlanal.c: may_trap_p_1.  */
-  int (* unspec_may_trap_p) (const_rtx x, unsigned flags);
-
-  /* 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 locations, or if the register should be
-     represented in more than one register in Dwarf.  Otherwise, this
-     hook should return NULL_RTX.  */
-  rtx (* dwarf_register_span) (rtx);
-
-  /* If expand_builtin_init_dwarf_reg_sizes needs to fill in table
-     entries not corresponding directly to registers below
-     FIRST_PSEUDO_REGISTER, this hook should generate the necessary
-     code, given the address of the table.  */
-  void (* init_dwarf_reg_sizes_extra) (tree);
-
-  /* Fetch the fixed register(s) which hold condition codes, for
-     targets where it makes sense to look for duplicate assignments to
-     the condition codes.  This should return true if there is such a
-     register, false otherwise.  The arguments should be set to the
-     fixed register numbers.  Up to two condition code registers are
-     supported.  If there is only one for this target, the int pointed
-     at by the second argument should be set to -1.  */
-  bool (* fixed_condition_code_regs) (unsigned int *, unsigned int *);
-
-  /* If two condition code modes are compatible, return a condition
-     code mode which is compatible with both, such that a comparison
-     done in the returned mode will work for both of the original
-     modes.  If the condition code modes are not compatible, return
-     VOIDmode.  */
-  enum machine_mode (* cc_modes_compatible) (enum machine_mode,
-					     enum machine_mode);
-
-  /* Do machine-dependent code transformations.  Called just before
-     delayed-branch scheduling.  */
-  void (* machine_dependent_reorg) (void);
-
-  /* Create the __builtin_va_list type.  */
-  tree (* build_builtin_va_list) (void);
-
-  /* Enumerate the va list variants.  */
-  int (* enum_va_list) (int, const char **, tree *);
-
-  /* Get the cfun/fndecl calling abi __builtin_va_list type.  */
-  tree (* fn_abi_va_list) (tree);
-
-  /* Get the __builtin_va_list type dependent on input type.  */
-  tree (* canonical_va_list_type) (tree);
-
-  /* Expand the __builtin_va_start builtin.  */
-  void (* expand_builtin_va_start) (tree valist, rtx nextarg);
-
-  /* Gimplifies a VA_ARG_EXPR.  */
-  tree (* gimplify_va_arg_expr) (tree valist, tree type, gimple_seq *pre_p,
-				 gimple_seq *post_p);
-
-  /* Validity-checking routines for PCH files, target-specific.
-     get_pch_validity returns a pointer to the data to be stored,
-     and stores the size in its argument.  pch_valid_p gets the same
-     information back and returns NULL if the PCH is valid,
-     or an error message if not.
-  */
-  void * (* get_pch_validity) (size_t *);
-  const char * (* pch_valid_p) (const void *, size_t);
-
-  /* If nonnull, this function checks whether a PCH file with the
-     given set of target flags can be used.  It returns NULL if so,
-     otherwise it returns an error message.  */
-  const char *(*check_pch_target_flags) (int);
-
-  /* True if the compiler should give an enum type only as many
-     bytes as it takes to represent the range of possible values of
-     that type.  */
-  bool (* default_short_enums) (void);
-
-  /* This target hook returns an rtx that is used to store the address
-     of the current frame into the built-in setjmp buffer.  */
-  rtx (* builtin_setjmp_frame_value) (void);
-
-  /* This target hook should add STRING_CST trees for any hard regs
-     the port wishes to automatically clobber for an asm.  */
-  tree (* md_asm_clobbers) (tree, tree, tree);
-
-  /* This target hook allows the backend to specify a calling convention
-     in the debug information.  This function actually returns an
-     enum dwarf_calling_convention, but because of forward declarations
-     and not wanting to include dwarf2.h everywhere target.h is included
-     the function is being declared as an int.  */
-  int (* dwarf_calling_convention) (const_tree);
-
-  /* This target hook allows the backend to emit frame-related insns that
-     contain UNSPECs or UNSPEC_VOLATILEs.  The call frame debugging info
-     engine will invoke it on insns of the form
-       (set (reg) (unspec [...] UNSPEC_INDEX))
-     and
-       (set (reg) (unspec_volatile [...] UNSPECV_INDEX))
-     to let the backend emit the call frame instructions.  */
-  void (* dwarf_handle_frame_unspec) (const char *, rtx, int);
-
-  /* Perform architecture specific checking of statements gimplified
-     from VA_ARG_EXPR.  STMT is the statement.  Returns true if the statement
-     doesn't need to be checked for va_list references.  */
-  bool (* stdarg_optimize_hook) (struct stdarg_info *ai, const_gimple stmt);
-
-  /* This target hook allows the operating system to override the DECL
-     that represents the external variable that contains the stack
-     protection guard variable.  The type of this DECL is ptr_type_node.  */
-  tree (* stack_protect_guard) (void);
-
-  /* This target hook allows the operating system to override the CALL_EXPR
-     that is invoked when a check vs the guard variable fails.  */
-  tree (* stack_protect_fail) (void);
-
-  /* Returns NULL if target supports the insn within a doloop block,
-     otherwise it returns an error message.  */
-  const char * (*invalid_within_doloop) (const_rtx);
-
-  /* DECL is a variable or function with __attribute__((dllimport))
-     specified.  Use this hook if the target needs to add extra validation
-     checks to  handle_dll_attribute ().  */
-  bool (* valid_dllimport_attribute_p) (const_tree decl);
-
-  /* If non-zero, align constant anchors in CSE to a multiple of this
-     value.  */
-  unsigned HOST_WIDE_INT const_anchor;
-
-  /* Functions relating to calls - argument passing, returns, etc.  */
-  struct calls {
-    enum machine_mode (*promote_function_mode) (const_tree type,
-						enum machine_mode mode,
-						int *punsignedp,
-						const_tree fntype,
-						int for_return);
-    bool (*promote_prototypes) (const_tree fntype);
-    rtx (*struct_value_rtx) (tree fndecl, int incoming);
-    bool (*return_in_memory) (const_tree type, const_tree fndecl);
-    bool (*return_in_msb) (const_tree type);
-
-    /* Return true if a parameter must be passed by reference.  TYPE may
-       be null if this is a libcall.  CA may be null if this query is
-       from __builtin_va_arg.  */
-    bool (*pass_by_reference) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			       const_tree type, bool named_arg);
-
-    rtx (*expand_builtin_saveregs) (void);
-    /* Returns pretend_argument_size.  */
-    void (*setup_incoming_varargs) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-				    tree type, int *pretend_arg_size,
-				    int second_time);
-    bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca);
-    /* Returns true if we should use
-       targetm.calls.setup_incoming_varargs() and/or
-       targetm.calls.strict_argument_naming().  */
-    bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca);
-
-    /* Given a complex type T, return true if a parameter of type T
-       should be passed as two scalars.  */
-    bool (* split_complex_arg) (const_tree type);
-
-    /* Return true if type T, mode MODE, may not be passed in registers,
-       but must be passed on the stack.  */
-    /* ??? This predicate should be applied strictly after pass-by-reference.
-       Need audit to verify that this is the case.  */
-    bool (* must_pass_in_stack) (enum machine_mode mode, const_tree t);
-
-    /* Return true if type TYPE, mode MODE, which is passed by reference,
-       should have the object copy generated by the callee rather than
-       the caller.  It is never called for TYPE requiring constructors.  */
-    bool (* callee_copies) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			    const_tree type, bool named);
-
-    /* Return zero for arguments passed entirely on the stack or entirely
-       in registers.  If passed in both, return the number of bytes passed
-       in registers; the balance is therefore passed on the stack.  */
-    int (* arg_partial_bytes) (CUMULATIVE_ARGS *ca, enum machine_mode mode,
-			       tree type, bool named);
-
-    /* Return the diagnostic message string if function without a prototype
-       is not allowed for this 'val' argument; NULL otherwise. */
-    const char *(*invalid_arg_for_unprototyped_fn) (const_tree typelist,
-					     	    const_tree funcdecl,
-						    const_tree val);
-
-    /* Return an rtx for the return value location of the function
-       specified by FN_DECL_OR_TYPE with a return type of RET_TYPE.  */
-    rtx (*function_value) (const_tree ret_type, const_tree fn_decl_or_type,
-			   bool outgoing);
-
-    /* Return the rtx for the result of a libcall of mode MODE,
-       calling the function FN_NAME.  */
-    rtx (*libcall_value) (enum machine_mode, const_rtx);
-
-    /* Return true if REGNO is a possible register number for
-       a function value as seen by the caller.  */
-    bool (*function_value_regno_p) (const unsigned int);
-
-    /* Return an rtx for the argument pointer incoming to the
-       current function.  */
-    rtx (*internal_arg_pointer) (void);
-
-    /* Update the current function stack boundary if needed.  */
-    void (*update_stack_boundary) (void);
-
-    /* Handle stack alignment and return an rtx for Dynamic Realign
-       Argument Pointer if necessary.  */
-    rtx (*get_drap_rtx) (void);
-
-    /* Return true if all function parameters should be spilled to the
-       stack.  */
-    bool (*allocate_stack_slots_for_args) (void);
-
-    /* Return an rtx for the static chain for FNDECL.  If INCOMING_P is true,
-       then it should be for the callee; otherwise for the caller.  */
-    rtx (*static_chain) (const_tree fndecl, bool incoming_p);
-
-    /* Fill in the trampoline at MEM with a call to FNDECL and a
-       static chain value of CHAIN.  */
-    void (*trampoline_init) (rtx mem, tree fndecl, rtx chain);
-
-    /* Adjust the address of the trampoline in a target-specific way.  */
-    rtx (*trampoline_adjust_address) (rtx addr);
-  } calls;
-
-  /* Return the diagnostic message string if conversion from FROMTYPE
-     to TOTYPE is not allowed, NULL otherwise.  */
-  const char *(*invalid_conversion) (const_tree fromtype, const_tree totype);
-
-  /* Return the diagnostic message string if the unary operation OP is
-     not permitted on TYPE, NULL otherwise.  */
-  const char *(*invalid_unary_op) (int op, const_tree type);
-
-  /* Return the diagnostic message string if the binary operation OP
-     is not permitted on TYPE1 and TYPE2, NULL otherwise.  */
-  const char *(*invalid_binary_op) (int op, const_tree type1, const_tree type2);
-
-  /* Return the diagnostic message string if TYPE is not valid as a
-     function parameter type, NULL otherwise.  */
-  const char *(*invalid_parameter_type) (const_tree type);
-
-  /* Return the diagnostic message string if TYPE is not valid as a
-     function return type, NULL otherwise.  */
-  const char *(*invalid_return_type) (const_tree type);
-
-  /* If values of TYPE are promoted to some other type when used in
-     expressions (analogous to the integer promotions), return that type,
-     or NULL_TREE otherwise.  */
-  tree (*promoted_type) (const_tree type);
-
-  /* Convert EXPR to TYPE, if target-specific types with special conversion
-     rules are involved.  Return the converted expression, or NULL to apply
-     the standard conversion rules.  */
-  tree (*convert_to_type) (tree type, tree expr);
-
-  /* Return the array of IRA cover classes for the current target.  */
-  const enum reg_class *(*ira_cover_classes) (void);
-
-  /* Return the class for a secondary reload, and fill in extra information.  */
-  enum reg_class (*secondary_reload) (bool, rtx, enum reg_class,
-				      enum machine_mode,
-				      secondary_reload_info *);
-
-  /* This target hook allows the backend to perform additional
-     processing while initializing for variable expansion.  */
-  void (* expand_to_rtl_hook) (void);
-
-  /* This target hook allows the backend to perform additional
-     instantiations on rtx that are not actually in insns yet,
-     but will be later.  */
-  void (* instantiate_decls) (void);
-
-  /* Return true if is OK to use a hard register REGNO as scratch register
-     in peephole2.  */
-  bool (* hard_regno_scratch_ok) (unsigned int regno);
-
-  /* Return the smallest number of different values for which it is best to
-     use a jump-table instead of a tree of conditional branches.  */
-  unsigned int (* case_values_threshold) (void);
-
-  /* Retutn true if a function must have and use a frame pointer.  */
-  bool (* frame_pointer_required) (void);
-
-  /* Returns true if the compiler is allowed to try to replace register number
-     from-reg with register number to-reg.  */
-  bool (* can_eliminate) (const int, const int);
-
-  /* Functions specific to the C family of frontends.  */
-  struct c {
-    /* Return machine mode for non-standard suffix
-       or VOIDmode if non-standard suffixes are unsupported.  */
-    enum machine_mode (*mode_for_suffix) (char);
-  } c;
-
-  /* Functions specific to the C++ frontend.  */
-  struct cxx {
-    /* Return the integer type used for guard variables.  */
-    tree (*guard_type) (void);
-    /* Return true if only the low bit of the guard should be tested.  */
-    bool (*guard_mask_bit) (void);
-    /* Returns the size of the array cookie for an array of type.  */
-    tree (*get_cookie_size) (tree);
-    /* Returns true if the element size should be stored in the
-       array cookie.  */
-    bool (*cookie_has_size) (void);
-    /* Allows backends to perform additional processing when
-       deciding if a class should be exported or imported.  */
-    int (*import_export_class) (tree, int);
-    /* Returns true if constructors and destructors return "this".  */
-    bool (*cdtor_returns_this) (void);
-    /* Returns true if the key method for a class can be an inline
-       function, so long as it is not declared inline in the class
-       itself.  Returning true is the behavior required by the Itanium
-       C++ ABI.  */
-    bool (*key_method_may_be_inline) (void);
-    /* DECL is a virtual table, virtual table table, typeinfo object,
-       or other similar implicit class data object that will be
-       emitted with external linkage in this translation unit.  No ELF
-       visibility has been explicitly specified.  If the target needs
-       to specify a visibility other than that of the containing class,
-       use this hook to set DECL_VISIBILITY and
-       DECL_VISIBILITY_SPECIFIED.  */
-    void (*determine_class_data_visibility) (tree decl);
-    /* 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 classes whose virtual table will be emitted in
-       only one translation unit will not be COMDAT.  */
-    bool (*class_data_always_comdat) (void);
-    /* Returns true (the default) if the RTTI for the basic types,
-       which is always defined in the C++ runtime, should be COMDAT;
-       false if it should not be COMDAT.  */
-    bool (*library_rtti_comdat) (void);
-    /* Returns true if __aeabi_atexit should be used to register static
-       destructors.  */
-    bool (*use_aeabi_atexit) (void);
-    /* Returns true if target may use atexit in the same manner as
-    __cxa_atexit  to register static destructors.  */
-    bool (*use_atexit_for_cxa_atexit) (void);
-    /* 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).  */
-    void (*adjust_class_at_definition) (tree type);
-  } cxx;
-
-  /* Functions and data for emulated TLS support.  */
-  struct emutls {
-    /* Name of the address and common functions.  */
-    const char *get_address;
-    const char *register_common;
-
-    /* Prefixes for proxy variable and template.  */
-    const char *var_section;
-    const char *tmpl_section;
-
-    /* Prefixes for proxy variable and template.  */
-    const char *var_prefix;
-    const char *tmpl_prefix;
-
-    /* Function to generate field definitions of the proxy variable.  */
-    tree (*var_fields) (tree, tree *);
-
-    /* Function to initialize a proxy variable.  */
-    tree (*var_init) (tree, tree, tree);
-
-    /* Whether we are allowed to alter the usual alignment of the
-       proxy variable.  */
-    bool var_align_fixed;
-
-    /* Whether we can emit debug information for TLS vars.  */
-    bool debug_form_tls_address;
-  } emutls;
-
-  struct target_option_hooks {
-    /* Function to validate the attribute((option(...))) strings or NULL.  If
-       the option is validated, it is assumed that DECL_FUNCTION_SPECIFIC will
-       be filled in in the function decl node.  */
-    bool (*valid_attribute_p) (tree, tree, tree, int);
-
-    /* Function to save any extra target state in the target options
-       structure.  */
-    void (*save) (struct cl_target_option *);
-
-    /* Function to restore any extra target state from the target options
-       structure.  */
-    void (*restore) (struct cl_target_option *);
-
-    /* Function to print any extra target state from the target options
-       structure.  */
-    void (*print) (FILE *, int, struct cl_target_option *);
-
-    /* Function to parse arguments to be validated for #pragma option, and to
-       change the state if the options are valid.  If the first argument is
-       NULL, the second argument specifies the default options to use.  Return
-       true if the options are valid, and set the current state.  */
-    bool (*pragma_parse) (tree, tree);
-
-    /* Function to determine if one function can inline another function.  */
-    bool (*can_inline_p) (tree, tree);
-  } target_option;
-
-  /* For targets that need to mark extra registers as live on entry to
-     the function, they should define this target hook and set their
-     bits in the bitmap passed in. */
-  void (*live_on_entry) (bitmap);
-
-  /* True if unwinding tables should be generated by default.  */
-  bool unwind_tables_default;
-
-  /* Leave the boolean fields at the end.  */
-
-  /* True if arbitrary sections are supported.  */
-  bool have_named_sections;
-
-  /* True if we can create zeroed data by switching to a BSS section
-     and then using ASM_OUTPUT_SKIP to allocate the space.  */
-  bool have_switchable_bss_sections;
-
-  /* True if "native" constructors and destructors are supported,
-     false if we're using collect2 for the job.  */
-  bool have_ctors_dtors;
-
-  /* True if thread-local storage is supported.  */
-  bool have_tls;
-
-  /* True if a small readonly data section is supported.  */
-  bool have_srodata_section;
-
-  /* True if EH frame info sections should be zero-terminated.  */
-  bool terminate_dw2_eh_frame_info;
-
-  /* True if #NO_APP should be emitted at the beginning of
-     assembly output.  */
-  bool file_start_app_off;
-
-  /* True if output_file_directive should be called for main_input_filename
-     at the beginning of assembly output.  */
-  bool file_start_file_directive;
-
-  /* True if #pragma extern_prefix is to be supported.  */
-  bool handle_pragma_extern_prefix;
-
-  /* True if the target is allowed to reorder memory accesses unless
-     synchronization is explicitly requested.  */
-  bool relaxed_ordering;
-
-  /* Returns true if we should generate exception tables for use with the
-     ARM EABI.  The effects the encoding of function exception specifications.
-   */
-  bool arm_eabi_unwinder;
-
-  /* Leave the boolean fields at the end.  */
-};
+#include "target.def"
 
 extern struct gcc_target targetm;
 
-struct gcc_targetcm {
-  /* Handle target switch CODE (an OPT_* value).  ARG is the argument
-     passed to the switch; it is NULL if no argument was.  VALUE is the
-     value of ARG if CODE specifies a UInteger option, otherwise it is
-     1 if the positive form of the switch was used and 0 if the negative
-     form was.  Return true if the switch was valid.  */
-  bool (*handle_c_option) (size_t code, const char *arg, int value);
-};
-
 /* Each target can provide their own.  */
 extern struct gcc_targetcm targetcm;
 
Index: gcc/df-scan.c
===================================================================
--- gcc/df-scan.c	(revision 161494)
+++ gcc/df-scan.c	(working copy)
@@ -3922,7 +3922,7 @@  df_get_entry_block_def_set (bitmap entry
     bitmap_set_bit (entry_block_defs, REGNO (INCOMING_RETURN_ADDR_RTX));
 #endif
 
-  targetm.live_on_entry (entry_block_defs);
+  targetm.extra_live_on_entry (entry_block_defs);
 }
 
 
Index: gcc/haifa-sched.c
===================================================================
--- gcc/haifa-sched.c	(revision 161494)
+++ gcc/haifa-sched.c	(working copy)
@@ -1798,7 +1798,7 @@  schedule_insn (rtx insn)
      forward dependencies for INSN anymore.  Nevertheless they are used in
      heuristics in rank_for_schedule (), early_queue_to_ready () and in
      some targets (e.g. rs6000).  Thus the earliest place where we *can*
-     remove dependencies is after targetm.sched.md_finish () call in
+     remove dependencies is after targetm.sched.finish () call in
      schedule_block ().  But, on the other side, the safest place to remove
      dependencies is when we are finishing scheduling entire region.  As we
      don't generate [many] dependencies during scheduling itself, we won't
@@ -2808,8 +2808,8 @@  schedule_block (basic_block *target_bb)
   /* It is used for first cycle multipass scheduling.  */
   temp_state = alloca (dfa_state_size);
 
-  if (targetm.sched.md_init)
-    targetm.sched.md_init (sched_dump, sched_verbose, ready.veclen);
+  if (targetm.sched.init)
+    targetm.sched.init (sched_dump, sched_verbose, ready.veclen);
 
   /* We start inserting insns after PREV_HEAD.  */
   last_scheduled_insn = prev_head;
@@ -3283,9 +3283,9 @@  schedule_block (basic_block *target_bb)
       fix_inter_tick (NEXT_INSN (prev_head), last_scheduled_insn);
     }
 
-  if (targetm.sched.md_finish)
+  if (targetm.sched.finish)
     {
-      targetm.sched.md_finish (sched_dump, sched_verbose);
+      targetm.sched.finish (sched_dump, sched_verbose);
       /* Target might have added some instructions to the scheduled block
 	 in its md_finish () hook.  These new insns don't have any data
 	 initialized and to identify them we extend h_i_d so that they'll
@@ -3444,9 +3444,8 @@  sched_init (void)
 
   regstat_compute_calls_crossed ();
 
-  if (targetm.sched.md_init_global)
-    targetm.sched.md_init_global (sched_dump, sched_verbose,
-				  get_max_uid () + 1);
+  if (targetm.sched.init_global)
+    targetm.sched.init_global (sched_dump, sched_verbose, get_max_uid () + 1);
 
   if (sched_pressure_p)
     {
@@ -3571,8 +3570,8 @@  sched_finish (void)
     }
   free (curr_state);
 
-  if (targetm.sched.md_finish_global)
-    targetm.sched.md_finish_global (sched_dump, sched_verbose);
+  if (targetm.sched.finish_global)
+    targetm.sched.finish_global (sched_dump, sched_verbose);
 
   end_alias_analysis ();
 
Index: gcc/sel-sched.c
===================================================================
--- gcc/sel-sched.c	(revision 161494)
+++ gcc/sel-sched.c	(working copy)
@@ -6863,11 +6863,11 @@  sel_region_init (int rgn)
   /* Set hooks so that no newly generated insn will go out unnoticed.  */
   sel_register_cfg_hooks ();
 
-  /* !!! We call target.sched.md_init () for the whole region, but we invoke
-     targetm.sched.md_finish () for every ebb.  */
-  if (targetm.sched.md_init)
+  /* !!! We call target.sched.init () for the whole region, but we invoke
+     targetm.sched.finish () for every ebb.  */
+  if (targetm.sched.init)
     /* None of the arguments are actually used in any target.  */
-    targetm.sched.md_init (sched_dump, sched_verbose, -1);
+    targetm.sched.init (sched_dump, sched_verbose, -1);
 
   first_emitted_uid = get_max_uid () + 1;
   preheader_removed = false;
@@ -6949,11 +6949,11 @@  reset_sched_cycles_in_current_ebb (void)
   int haifa_clock = 0;
   insn_t insn;
 
-  if (targetm.sched.md_init)
+  if (targetm.sched.init)
     {
       /* None of the arguments are actually used in any target.
 	 NB: We should have md_reset () hook for cases like this.  */
-      targetm.sched.md_init (sched_dump, sched_verbose, -1);
+      targetm.sched.init (sched_dump, sched_verbose, -1);
     }
 
   state_reset (curr_state);
@@ -7131,14 +7131,14 @@  sel_region_target_finish (bool reset_sch
       if (reset_sched_cycles_p)
 	reset_sched_cycles_in_current_ebb ();
 
-      if (targetm.sched.md_init)
-	targetm.sched.md_init (sched_dump, sched_verbose, -1);
+      if (targetm.sched.init)
+	targetm.sched.init (sched_dump, sched_verbose, -1);
 
       put_TImodes ();
 
-      if (targetm.sched.md_finish)
+      if (targetm.sched.finish)
 	{
-	  targetm.sched.md_finish (sched_dump, sched_verbose);
+	  targetm.sched.finish (sched_dump, sched_verbose);
 
 	  /* Extend luids so that insns generated by the target will
 	     get zero luid.  */
Index: gcc/dwarf2out.c
===================================================================
--- gcc/dwarf2out.c	(revision 161494)
+++ gcc/dwarf2out.c	(working copy)
@@ -3463,8 +3463,8 @@  output_fde (dw_fde_ref fde, bool for_eh,
   char l1[20], l2[20];
   dw_cfi_ref cfi;
 
-  targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh,
-				/* empty */ 0);
+  targetm.asm_out.emit_unwind_label (asm_out_file, fde->decl, for_eh,
+				     /* empty */ 0);
   targetm.asm_out.internal_label (asm_out_file, FDE_LABEL,
 				  for_eh + j);
   ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + j);
@@ -3680,7 +3680,8 @@  output_call_frame_info (int for_eh)
 	else if (fde_needed_for_eh_p (&fde_table[i]))
 	  any_eh_needed = true;
 	else if (TARGET_USES_WEAK_UNWIND_INFO)
-	  targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl, 1, 1);
+	  targetm.asm_out.emit_unwind_label (asm_out_file, fde_table[i].decl,
+					     1, 1);
 
       if (!any_eh_needed)
 	return;
Index: gcc/opts.c
===================================================================
--- gcc/opts.c	(revision 161494)
+++ gcc/opts.c	(working copy)
@@ -1473,8 +1473,8 @@  common_handle_option (size_t scode, cons
       exit_after_options = true;
 
       /* Allow the target a chance to give the user some additional information.  */
-      if (targetm.target_help)
-	targetm.target_help ();
+      if (targetm.help)
+	targetm.help ();
       break;
 
     case OPT_fhelp_:
Index: gcc/tree-vect-data-refs.c
===================================================================
--- gcc/tree-vect-data-refs.c	(revision 161494)
+++ gcc/tree-vect-data-refs.c	(working copy)
@@ -3677,8 +3677,8 @@  vect_supportable_dr_alignment (struct da
 	}
 
       if (targetm.vectorize.
-	  builtin_support_vector_misalignment (mode, type,
-					       DR_MISALIGNMENT (dr), is_packed))
+	  support_vector_misalignment (mode, type,
+				       DR_MISALIGNMENT (dr), is_packed))
 	/* Can't software pipeline the loads, but can at least do them.  */
 	return dr_unaligned_supported;
     }
@@ -3696,8 +3696,8 @@  vect_supportable_dr_alignment (struct da
 	}
 
      if (targetm.vectorize.
-         builtin_support_vector_misalignment (mode, type,
-					      DR_MISALIGNMENT (dr), is_packed))
+         support_vector_misalignment (mode, type,
+				      DR_MISALIGNMENT (dr), is_packed))
        return dr_unaligned_supported;
     }
 
Index: gcc/genhooks.c
===================================================================
--- gcc/genhooks.c	(revision 0)
+++ gcc/genhooks.c	(revision 0)
@@ -0,0 +1,343 @@ 
+/* Process target.def to create initialization macros definition in
+   target-hooks-def.h and documentation in target-hooks.texi.
+   Copyright (C) 2009, 2010 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+You should have received a copy of the GNU General Public License
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */
+#include "bconfig.h"
+#include "system.h"
+#include <string.h>
+#include "hashtab.h"
+#include "errors.h"
+
+struct hook_desc { const char *doc, *type, *name, *param, *init; };
+static struct hook_desc hook_array[] = {
+#define HOOK_VECTOR_1(NAME, FRAGMENT) \
+  { 0, 0, #NAME, 0, 0 },
+#define DEFHOOKPOD(NAME, DOC, TYPE, INIT) \
+  { DOC, #TYPE, HOOK_PREFIX #NAME, 0, #INIT },
+#define DEFHOOK(NAME, DOC, TYPE, PARAMS, INIT) \
+  { DOC, #TYPE, HOOK_PREFIX #NAME, #PARAMS, #INIT },
+#define DEFHOOK_UNDOC(NAME, DOC, TYPE, PARAMS, INIT) \
+  { "*", #TYPE, HOOK_PREFIX #NAME, #PARAMS, #INIT },
+#include "target.def"
+#undef DEFHOOK
+};
+
+/* For each @Fcode in the the first paragraph of the documentation string DOC,
+   print an @findex directive.  HOOK_NAME is the name of the hook this bit of
+   documentation pertains to.  */
+static void
+emit_findices (const char *doc, const char *hook_name)
+{
+  const char *end = strstr (doc, "\n\n");
+  const char *fcode;
+
+  while ((fcode = strstr (doc, "@Fcode{")) && (!end || fcode < end))
+    {
+      fcode += strlen ("@Fcode{");
+      doc = strchr (fcode, '}');
+      if (!doc)
+	fatal ("Malformed @Fcode for hook %s\n", hook_name);
+      printf ("@findex %.*s\n", doc - fcode, fcode);
+      doc = fcode;
+    }
+}
+
+/* Return an upper-case copy of IN.  */
+static char *
+upstrdup (const char *in)
+{
+  char *p, *ret = xstrdup (in);
+  for (p = ret; *p; p++)
+    *p = TOUPPER (*p);
+  return ret;
+}
+
+/* Struct for 'start hooks' which start a sequence of consecutive hooks
+   that are defined in target.def and to be documented in tm.texi.  */
+struct s_hook
+{
+  char *name;
+  int pos;
+};
+
+static hashval_t
+s_hook_hash (const void *p)
+{
+  const struct s_hook *s_hook = (const struct s_hook *)p;
+  return htab_hash_string (s_hook->name);
+}
+
+static int
+s_hook_eq_p (const void *p1, const void *p2)
+{
+  return (strcmp (((const struct s_hook *) p1)->name, 
+		  ((const struct s_hook *) p2)->name) == 0);
+}
+
+/* Read the documentation file with name IN_FNAME, perform substitutions
+   to incorporate informtion from hook_array, and emit the result on stdout.
+   Hooks defined with DEFHOOK / DEFHOOKPOD are emitted at the place of a
+   matching @hook in the input file; if there is no matching @hook, the
+   hook is emitted after the hook that precedes it in target.def .
+   Usually, the emitted hook documentation starts with the hook
+   signature, followed by the string from the doc field.
+   The documentation is bracketed in @deftypefn / @deftypevr and a matching
+   @end.
+   While emitting the doc field, @Fcode is translated to @code, and an
+   @findex entry is added to the affected paragraph.
+   If the doc field starts with '*', the leading '*' is stripped, and the doc
+   field is otherwise emitted unaltered; no function signature/
+   @deftypefn/deftypevr/@end is emitted.
+   In particular, a doc field of "*" means not to emit any ocumentation for
+   this target.def / hook_array entry at all (there might be documentation
+   for this hook in the file named IN_FNAME, though).
+   A doc field of 0 is used to append the hook signature after the previous
+   hook's signture, so that one description can be used for a group of hooks.
+   When the doc field is "", @deftypefn/@deftypevr and the hook signature
+   is emitted, but not the matching @end.  This allows all the free-form
+   documentation to be placed in IN_FNAME, to work around GPL/GFDL
+   licensing incompatibility issues.  */
+static void
+emit_documentation (const char *in_fname)
+{
+  int i, j;
+  char buf[1000];
+  htab_t start_hooks = htab_create (99, s_hook_hash, s_hook_eq_p, (htab_del) 0);
+  FILE *f;
+  bool found_start = false;
+
+  /* Enter all the start hooks in start_hooks.  */
+  f = fopen (in_fname, "r");
+  if (!f)
+    {
+      perror ("");
+      fatal ("Couldn't open input file");
+    }
+  while (fscanf (f, "%*[^@]"), buf[0] = '\0',
+	 fscanf (f, "@%5[^ \n]", buf) != EOF)
+    {
+      void **p;
+      struct s_hook *shp;
+
+      if (strcmp (buf, "hook") != 0)
+	continue;
+      buf[0] = '\0';
+      fscanf (f, "%999s", buf);
+      shp = XNEW (struct s_hook);
+      shp->name = upstrdup (buf);
+      shp->pos = -1;
+      p = htab_find_slot (start_hooks, shp, INSERT);
+      if (*p != HTAB_EMPTY_ENTRY)
+	fatal ("Duplicate placement for hook %s\n", shp->name);
+      *(struct s_hook **) p = shp;
+    }
+  fclose (f);
+  /* For each hook in hook_array, if it is a start hook, store its position.  */
+  for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++)
+    {
+      struct s_hook sh, *shp;
+      void *p;
+
+      if (!hook_array[i].doc || strcmp (hook_array[i].doc, "*") == 0)
+	continue;
+      sh.name = upstrdup (hook_array[i].name);
+      p = htab_find (start_hooks, &sh);
+      if (p)
+	{
+	  shp = (struct s_hook *) p;
+	  if (shp->pos >= 0)
+	    fatal ("Duplicate hook %s\n", sh.name);
+	  shp->pos = i;
+	  found_start = true;
+	}
+      else if (!found_start)
+	fatal ("No place specified to document hook %s\n", sh.name);
+      free (sh.name);
+    }
+  /* Copy input file to stdout, substituting @hook directives with the
+     corresponding hook documentation sequences.  */
+  f = fopen (in_fname, "r");
+  if (!f)
+    {
+      perror ("");
+      fatal ("Couldn't open input file");
+    }
+  for (;;)
+    {
+      struct s_hook sh, *shp;
+      int c = getc (f);
+      char *name;
+
+      if (c == EOF)
+	break;
+      if (c != '@')
+	{
+	  putchar (c);
+	  continue;
+	}
+      buf[0] = '\0';
+      fscanf (f, "%5[^ \n]", buf);
+      if (strcmp (buf, "hook") != 0)
+	{
+	  printf ("@%s", buf);
+	  continue;
+	}
+      fscanf (f, "%999s", buf);
+      sh.name = name = upstrdup (buf);
+      shp = (struct s_hook *) htab_find (start_hooks, &sh);
+      if (!shp || shp->pos < 0)
+	fatal ("No documentation for hook %s\n", sh.name);
+      i = shp->pos;
+      do
+	{
+	  const char *q, *e;
+	  const char *deftype;
+	  const char *doc, *fcode, *p_end;
+
+	  /* A leading '*' means to output the documentation string without
+	     further processing.  */
+	  if (*hook_array[i].doc == '*')
+	    printf ("%s", hook_array[i].doc + 1);
+	  else
+	    {
+	      if (i != shp->pos)
+		printf ("\n\n");
+	      emit_findices (hook_array[i].doc, name);
+
+	      /* Print header.  Function-valued hooks have a parameter list, 
+		 unlike POD-valued ones.  */
+	      deftype = hook_array[i].param ? "deftypefn" : "deftypevr";
+	      printf ("@%s {Target Hook} ", deftype);
+	      if (strchr (hook_array[i].type, ' '))
+		printf ("{%s}", hook_array[i].type);
+	      else
+		printf ("%s", hook_array[i].type);
+	      printf (" %s", name);
+	      if (hook_array[i].param)
+		{
+		  /* Print the parameter list, with the parameter names
+		     enclosed in @var{}.  */
+		  printf (" ");
+		  for (q = hook_array[i].param; (e = strpbrk (q, " *,)"));
+		       q = e + 1)
+		    /* Type names like 'int' are followed by a space, sometimes
+		       also by '*'.  'void' should appear only in "(void)".  */
+		    if (*e == ' ' || *e == '*' || *q == '(')
+		      printf ("%.*s", e - q + 1, q);
+		    else
+		      printf ("@var{%.*s}%c", e - q, q, *e);
+		}
+	      /* POD-valued hooks sometimes come in groups with common
+		 documentation.*/
+	      for (j = i + 1;
+		   j < (int) (sizeof hook_array / sizeof hook_array[0])
+		   && hook_array[j].doc == 0 && hook_array[j].type; j++)
+		{
+		  char *namex = upstrdup (hook_array[j].name);
+
+		  printf ("\n@%sx {Target Hook} {%s} %s",
+			  deftype, hook_array[j].type, namex);
+		}
+	      if (hook_array[i].doc[0])
+		{
+		  printf ("\n");
+		  /* Print each documentation paragraph in turn.  */
+		  for (doc = hook_array[i].doc; *doc; doc = p_end)
+		    {
+		      /* Find paragraph end.  */
+		      p_end = strstr (doc, "\n\n");
+		      p_end = (p_end ? p_end + 2 : doc + strlen (doc));
+		      /* Print paragraph, emitting @Fcode as @code.  */
+		      for (; (fcode = strstr (doc, "@Fcode{")) && fcode < p_end;
+			   doc = fcode + 2)
+			printf ("%.*s@", fcode - doc, doc);
+		      printf ("%.*s", p_end - doc, doc);
+		      /* Emit function indices for next paragraph.  */
+		      emit_findices (p_end, name);
+		    }
+		  printf ("\n@end %s", deftype);
+		}
+	    }
+	  if (++i >= (int) (sizeof hook_array / sizeof hook_array[0])
+	      || !hook_array[i].doc)
+	    break;
+	  free (name);
+	  sh.name = name = upstrdup (hook_array[i].name);
+	}
+      while (!htab_find (start_hooks, &sh));
+      free (name);
+    }
+}
+
+/* Emit #defines to stdout (this will be redirected to generate
+   target-hook-def.h) which set target hooks initializer macros
+   to their default values.  */
+static void
+emit_init_macros (void)
+{
+  int i;
+  const int MAX_NEST = 2;
+  int print_nest, nest = 0;
+
+  for (print_nest = 0; print_nest <= MAX_NEST; print_nest++)
+    {
+      for (i = 0; i < (int) (sizeof hook_array / sizeof hook_array[0]); i++)
+	{
+	  char *name = upstrdup (hook_array[i].name);
+
+	  if (!hook_array[i].type)
+	    {
+	      if (*name)
+		{
+		  if (nest && nest == print_nest)
+		    printf ("    %s, \\\n", name);
+		  nest++;
+		  if (nest > MAX_NEST)
+		    fatal ("Unexpected nesting of %s\n", name);
+		  if (nest == print_nest)
+		    printf ("\n#define %s \\\n  { \\\n", name);
+		}
+	      else
+		{
+		  if (nest == print_nest)
+		    printf ("  }\n");
+		  nest--;
+		}
+	      continue;
+	    }
+	  if (0 == print_nest)
+	    {
+	      /* Output default definitions of target hooks.  */
+	      printf ("#ifndef %s\n#define %s %s\n#endif\n",
+		      name, name, hook_array[i].init);
+	    }
+	  if (nest == print_nest)
+	    printf ("    %s, \\\n", name);
+	}
+    }
+}
+
+int
+main (int argc, char **argv)
+{
+  if (argc >= 2)
+    emit_documentation (argv[1]);
+  else
+    emit_init_macros ();
+  return 0;
+}
Index: gcc/except.c
===================================================================
--- gcc/except.c	(revision 161494)
+++ gcc/except.c	(working copy)
@@ -2930,7 +2930,7 @@  output_one_function_exception_table (con
 #endif
 
   /* If the target wants a label to begin the table, emit it here.  */
-  targetm.asm_out.except_table_label (asm_out_file);
+  targetm.asm_out.emit_except_table_label (asm_out_file);
 
   have_tt_data = (VEC_length (tree, cfun->eh->ttype_data)
 		  || (targetm.arm_eabi_unwinder
Index: gcc/po/EXCLUDES
===================================================================
--- gcc/po/EXCLUDES	(revision 161494)
+++ gcc/po/EXCLUDES	(working copy)
@@ -74,6 +74,7 @@  genextract.c
 genflags.c
 gengenrtl.c
 gengtype.c
+genhooks.c
 genmodes.c
 genopinit.c
 genoutput.c
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c	(revision 161494)
+++ gcc/varasm.c	(working copy)
@@ -5979,7 +5979,7 @@  maybe_assemble_visibility (tree decl)
 
   if (vis != VISIBILITY_DEFAULT)
     {
-      targetm.asm_out.visibility (decl, vis);
+      targetm.asm_out.assemble_visibility (decl, vis);
       return 1;
     }
   else
@@ -6905,11 +6905,11 @@  default_asm_declare_constant_name (FILE 
 void
 default_file_start (void)
 {
-  if (targetm.file_start_app_off
+  if (targetm.asm_file_start_app_off
       && !(flag_verbose_asm || flag_debug_asm || flag_dump_rtl_in_asm))
     fputs (ASM_APP_OFF, asm_out_file);
 
-  if (targetm.file_start_file_directive)
+  if (targetm.asm_file_start_file_directive)
     output_file_directive (asm_out_file, main_input_filename);
 }
 
Index: gcc/target-def.h
===================================================================
--- gcc/target-def.h	(revision 161494)
+++ gcc/target-def.h	(working copy)
@@ -20,7 +20,7 @@ 
    You are forbidden to forbid anyone else to use, share and improve
    what you give them.   Help stamp out software-hoarding!  */
 
-/* See target.h for a description of what this file contains and how to
+/* See target.def for a description of what this file contains and how to
    use it.
 
    We want to have non-NULL default definitions of all hook functions,
@@ -30,16 +30,6 @@ 
    rather than the .c file, then we need to wrap the default
    definition in a #ifndef, since files include tm.h before this one.  */
 
-/* Assembler output.  */
-#ifndef TARGET_ASM_OPEN_PAREN
-#define TARGET_ASM_OPEN_PAREN "("
-#endif
-#ifndef TARGET_ASM_CLOSE_PAREN
-#define TARGET_ASM_CLOSE_PAREN ")"
-#endif
-
-#define TARGET_ASM_BYTE_OP "\t.byte\t"
-
 #define TARGET_ASM_ALIGNED_HI_OP "\t.short\t"
 #define TARGET_ASM_ALIGNED_SI_OP "\t.long\t"
 #define TARGET_ASM_ALIGNED_DI_OP NULL
@@ -58,69 +48,6 @@ 
 #define TARGET_ASM_UNALIGNED_TI_OP NULL
 #endif /* OBJECT_FORMAT_ELF */
 
-#define TARGET_ASM_INTEGER default_assemble_integer
-
-#ifndef TARGET_ASM_GLOBALIZE_LABEL
-#define TARGET_ASM_GLOBALIZE_LABEL default_globalize_label
-#endif
-
-#ifndef TARGET_ASM_GLOBALIZE_DECL_NAME
-#define TARGET_ASM_GLOBALIZE_DECL_NAME default_globalize_decl_name
-#endif
-
-#ifndef TARGET_ASM_EMIT_UNWIND_LABEL
-#define TARGET_ASM_EMIT_UNWIND_LABEL default_emit_unwind_label
-#endif
-
-#ifndef TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL
-#define TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL default_emit_except_table_label
-#endif
-
-#ifndef TARGET_UNWIND_EMIT
-#define TARGET_UNWIND_EMIT default_unwind_emit
-#endif
-
-#ifndef TARGET_ASM_INTERNAL_LABEL
-#define TARGET_ASM_INTERNAL_LABEL default_internal_label
-#endif
-
-#ifndef TARGET_ASM_DECLARE_CONSTANT_NAME
-#define TARGET_ASM_DECLARE_CONSTANT_NAME default_asm_declare_constant_name
-#endif
-
-#ifndef TARGET_ASM_TTYPE
-#define TARGET_ASM_TTYPE hook_bool_rtx_false
-#endif
-
-#ifndef TARGET_ASM_ASSEMBLE_VISIBILITY
-#define TARGET_ASM_ASSEMBLE_VISIBILITY default_assemble_visibility
-#endif
-
-#define TARGET_ASM_FUNCTION_PROLOGUE default_function_pro_epilogue
-#define TARGET_ASM_FUNCTION_EPILOGUE default_function_pro_epilogue
-#define TARGET_ASM_FUNCTION_END_PROLOGUE no_asm_to_stream
-#define TARGET_ASM_FUNCTION_BEGIN_EPILOGUE no_asm_to_stream
-
-#ifndef TARGET_ASM_RELOC_RW_MASK
-#define TARGET_ASM_RELOC_RW_MASK default_reloc_rw_mask
-#endif
-
-#ifndef TARGET_ASM_SELECT_SECTION
-#define TARGET_ASM_SELECT_SECTION default_select_section
-#endif
-
-#ifndef TARGET_ASM_UNIQUE_SECTION
-#define TARGET_ASM_UNIQUE_SECTION default_unique_section
-#endif
-
-#ifndef TARGET_ASM_FUNCTION_RODATA_SECTION
-#define TARGET_ASM_FUNCTION_RODATA_SECTION default_function_rodata_section
-#endif
-
-#ifndef TARGET_ASM_SELECT_RTX_SECTION
-#define TARGET_ASM_SELECT_RTX_SECTION default_select_rtx_section
-#endif
-
 #if !defined(TARGET_ASM_CONSTRUCTOR) && !defined(USE_COLLECT2)
 # ifdef CTORS_SECTION_ASM_OP
 #  define TARGET_ASM_CONSTRUCTOR default_ctor_section_asm_out_constructor
@@ -145,137 +72,25 @@ 
 # endif
 #endif
 
-#define TARGET_ASM_OUTPUT_MI_THUNK NULL
-#define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_false
-
 #if !defined(TARGET_HAVE_CTORS_DTORS)
 # if defined(TARGET_ASM_CONSTRUCTOR) && defined(TARGET_ASM_DESTRUCTOR)
 # define TARGET_HAVE_CTORS_DTORS true
-# else
-# define TARGET_HAVE_CTORS_DTORS false
-# define TARGET_ASM_CONSTRUCTOR NULL
-# define TARGET_ASM_DESTRUCTOR NULL
 # endif
 #endif
 
-#ifndef TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
-#define TARGET_HAVE_SWITCHABLE_BSS_SECTIONS false
-#endif
-
-#ifndef TARGET_ASM_INIT_SECTIONS
-#define TARGET_ASM_INIT_SECTIONS hook_void_void
-#endif
-
 #ifdef TARGET_ASM_NAMED_SECTION
 #define TARGET_HAVE_NAMED_SECTIONS true
-#else
-#define TARGET_ASM_NAMED_SECTION default_no_named_section
-#define TARGET_HAVE_NAMED_SECTIONS false
-#endif
-
-#ifndef TARGET_INVALID_WITHIN_DOLOOP
-#define TARGET_INVALID_WITHIN_DOLOOP default_invalid_within_doloop
-#endif
-
-#ifndef TARGET_VALID_DLLIMPORT_ATTRIBUTE_P
-#define TARGET_VALID_DLLIMPORT_ATTRIBUTE_P hook_bool_const_tree_true
-#endif
-
-#ifndef TARGET_HAVE_TLS
-#define TARGET_HAVE_TLS false
-#endif
-
-#ifndef TARGET_HAVE_SRODATA_SECTION
-#define TARGET_HAVE_SRODATA_SECTION false
 #endif
 
 #ifndef TARGET_TERMINATE_DW2_EH_FRAME_INFO
 #ifdef EH_FRAME_SECTION_NAME
 #define TARGET_TERMINATE_DW2_EH_FRAME_INFO false
-#else
-#define TARGET_TERMINATE_DW2_EH_FRAME_INFO true
-#endif
-#endif
-
-#define TARGET_DWARF_REGISTER_SPAN hook_rtx_rtx_null
-#define TARGET_INIT_DWARF_REG_SIZES_EXTRA hook_void_tree
-
-#ifndef TARGET_ASM_FILE_START
-#define TARGET_ASM_FILE_START default_file_start
-#endif
-
-#ifndef TARGET_ASM_FILE_END
-#define TARGET_ASM_FILE_END hook_void_void
-#endif
-
-#ifndef TARGET_ASM_LTO_START
-#define TARGET_ASM_LTO_START hook_void_void
-#endif
-
-#ifndef TARGET_ASM_LTO_END
-#define TARGET_ASM_LTO_END hook_void_void
-#endif
-
-#ifndef TARGET_ASM_CODE_END
-#define TARGET_ASM_CODE_END hook_void_void
-#endif
-
-#ifndef TARGET_EXTRA_LIVE_ON_ENTRY
-#define TARGET_EXTRA_LIVE_ON_ENTRY hook_void_bitmap
-#endif
-
-#ifndef TARGET_ASM_FILE_START_APP_OFF
-#define TARGET_ASM_FILE_START_APP_OFF false
-#endif
-
-#ifndef TARGET_ASM_FILE_START_FILE_DIRECTIVE
-#define TARGET_ASM_FILE_START_FILE_DIRECTIVE false
 #endif
-
-#ifndef TARGET_ASM_EXTERNAL_LIBCALL
-#define TARGET_ASM_EXTERNAL_LIBCALL default_external_libcall
-#endif
-
-#ifndef TARGET_ASM_MARK_DECL_PRESERVED
-#define TARGET_ASM_MARK_DECL_PRESERVED hook_void_constcharptr
 #endif
 
-#ifndef TARGET_ASM_OUTPUT_ANCHOR
-#ifdef ASM_OUTPUT_DEF
-#define TARGET_ASM_OUTPUT_ANCHOR default_asm_output_anchor
-#else
+#if !defined(TARGET_ASM_OUTPUT_ANCHOR) && !defined(ASM_OUTPUT_DEF)
 #define TARGET_ASM_OUTPUT_ANCHOR NULL
 #endif
-#endif
-
-#ifndef TARGET_ASM_OUTPUT_DWARF_DTPREL
-#define TARGET_ASM_OUTPUT_DWARF_DTPREL NULL
-#endif
-
-#ifndef TARGET_ASM_FINAL_POSTSCAN_INSN
-#define TARGET_ASM_FINAL_POSTSCAN_INSN NULL
-#endif
-
-#ifndef TARGET_ASM_RECORD_GCC_SWITCHES
-#define TARGET_ASM_RECORD_GCC_SWITCHES NULL
-#endif
-#ifndef TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
-#define TARGET_ASM_RECORD_GCC_SWITCHES_SECTION ".GCC.command.line"
-#endif
-
-#define TARGET_ASM_TRAMPOLINE_TEMPLATE NULL
-
-#ifndef TARGET_PRINT_OPERAND
-#define TARGET_PRINT_OPERAND default_print_operand
-#endif
-
-#ifndef TARGET_PRINT_OPERAND_ADDRESS
-#define TARGET_PRINT_OPERAND_ADDRESS default_print_operand_address
-#endif
-
-#ifndef TARGET_PRINT_OPERAND_PUNCT_VALID_P
-#define TARGET_PRINT_OPERAND_PUNCT_VALID_P default_print_operand_punct_valid_p
-#endif
 
 #define TARGET_ASM_ALIGNED_INT_OP				\
 		       {TARGET_ASM_ALIGNED_HI_OP,		\
@@ -289,817 +104,11 @@ 
 			TARGET_ASM_UNALIGNED_DI_OP,		\
 			TARGET_ASM_UNALIGNED_TI_OP}
 
-#define TARGET_ASM_OUT {TARGET_ASM_OPEN_PAREN,			\
-			TARGET_ASM_CLOSE_PAREN,			\
-			TARGET_ASM_BYTE_OP,			\
-			TARGET_ASM_ALIGNED_INT_OP,		\
-			TARGET_ASM_UNALIGNED_INT_OP,		\
-			TARGET_ASM_INTEGER,			\
-			TARGET_ASM_GLOBALIZE_LABEL,		\
-			TARGET_ASM_GLOBALIZE_DECL_NAME,		\
-                        TARGET_ASM_EMIT_UNWIND_LABEL,           \
-			TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL,	\
-			TARGET_UNWIND_EMIT,			\
-			TARGET_ASM_INTERNAL_LABEL,		\
-			TARGET_ASM_DECLARE_CONSTANT_NAME,	\
-			TARGET_ASM_TTYPE,			\
-			TARGET_ASM_ASSEMBLE_VISIBILITY,		\
-			TARGET_ASM_FUNCTION_PROLOGUE,		\
-			TARGET_ASM_FUNCTION_END_PROLOGUE,	\
-			TARGET_ASM_FUNCTION_BEGIN_EPILOGUE,	\
-			TARGET_ASM_FUNCTION_EPILOGUE,		\
-			TARGET_ASM_INIT_SECTIONS,		\
-			TARGET_ASM_NAMED_SECTION,		\
-			TARGET_ASM_RELOC_RW_MASK,		\
-			TARGET_ASM_SELECT_SECTION,		\
-			TARGET_ASM_SELECT_RTX_SECTION,		\
-			TARGET_ASM_UNIQUE_SECTION,		\
-			TARGET_ASM_FUNCTION_RODATA_SECTION,	\
-			TARGET_ASM_CONSTRUCTOR,			\
-			TARGET_ASM_DESTRUCTOR,                  \
-                        TARGET_ASM_OUTPUT_MI_THUNK,             \
-                        TARGET_ASM_CAN_OUTPUT_MI_THUNK,         \
-                        TARGET_ASM_FILE_START,                  \
-                        TARGET_ASM_FILE_END,			\
-                        TARGET_ASM_LTO_START,			\
-                        TARGET_ASM_LTO_END,			\
-                        TARGET_ASM_CODE_END,			\
-			TARGET_ASM_EXTERNAL_LIBCALL,            \
-                        TARGET_ASM_MARK_DECL_PRESERVED,		\
-			TARGET_ASM_RECORD_GCC_SWITCHES,		\
-			TARGET_ASM_RECORD_GCC_SWITCHES_SECTION,	\
-			TARGET_ASM_OUTPUT_ANCHOR,		\
-			TARGET_ASM_OUTPUT_DWARF_DTPREL,		\
-			TARGET_ASM_FINAL_POSTSCAN_INSN,		\
-			TARGET_ASM_TRAMPOLINE_TEMPLATE,		\
-			TARGET_PRINT_OPERAND,			\
-			TARGET_PRINT_OPERAND_ADDRESS,		\
-			TARGET_PRINT_OPERAND_PUNCT_VALID_P }
-
-/* Scheduler hooks.  All of these default to null pointers, which
-   haifa-sched.c looks for and handles.  */
-#define TARGET_SCHED_ADJUST_COST 0
-#define TARGET_SCHED_ADJUST_PRIORITY 0
-#define TARGET_SCHED_ISSUE_RATE 0
-#define TARGET_SCHED_VARIABLE_ISSUE 0
-#define TARGET_SCHED_INIT 0
-#define TARGET_SCHED_FINISH 0
-#define TARGET_SCHED_INIT_GLOBAL 0
-#define TARGET_SCHED_FINISH_GLOBAL 0
-#define TARGET_SCHED_REORDER 0
-#define TARGET_SCHED_REORDER2 0
-#define TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK 0
-#define TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN 0
-#define TARGET_SCHED_DFA_PRE_CYCLE_INSN 0
-#define TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN 0
-#define TARGET_SCHED_DFA_POST_CYCLE_INSN 0
-#define TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE 0
-#define TARGET_SCHED_DFA_POST_ADVANCE_CYCLE 0
-#define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD 0
-#define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD 0
-#define TARGET_SCHED_DFA_NEW_CYCLE 0
-#define TARGET_SCHED_IS_COSTLY_DEPENDENCE 0
-#define TARGET_SCHED_ADJUST_COST_2 0
-#define TARGET_SCHED_H_I_D_EXTENDED 0
-#define TARGET_SCHED_ALLOC_SCHED_CONTEXT 0
-#define TARGET_SCHED_INIT_SCHED_CONTEXT 0
-#define TARGET_SCHED_SET_SCHED_CONTEXT 0
-#define TARGET_SCHED_CLEAR_SCHED_CONTEXT 0
-#define TARGET_SCHED_FREE_SCHED_CONTEXT 0
-#define TARGET_SCHED_SPECULATE_INSN 0
-#define TARGET_SCHED_NEEDS_BLOCK_P 0
-#define TARGET_SCHED_GEN_SPEC_CHECK 0
-#define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC 0
-#define TARGET_SCHED_SET_SCHED_FLAGS 0
-#define TARGET_SCHED_GET_INSN_SPEC_DS 0
-#define TARGET_SCHED_GET_INSN_CHECKED_DS 0
-#define TARGET_SCHED_SKIP_RTX_P 0
-#define TARGET_SCHED_SMS_RES_MII 0
-
-#define TARGET_SCHED						\
-  {TARGET_SCHED_ADJUST_COST,					\
-   TARGET_SCHED_ADJUST_PRIORITY,				\
-   TARGET_SCHED_ISSUE_RATE,					\
-   TARGET_SCHED_VARIABLE_ISSUE,					\
-   TARGET_SCHED_INIT,						\
-   TARGET_SCHED_FINISH,						\
-   TARGET_SCHED_INIT_GLOBAL,					\
-   TARGET_SCHED_FINISH_GLOBAL,					\
-   TARGET_SCHED_REORDER,					\
-   TARGET_SCHED_REORDER2,					\
-   TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK,			\
-   TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN,			\
-   TARGET_SCHED_DFA_PRE_CYCLE_INSN,				\
-   TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN,			\
-   TARGET_SCHED_DFA_POST_CYCLE_INSN,			        \
-   TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE,                          \
-   TARGET_SCHED_DFA_POST_ADVANCE_CYCLE,                         \
-   TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD,		\
-   TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD,	\
-   TARGET_SCHED_DFA_NEW_CYCLE,					\
-   TARGET_SCHED_IS_COSTLY_DEPENDENCE,                           \
-   TARGET_SCHED_ADJUST_COST_2,                                  \
-   TARGET_SCHED_H_I_D_EXTENDED,					\
-   TARGET_SCHED_ALLOC_SCHED_CONTEXT,                            \
-   TARGET_SCHED_INIT_SCHED_CONTEXT,                             \
-   TARGET_SCHED_SET_SCHED_CONTEXT,                              \
-   TARGET_SCHED_CLEAR_SCHED_CONTEXT,                            \
-   TARGET_SCHED_FREE_SCHED_CONTEXT,                             \
-   TARGET_SCHED_SPECULATE_INSN,                                 \
-   TARGET_SCHED_NEEDS_BLOCK_P,                                  \
-   TARGET_SCHED_GEN_SPEC_CHECK,				        \
-   TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC, \
-   TARGET_SCHED_SET_SCHED_FLAGS,                                \
-   TARGET_SCHED_GET_INSN_SPEC_DS,                               \
-   TARGET_SCHED_GET_INSN_CHECKED_DS,                            \
-   TARGET_SCHED_SKIP_RTX_P,					\
-   TARGET_SCHED_SMS_RES_MII}
-
-#define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD 0
-#define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
-  default_builtin_vectorized_function
-#define TARGET_VECTORIZE_BUILTIN_CONVERSION \
-  default_builtin_vectorized_conversion
-#define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN 0
-#define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD 0
-#define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
-  default_builtin_vectorization_cost
-#define TARGET_VECTOR_ALIGNMENT_REACHABLE \
-  default_builtin_vector_alignment_reachable
-#define TARGET_VECTORIZE_BUILTIN_VEC_PERM 0
-#define TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK \
-  hook_bool_tree_tree_true
-#define TARGET_SUPPORT_VECTOR_MISALIGNMENT \
-  default_builtin_support_vector_misalignment
-
-
-#define TARGET_VECTORIZE                                                \
-  {									\
-    TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD,				\
-    TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION,			\
-    TARGET_VECTORIZE_BUILTIN_CONVERSION,				\
-    TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN,                            \
-    TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD,				\
-    TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST,			\
-    TARGET_VECTOR_ALIGNMENT_REACHABLE,                                  \
-    TARGET_VECTORIZE_BUILTIN_VEC_PERM,					\
-    TARGET_VECTORIZE_BUILTIN_VEC_PERM_OK,				\
-    TARGET_SUPPORT_VECTOR_MISALIGNMENT					\
-  }
-
-#define TARGET_DEFAULT_TARGET_FLAGS 0
-
-#define TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE hook_void_void
-
-#define TARGET_HANDLE_OPTION hook_bool_size_t_constcharptr_int_true
-#define TARGET_HANDLE_OFAST hook_void_void
-#define TARGET_HELP NULL
-
-/* In except.c */
-#define TARGET_EH_RETURN_FILTER_MODE  default_eh_return_filter_mode
-
-/* In libgcc2.c */
-#define TARGET_LIBGCC_CMP_RETURN_MODE  default_libgcc_cmp_return_mode
-#define TARGET_LIBGCC_SHIFT_COUNT_MODE default_libgcc_shift_count_mode
-
-/* In unwind-generic.h.  */
-#define TARGET_UNWIND_WORD_MODE default_unwind_word_mode
-
-/* In tree.c.  */
-#define TARGET_MERGE_DECL_ATTRIBUTES merge_decl_attributes
-#define TARGET_MERGE_TYPE_ATTRIBUTES merge_type_attributes
-#define TARGET_ATTRIBUTE_TABLE NULL
-
-/* In cse.c.  */
-#define TARGET_ADDRESS_COST default_address_cost
-#define TARGET_CONST_ANCHOR 0
-
-#ifndef TARGET_REGISTER_MOVE_COST
-#define TARGET_REGISTER_MOVE_COST default_register_move_cost
-#endif
-
-#ifndef TARGET_MEMORY_MOVE_COST
-#define TARGET_MEMORY_MOVE_COST default_memory_move_cost
-#endif
-
-/* In builtins.c.  */
-#define TARGET_INIT_BUILTINS hook_void_void
-#define TARGET_EXPAND_BUILTIN default_expand_builtin
-#define TARGET_RESOLVE_OVERLOADED_BUILTIN NULL
-#define TARGET_FOLD_BUILTIN hook_tree_tree_int_treep_bool_null
-#define TARGET_BUILTIN_DECL NULL
-
-/* In tree-ssa-math-opts.c  */
-#define TARGET_BUILTIN_RECIPROCAL default_builtin_reciprocal
-
-/* In varasm.c.  */
-#ifndef TARGET_SECTION_TYPE_FLAGS
-#define TARGET_SECTION_TYPE_FLAGS default_section_type_flags
-#endif
-
-#ifndef TARGET_STRIP_NAME_ENCODING
-#define TARGET_STRIP_NAME_ENCODING default_strip_name_encoding
-#endif
-
-#ifndef TARGET_BINDS_LOCAL_P
-#define TARGET_BINDS_LOCAL_P default_binds_local_p
-#endif
-
-#ifndef TARGET_SHIFT_TRUNCATION_MASK
-#define TARGET_SHIFT_TRUNCATION_MASK default_shift_truncation_mask
-#endif
-
-#ifndef TARGET_MIN_DIVISIONS_FOR_RECIP_MUL
-#define TARGET_MIN_DIVISIONS_FOR_RECIP_MUL default_min_divisions_for_recip_mul
-#endif
-
-#ifndef TARGET_MODE_REP_EXTENDED
-#define TARGET_MODE_REP_EXTENDED default_mode_rep_extended
-#endif
-
-#ifndef TARGET_VALID_POINTER_MODE
-#define TARGET_VALID_POINTER_MODE default_valid_pointer_mode
-#endif
-
-#ifndef TARGET_ADDR_SPACE_POINTER_MODE
-#define TARGET_ADDR_SPACE_POINTER_MODE default_addr_space_pointer_mode
-#endif
-
-#ifndef TARGET_ADDR_SPACE_ADDRESS_MODE
-#define TARGET_ADDR_SPACE_ADDRESS_MODE default_addr_space_address_mode
-#endif
-
-#ifndef TARGET_ADDR_SPACE_VALID_POINTER_MODE
-#define TARGET_ADDR_SPACE_VALID_POINTER_MODE \
-	default_addr_space_valid_pointer_mode
-#endif
-
-#ifndef TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
-#define TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P \
-  default_addr_space_legitimate_address_p
-#endif
-
-#ifndef TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS
-#define TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS \
-  default_addr_space_legitimize_address
-#endif
-
-#ifndef TARGET_ADDR_SPACE_SUBSET_P
-#define TARGET_ADDR_SPACE_SUBSET_P default_addr_space_subset_p
-#endif
-
-#ifndef TARGET_ADDR_SPACE_CONVERT
-#define TARGET_ADDR_SPACE_CONVERT default_addr_space_convert
-#endif
-
-#define TARGET_ADDR_SPACE_HOOKS			\
-  {						\
-    TARGET_ADDR_SPACE_POINTER_MODE,		\
-    TARGET_ADDR_SPACE_ADDRESS_MODE,		\
-    TARGET_ADDR_SPACE_VALID_POINTER_MODE,	\
-    TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P,	\
-    TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS,	\
-    TARGET_ADDR_SPACE_SUBSET_P,			\
-    TARGET_ADDR_SPACE_CONVERT,			\
-  }
-
-#ifndef TARGET_SCALAR_MODE_SUPPORTED_P
-#define TARGET_SCALAR_MODE_SUPPORTED_P default_scalar_mode_supported_p
-#endif
-
-#ifndef TARGET_ENUM_VA_LIST_P
-#define TARGET_ENUM_VA_LIST_P NULL
-#endif
-
-#ifndef TARGET_DECIMAL_FLOAT_SUPPORTED_P
-#define TARGET_DECIMAL_FLOAT_SUPPORTED_P default_decimal_float_supported_p
-#endif
-
-#ifndef TARGET_FIXED_POINT_SUPPORTED_P
-#define TARGET_FIXED_POINT_SUPPORTED_P default_fixed_point_supported_p
-#endif
-
-#ifndef TARGET_VECTOR_MODE_SUPPORTED_P
-#define TARGET_VECTOR_MODE_SUPPORTED_P hook_bool_mode_false
-#endif
-
-#ifndef TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
-#define TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P hook_bool_mode_false
-#endif
-
-/* In hooks.c.  */
-#define TARGET_CANNOT_MODIFY_JUMPS_P hook_bool_void_false
-#define TARGET_BRANCH_TARGET_REGISTER_CLASS \
-  default_branch_target_register_class
-#define TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED hook_bool_bool_false
-#define TARGET_HAVE_CONDITIONAL_EXECUTION default_have_conditional_execution
-#define TARGET_LOOP_UNROLL_ADJUST NULL
-#define TARGET_CANNOT_FORCE_CONST_MEM hook_bool_rtx_false
-#define TARGET_CANNOT_COPY_INSN_P NULL
-#define TARGET_COMMUTATIVE_P hook_bool_const_rtx_commutative_p
-#define TARGET_LEGITIMIZE_ADDRESS default_legitimize_address
-#define TARGET_DELEGITIMIZE_ADDRESS delegitimize_mem_from_attrs
-#define TARGET_LEGITIMATE_ADDRESS_P default_legitimate_address_p
-#define TARGET_USE_BLOCKS_FOR_CONSTANT_P hook_bool_mode_const_rtx_false
-#define TARGET_MIN_ANCHOR_OFFSET 0
-#define TARGET_MAX_ANCHOR_OFFSET 0
-#define TARGET_USE_ANCHORS_FOR_SYMBOL_P default_use_anchors_for_symbol_p
-#define TARGET_FUNCTION_OK_FOR_SIBCALL hook_bool_tree_tree_false
-#define TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P hook_bool_const_tree_false
-#define TARGET_COMP_TYPE_ATTRIBUTES hook_int_const_tree_const_tree_1
-#ifndef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
-#define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES hook_void_tree
-#endif
-#define TARGET_INSERT_ATTRIBUTES hook_void_tree_treeptr
-#define TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P hook_bool_const_tree_false
-#define TARGET_MS_BITFIELD_LAYOUT_P hook_bool_const_tree_false
-#define TARGET_ALIGN_ANON_BITFIELD hook_bool_void_false
-#define TARGET_NARROW_VOLATILE_BITFIELD hook_bool_void_false
-#define TARGET_RTX_COSTS hook_bool_rtx_int_int_intp_bool_false
-#define TARGET_MANGLE_TYPE hook_constcharptr_const_tree_null
-#define TARGET_ALLOCATE_INITIAL_VALUE NULL
-
-#define TARGET_UNSPEC_MAY_TRAP_P default_unspec_may_trap_p
-
-#ifndef TARGET_SET_CURRENT_FUNCTION
-#define TARGET_SET_CURRENT_FUNCTION hook_void_tree
-#endif
-
-#ifndef TARGET_INIT_LIBFUNCS
-#define TARGET_INIT_LIBFUNCS hook_void_void
-#endif
-
-#ifndef TARGET_IN_SMALL_DATA_P
-#define TARGET_IN_SMALL_DATA_P hook_bool_const_tree_false
-#endif
-
-#ifndef TARGET_MODE_DEPENDENT_ADDRESS_P
-#define TARGET_MODE_DEPENDENT_ADDRESS_P default_mode_dependent_address_p
-#endif
-
-#ifndef TARGET_MANGLE_DECL_ASSEMBLER_NAME
-#define TARGET_MANGLE_DECL_ASSEMBLER_NAME default_mangle_decl_assembler_name
-#endif
-
-#ifndef TARGET_ENCODE_SECTION_INFO
-#define TARGET_ENCODE_SECTION_INFO default_encode_section_info
-#endif
-
-#ifndef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
-#define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN hook_invalid_arg_for_unprototyped_fn
-#endif
-
-#define TARGET_INVALID_CONVERSION hook_constcharptr_const_tree_const_tree_null
-#define TARGET_INVALID_UNARY_OP hook_constcharptr_int_const_tree_null
-#define TARGET_INVALID_BINARY_OP hook_constcharptr_int_const_tree_const_tree_null
-#define TARGET_INVALID_PARAMETER_TYPE hook_constcharptr_const_tree_null
-#define TARGET_INVALID_RETURN_TYPE hook_constcharptr_const_tree_null
-#define TARGET_PROMOTED_TYPE hook_tree_const_tree_null
-#define TARGET_CONVERT_TO_TYPE hook_tree_tree_tree_null
-
-#define TARGET_FIXED_CONDITION_CODE_REGS hook_bool_uintp_uintp_false
-
-#define TARGET_CC_MODES_COMPATIBLE default_cc_modes_compatible
-
-#define TARGET_MACHINE_DEPENDENT_REORG 0
-
-#define TARGET_BUILD_BUILTIN_VA_LIST std_build_builtin_va_list
-#define TARGET_FN_ABI_VA_LIST std_fn_abi_va_list
-#define TARGET_CANONICAL_VA_LIST_TYPE std_canonical_va_list_type
-#define TARGET_EXPAND_BUILTIN_VA_START 0
-
-#define TARGET_GET_PCH_VALIDITY default_get_pch_validity
-#define TARGET_PCH_VALID_P default_pch_valid_p
-#define TARGET_CHECK_PCH_TARGET_FLAGS NULL
-
-#define TARGET_DEFAULT_SHORT_ENUMS hook_bool_void_false
-
-#define TARGET_BUILTIN_SETJMP_FRAME_VALUE default_builtin_setjmp_frame_value
-
-#define TARGET_MD_ASM_CLOBBERS hook_tree_tree_tree_tree_3rd_identity
-
-#define TARGET_DWARF_CALLING_CONVENTION hook_int_const_tree_0
-
-#define TARGET_DWARF_HANDLE_FRAME_UNSPEC 0
-
-#define TARGET_STDARG_OPTIMIZE_HOOK 0
-
-#define TARGET_STACK_PROTECT_GUARD  default_stack_protect_guard
-#define TARGET_STACK_PROTECT_FAIL   default_external_stack_protect_fail
-
-#define TARGET_ARM_EABI_UNWINDER false
-
-#define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode
-#define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_false
-
-#define TARGET_STRUCT_VALUE_RTX hook_rtx_tree_int_null
-#define TARGET_RETURN_IN_MEMORY default_return_in_memory
-#define TARGET_RETURN_IN_MSB hook_bool_const_tree_false
-
-#define TARGET_EXPAND_BUILTIN_SAVEREGS default_expand_builtin_saveregs
-#define TARGET_SETUP_INCOMING_VARARGS default_setup_incoming_varargs
-#define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_false
-#define TARGET_PRETEND_OUTGOING_VARARGS_NAMED \
-  default_pretend_outgoing_varargs_named
-#define TARGET_SPLIT_COMPLEX_ARG NULL
-
-#define TARGET_GIMPLIFY_VA_ARG_EXPR std_gimplify_va_arg_expr
-#define TARGET_PASS_BY_REFERENCE hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false
-
-#define TARGET_RELAXED_ORDERING false
-
-#define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size_or_pad
-#define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false
-#define TARGET_ARG_PARTIAL_BYTES hook_int_CUMULATIVE_ARGS_mode_tree_bool_0
-
-#define TARGET_FUNCTION_VALUE default_function_value
-#define TARGET_LIBCALL_VALUE default_libcall_value
-#define TARGET_FUNCTION_VALUE_REGNO_P default_function_value_regno_p
-#define TARGET_INTERNAL_ARG_POINTER default_internal_arg_pointer
-#define TARGET_UPDATE_STACK_BOUNDARY NULL
-#define TARGET_GET_DRAP_RTX NULL
-#define TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS hook_bool_void_true
-#define TARGET_STATIC_CHAIN default_static_chain
-#define TARGET_TRAMPOLINE_INIT default_trampoline_init
-#define TARGET_TRAMPOLINE_ADJUST_ADDRESS NULL
-
-#define TARGET_CALLS {						\
-   TARGET_PROMOTE_FUNCTION_MODE,				\
-   TARGET_PROMOTE_PROTOTYPES,					\
-   TARGET_STRUCT_VALUE_RTX,					\
-   TARGET_RETURN_IN_MEMORY,					\
-   TARGET_RETURN_IN_MSB,					\
-   TARGET_PASS_BY_REFERENCE,					\
-   TARGET_EXPAND_BUILTIN_SAVEREGS,				\
-   TARGET_SETUP_INCOMING_VARARGS,				\
-   TARGET_STRICT_ARGUMENT_NAMING,				\
-   TARGET_PRETEND_OUTGOING_VARARGS_NAMED,			\
-   TARGET_SPLIT_COMPLEX_ARG,					\
-   TARGET_MUST_PASS_IN_STACK,					\
-   TARGET_CALLEE_COPIES,					\
-   TARGET_ARG_PARTIAL_BYTES,					\
-   TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN,			\
-   TARGET_FUNCTION_VALUE,					\
-   TARGET_LIBCALL_VALUE,					\
-   TARGET_FUNCTION_VALUE_REGNO_P,				\
-   TARGET_INTERNAL_ARG_POINTER,					\
-   TARGET_UPDATE_STACK_BOUNDARY,				\
-   TARGET_GET_DRAP_RTX,						\
-   TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS,			\
-   TARGET_STATIC_CHAIN,						\
-   TARGET_TRAMPOLINE_INIT,					\
-   TARGET_TRAMPOLINE_ADJUST_ADDRESS				\
-   }
-
-#ifndef TARGET_UNWIND_TABLES_DEFAULT
-#define TARGET_UNWIND_TABLES_DEFAULT false
-#endif
-
-#ifndef TARGET_HANDLE_PRAGMA_EXTERN_PREFIX
-#define TARGET_HANDLE_PRAGMA_EXTERN_PREFIX 0
-#endif
-
-#ifdef IRA_COVER_CLASSES
-#define TARGET_IRA_COVER_CLASSES default_ira_cover_classes
-#else
+#ifndef IRA_COVER_CLASSES
 #define TARGET_IRA_COVER_CLASSES 0
 #endif
 
-#ifndef TARGET_SECONDARY_RELOAD
-#define TARGET_SECONDARY_RELOAD default_secondary_reload
-#endif
-
-#ifndef TARGET_EXPAND_TO_RTL_HOOK
-#define TARGET_EXPAND_TO_RTL_HOOK hook_void_void
-#endif
-
-#ifndef TARGET_INSTANTIATE_DECLS
-#define TARGET_INSTANTIATE_DECLS hook_void_void
-#endif
-
-#ifndef TARGET_HARD_REGNO_SCRATCH_OK
-#define TARGET_HARD_REGNO_SCRATCH_OK default_hard_regno_scratch_ok
-#endif
-
-#ifndef TARGET_CASE_VALUES_THRESHOLD
-#define TARGET_CASE_VALUES_THRESHOLD default_case_values_threshold
-#endif
-
-#ifndef TARGET_FRAME_POINTER_REQUIRED
-#define TARGET_FRAME_POINTER_REQUIRED hook_bool_void_false
-#endif
-
-#ifndef TARGET_CAN_ELIMINATE
-#define TARGET_CAN_ELIMINATE hook_bool_const_int_const_int_true
-#endif
-
-/* C specific.  */
-#ifndef TARGET_C_MODE_FOR_SUFFIX
-#define TARGET_C_MODE_FOR_SUFFIX default_mode_for_suffix
-#endif
-
-#define TARGET_C				\
-  {						\
-    TARGET_C_MODE_FOR_SUFFIX			\
-  }
-
-/* C++ specific.  */
-#ifndef TARGET_CXX_GUARD_TYPE
-#define TARGET_CXX_GUARD_TYPE default_cxx_guard_type
-#endif
-
-#ifndef TARGET_CXX_GUARD_MASK_BIT
-#define TARGET_CXX_GUARD_MASK_BIT hook_bool_void_false
-#endif
-
-#ifndef TARGET_CXX_GET_COOKIE_SIZE
-#define TARGET_CXX_GET_COOKIE_SIZE default_cxx_get_cookie_size
-#endif
-
-#ifndef TARGET_CXX_COOKIE_HAS_SIZE
-#define TARGET_CXX_COOKIE_HAS_SIZE hook_bool_void_false
-#endif
-
-#ifndef TARGET_CXX_IMPORT_EXPORT_CLASS
-#define TARGET_CXX_IMPORT_EXPORT_CLASS NULL
-#endif
-
-#ifndef TARGET_CXX_CDTOR_RETURNS_THIS
-#define TARGET_CXX_CDTOR_RETURNS_THIS hook_bool_void_false
-#endif
-
-#ifndef TARGET_CXX_KEY_METHOD_MAY_BE_INLINE
-#define TARGET_CXX_KEY_METHOD_MAY_BE_INLINE hook_bool_void_true
-#endif
-
-#ifndef TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
-#define TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY hook_void_tree
-#endif
-
-#ifndef TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT
-#define TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT hook_bool_void_true
-#endif
-
-#ifndef TARGET_CXX_LIBRARY_RTTI_COMDAT
-#define TARGET_CXX_LIBRARY_RTTI_COMDAT hook_bool_void_true
-#endif
-
-#ifndef TARGET_CXX_USE_AEABI_ATEXIT
-#define TARGET_CXX_USE_AEABI_ATEXIT hook_bool_void_false
-#endif
-
-#ifndef TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT
-#define TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT hook_bool_void_false
-#endif
-
-#ifndef TARGET_CXX_ADJUST_CLASS_AT_DEFINITION
-#define TARGET_CXX_ADJUST_CLASS_AT_DEFINITION hook_void_tree
-#endif
-
-#define TARGET_CXX				\
-  {						\
-    TARGET_CXX_GUARD_TYPE,			\
-    TARGET_CXX_GUARD_MASK_BIT,			\
-    TARGET_CXX_GET_COOKIE_SIZE,			\
-    TARGET_CXX_COOKIE_HAS_SIZE,			\
-    TARGET_CXX_IMPORT_EXPORT_CLASS,		\
-    TARGET_CXX_CDTOR_RETURNS_THIS,		\
-    TARGET_CXX_KEY_METHOD_MAY_BE_INLINE,	\
-    TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY,	\
-    TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT,        \
-    TARGET_CXX_LIBRARY_RTTI_COMDAT,	        \
-    TARGET_CXX_USE_AEABI_ATEXIT,		\
-    TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT,	\
-    TARGET_CXX_ADJUST_CLASS_AT_DEFINITION	\
-  }
-
-/* EMUTLS specific */
-#ifndef TARGET_EMUTLS_GET_ADDRESS
-#define TARGET_EMUTLS_GET_ADDRESS "__builtin___emutls_get_address"
-#endif
-
-#ifndef TARGET_EMUTLS_REGISTER_COMMON
-#define TARGET_EMUTLS_REGISTER_COMMON "__builtin___emutls_register_common"
-#endif
-
-#ifndef TARGET_EMUTLS_VAR_SECTION
-#define TARGET_EMUTLS_VAR_SECTION NULL
-#endif
-
-#ifndef TARGET_EMUTLS_TMPL_SECTION
-#define TARGET_EMUTLS_TMPL_SECTION NULL
-#endif
-
-#ifndef TARGET_EMUTLS_VAR_PREFIX
-#define TARGET_EMUTLS_VAR_PREFIX NULL
-#endif
-
-#ifndef TARGET_EMUTLS_TMPL_PREFIX
-#define TARGET_EMUTLS_TMPL_PREFIX NULL
-#endif
-
-#ifndef TARGET_EMUTLS_VAR_FIELDS
-#define TARGET_EMUTLS_VAR_FIELDS default_emutls_var_fields
-#endif
-
-#ifndef TARGET_EMUTLS_VAR_INIT
-#define TARGET_EMUTLS_VAR_INIT default_emutls_var_init
-#endif
-
-#ifndef TARGET_EMUTLS_VAR_ALIGN_FIXED
-#define TARGET_EMUTLS_VAR_ALIGN_FIXED false
-#endif
-
-#ifndef TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
-#define TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS false
-#endif
-
-#define TARGET_EMUTLS				\
-  {						\
-    TARGET_EMUTLS_GET_ADDRESS,  		\
-    TARGET_EMUTLS_REGISTER_COMMON,  		\
-    TARGET_EMUTLS_VAR_SECTION,  		\
-    TARGET_EMUTLS_TMPL_SECTION,  		\
-    TARGET_EMUTLS_VAR_PREFIX,  			\
-    TARGET_EMUTLS_TMPL_PREFIX,  		\
-    TARGET_EMUTLS_VAR_FIELDS,			\
-    TARGET_EMUTLS_VAR_INIT,			\
-    TARGET_EMUTLS_VAR_ALIGN_FIXED,		\
-    TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS	\
-  }
-
-/* Function specific option attribute support.  */
-#ifndef TARGET_OPTION_VALID_ATTRIBUTE_P
-#define TARGET_OPTION_VALID_ATTRIBUTE_P \
-  default_target_option_valid_attribute_p
-#endif
-
-#ifndef TARGET_OPTION_SAVE
-#define TARGET_OPTION_SAVE NULL
-#endif
-
-#ifndef TARGET_OPTION_RESTORE
-#define TARGET_OPTION_RESTORE NULL
-#endif
-
-#ifndef TARGET_OPTION_PRINT
-#define TARGET_OPTION_PRINT NULL
-#endif
-
-#ifndef TARGET_OPTION_PRAGMA_PARSE
-#define TARGET_OPTION_PRAGMA_PARSE default_target_option_pragma_parse
-#endif
-
-#ifndef TARGET_CAN_INLINE_P
-#define TARGET_CAN_INLINE_P default_target_can_inline_p
-#endif
-
-#define TARGET_OPTION_HOOKS			\
-  {						\
-    TARGET_OPTION_VALID_ATTRIBUTE_P,		\
-    TARGET_OPTION_SAVE,				\
-    TARGET_OPTION_RESTORE,			\
-    TARGET_OPTION_PRINT,			\
-    TARGET_OPTION_PRAGMA_PARSE,			\
-    TARGET_CAN_INLINE_P,			\
-  }
-
-/* The whole shebang.  */
-#define TARGET_INITIALIZER			\
-{						\
-  TARGET_ASM_OUT,				\
-  TARGET_SCHED,					\
-  TARGET_VECTORIZE,				\
-  TARGET_DEFAULT_TARGET_FLAGS,			\
-  TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE,		\
-  TARGET_HANDLE_OPTION,				\
-  TARGET_HANDLE_OFAST,				\
-  TARGET_HELP,					\
-  TARGET_EH_RETURN_FILTER_MODE,			\
-  TARGET_LIBGCC_CMP_RETURN_MODE,                \
-  TARGET_LIBGCC_SHIFT_COUNT_MODE,               \
-  TARGET_UNWIND_WORD_MODE,			\
-  TARGET_MERGE_DECL_ATTRIBUTES,			\
-  TARGET_MERGE_TYPE_ATTRIBUTES,			\
-  TARGET_ATTRIBUTE_TABLE,			\
-  TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P,		\
-  TARGET_COMP_TYPE_ATTRIBUTES,			\
-  TARGET_SET_DEFAULT_TYPE_ATTRIBUTES,		\
-  TARGET_INSERT_ATTRIBUTES,			\
-  TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P,	\
-  TARGET_MS_BITFIELD_LAYOUT_P,			\
-  TARGET_DECIMAL_FLOAT_SUPPORTED_P,		\
-  TARGET_FIXED_POINT_SUPPORTED_P,		\
-  TARGET_ALIGN_ANON_BITFIELD,			\
-  TARGET_NARROW_VOLATILE_BITFIELD,		\
-  TARGET_INIT_BUILTINS,				\
-  TARGET_BUILTIN_DECL,				\
-  TARGET_EXPAND_BUILTIN,			\
-  TARGET_RESOLVE_OVERLOADED_BUILTIN,		\
-  TARGET_FOLD_BUILTIN,				\
-  TARGET_BUILTIN_RECIPROCAL,			\
-  TARGET_MANGLE_TYPE,				\
-  TARGET_INIT_LIBFUNCS,				\
-  TARGET_SECTION_TYPE_FLAGS,			\
-  TARGET_CANNOT_MODIFY_JUMPS_P,			\
-  TARGET_BRANCH_TARGET_REGISTER_CLASS,		\
-  TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED,	\
-  TARGET_HAVE_CONDITIONAL_EXECUTION,		\
-  TARGET_LOOP_UNROLL_ADJUST,			\
-  TARGET_CANNOT_FORCE_CONST_MEM,		\
-  TARGET_CANNOT_COPY_INSN_P,			\
-  TARGET_COMMUTATIVE_P,				\
-  TARGET_MODE_DEPENDENT_ADDRESS_P,		\
-  TARGET_LEGITIMIZE_ADDRESS,			\
-  TARGET_DELEGITIMIZE_ADDRESS,			\
-  TARGET_LEGITIMATE_ADDRESS_P,			\
-  TARGET_USE_BLOCKS_FOR_CONSTANT_P,		\
-  TARGET_MIN_ANCHOR_OFFSET,			\
-  TARGET_MAX_ANCHOR_OFFSET,			\
-  TARGET_USE_ANCHORS_FOR_SYMBOL_P,		\
-  TARGET_FUNCTION_OK_FOR_SIBCALL,		\
-  TARGET_SET_CURRENT_FUNCTION,			\
-  TARGET_IN_SMALL_DATA_P,			\
-  TARGET_BINDS_LOCAL_P,				\
-  TARGET_MANGLE_DECL_ASSEMBLER_NAME,		\
-  TARGET_ENCODE_SECTION_INFO,			\
-  TARGET_STRIP_NAME_ENCODING,			\
-  TARGET_SHIFT_TRUNCATION_MASK,			\
-  TARGET_MIN_DIVISIONS_FOR_RECIP_MUL,		\
-  TARGET_MODE_REP_EXTENDED,			\
-  TARGET_VALID_POINTER_MODE,                    \
-  TARGET_ADDR_SPACE_HOOKS,			\
-  TARGET_SCALAR_MODE_SUPPORTED_P,		\
-  TARGET_VECTOR_MODE_SUPPORTED_P,               \
-  TARGET_REGISTER_MOVE_COST,			\
-  TARGET_MEMORY_MOVE_COST, 			\
-  TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P,	\
-  TARGET_RTX_COSTS,				\
-  TARGET_ADDRESS_COST,				\
-  TARGET_ALLOCATE_INITIAL_VALUE,		\
-  TARGET_UNSPEC_MAY_TRAP_P,                     \
-  TARGET_DWARF_REGISTER_SPAN,                   \
-  TARGET_INIT_DWARF_REG_SIZES_EXTRA,		\
-  TARGET_FIXED_CONDITION_CODE_REGS,		\
-  TARGET_CC_MODES_COMPATIBLE,			\
-  TARGET_MACHINE_DEPENDENT_REORG,		\
-  TARGET_BUILD_BUILTIN_VA_LIST,			\
-  TARGET_ENUM_VA_LIST_P,			\
-  TARGET_FN_ABI_VA_LIST,			\
-  TARGET_CANONICAL_VA_LIST_TYPE,		\
-  TARGET_EXPAND_BUILTIN_VA_START,		\
-  TARGET_GIMPLIFY_VA_ARG_EXPR,			\
-  TARGET_GET_PCH_VALIDITY,			\
-  TARGET_PCH_VALID_P,				\
-  TARGET_CHECK_PCH_TARGET_FLAGS,		\
-  TARGET_DEFAULT_SHORT_ENUMS,			\
-  TARGET_BUILTIN_SETJMP_FRAME_VALUE,		\
-  TARGET_MD_ASM_CLOBBERS,			\
-  TARGET_DWARF_CALLING_CONVENTION,              \
-  TARGET_DWARF_HANDLE_FRAME_UNSPEC,		\
-  TARGET_STDARG_OPTIMIZE_HOOK,			\
-  TARGET_STACK_PROTECT_GUARD,			\
-  TARGET_STACK_PROTECT_FAIL,			\
-  TARGET_INVALID_WITHIN_DOLOOP,			\
-  TARGET_VALID_DLLIMPORT_ATTRIBUTE_P,		\
-  TARGET_CONST_ANCHOR,				\
-  TARGET_CALLS,					\
-  TARGET_INVALID_CONVERSION,			\
-  TARGET_INVALID_UNARY_OP,			\
-  TARGET_INVALID_BINARY_OP,			\
-  TARGET_INVALID_PARAMETER_TYPE,		\
-  TARGET_INVALID_RETURN_TYPE,			\
-  TARGET_PROMOTED_TYPE,				\
-  TARGET_CONVERT_TO_TYPE,			\
-  TARGET_IRA_COVER_CLASSES,			\
-  TARGET_SECONDARY_RELOAD,			\
-  TARGET_EXPAND_TO_RTL_HOOK,			\
-  TARGET_INSTANTIATE_DECLS,			\
-  TARGET_HARD_REGNO_SCRATCH_OK,			\
-  TARGET_CASE_VALUES_THRESHOLD,			\
-  TARGET_FRAME_POINTER_REQUIRED,		\
-  TARGET_CAN_ELIMINATE,				\
-  TARGET_C,					\
-  TARGET_CXX,					\
-  TARGET_EMUTLS,				\
-  TARGET_OPTION_HOOKS,				\
-  TARGET_EXTRA_LIVE_ON_ENTRY,			\
-  TARGET_UNWIND_TABLES_DEFAULT,			\
-  TARGET_HAVE_NAMED_SECTIONS,			\
-  TARGET_HAVE_SWITCHABLE_BSS_SECTIONS,		\
-  TARGET_HAVE_CTORS_DTORS,			\
-  TARGET_HAVE_TLS,				\
-  TARGET_HAVE_SRODATA_SECTION,			\
-  TARGET_TERMINATE_DW2_EH_FRAME_INFO,		\
-  TARGET_ASM_FILE_START_APP_OFF,		\
-  TARGET_ASM_FILE_START_FILE_DIRECTIVE,		\
-  TARGET_HANDLE_PRAGMA_EXTERN_PREFIX,		\
-  TARGET_RELAXED_ORDERING,			\
-  TARGET_ARM_EABI_UNWINDER			\
-}
-
-#define TARGET_HANDLE_C_OPTION default_handle_c_option
-#define TARGETCM_INITIALIZER { TARGET_HANDLE_C_OPTION }
+#include "target-hooks-def.h"
 
 #include "hooks.h"
 #include "targhooks.h"
Index: gcc/Makefile.in
===================================================================
--- gcc/Makefile.in	(revision 161494)
+++ gcc/Makefile.in	(working copy)
@@ -861,12 +861,12 @@  endif
 VEC_H = vec.h statistics.h
 EXCEPT_H = except.h $(HASHTAB_H) vecprim.h vecir.h
 TOPLEV_H = toplev.h $(INPUT_H) bversion.h $(DIAGNOSTIC_CORE_H)
-TARGET_H = $(TM_H) target.h insn-modes.h
+TARGET_H = $(TM_H) target.h target.def insn-modes.h
 MACHMODE_H = machmode.h mode-classes.def insn-modes.h
 HOOKS_H = hooks.h $(MACHMODE_H)
 HOSTHOOKS_DEF_H = hosthooks-def.h $(HOOKS_H)
 LANGHOOKS_DEF_H = langhooks-def.h $(HOOKS_H)
-TARGET_DEF_H = target-def.h $(HOOKS_H) targhooks.h
+TARGET_DEF_H = target-def.h target-hooks-def.h $(HOOKS_H) targhooks.h
 RTL_BASE_H = rtl.h rtl.def $(MACHMODE_H) reg-notes.def insn-notes.def \
   $(INPUT_H) $(REAL_H) statistics.h $(VEC_H) $(FIXED_VALUE_H) alias.h
 FIXED_VALUE_H = fixed-value.h $(MACHMODE_H) double-int.h
@@ -3674,6 +3674,27 @@  s-constrs-h: $(MD_DEPS) build/genpreds$(
 	$(SHELL) $(srcdir)/../move-if-change tmp-constrs.h tm-constrs.h
 	$(STAMP) s-constrs-h
 
+target-hooks-def.h: s-target-hooks-def-h; @true
+tm.texi: s-tm-texi; @true
+
+s-target-hooks-def-h: build/genhooks$(build_exeext)
+	$(RUN_GEN) build/genhooks$(build_exeext) > tmp-target-hooks-def.h
+	$(SHELL) $(srcdir)/../move-if-change tmp-target-hooks-def.h \
+					     target-hooks-def.h
+	$(STAMP) s-target-hooks-def-h
+s-tm-texi: build/genhooks$(build_exeext) $(srcdir)/doc/tm.texi.in
+	$(RUN_GEN) build/genhooks$(build_exeext) \
+			$(srcdir)/doc/tm.texi.in > tmp-tm.texi
+	$(SHELL) $(srcdir)/../move-if-change tmp-tm.texi tm.texi
+	@if cmp -s $(srcdir)/doc/tm.texi tm.texi; then \
+	  $(STAMP) $@; \
+	else \
+	  echo >&2 ; \
+	  echo Verify that you have permission to grant a GFDL license for all >&2 ; \
+	  echo new text in tm.texi, then copy it to $(srcdir)/doc/tm.texi. >&2 ; \
+	  false; \
+	fi
+
 GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \
   $(srcdir)/vecprim.h $(srcdir)/vecir.h \
   $(host_xm_file_list) \
@@ -3852,6 +3873,7 @@  build/genpreds.o : genpreds.c $(RTL_BASE
   coretypes.h $(GTM_H) errors.h $(READ_MD_H) gensupport.h $(OBSTACK_H)
 build/genrecog.o : genrecog.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H)	\
   coretypes.h $(GTM_H) errors.h $(READ_MD_H) gensupport.h
+build/genhooks.o : genhooks.c target.def $(BCONFIG_H) $(SYSTEM_H) errors.h
 
 # Compile the programs that generate insn-* from the machine description.
 # They are compiled with $(COMPILER_FOR_BUILD), and associated libraries,
@@ -3881,6 +3903,7 @@  build/genautomata$(build_exeext) : BUILD
 
 # These programs are not linked with the MD reader.
 build/gengtype$(build_exeext) : build/gengtype-lex.o build/gengtype-parse.o
+build/genhooks$(build_exeext) : $(BUILD_ERRORS)
 
 # Generated source files for gengtype.
 gengtype-lex.c : gengtype-lex.l
Index: gcc/config/alpha/alpha.c
===================================================================
--- gcc/config/alpha/alpha.c	(revision 161494)
+++ gcc/config/alpha/alpha.c	(working copy)
@@ -9742,7 +9742,7 @@  alpha_file_start (void)
   /* If emitting dwarf2 debug information, we cannot generate a .file
      directive to start the file, as it will conflict with dwarf2out
      file numbers.  So it's only useful when emitting mdebug output.  */
-  targetm.file_start_file_directive = (write_symbols == DBX_DEBUG);
+  targetm.asm_file_start_file_directive = (write_symbols == DBX_DEBUG);
 #endif
 
   default_file_start ();
Index: gcc/config/spu/spu.c
===================================================================
--- gcc/config/spu/spu.c	(revision 161494)
+++ gcc/config/spu/spu.c	(working copy)
@@ -432,8 +432,8 @@  static const struct attribute_spec spu_a
 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST spu_builtin_vectorization_cost
 
-#undef TARGET_VECTOR_ALIGNMENT_REACHABLE
-#define TARGET_VECTOR_ALIGNMENT_REACHABLE spu_vector_alignment_reachable
+#undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
+#define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE spu_vector_alignment_reachable
 
 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM spu_builtin_vec_perm
Index: gcc/config/cris/cris.c
===================================================================
--- gcc/config/cris/cris.c	(revision 161494)
+++ gcc/config/cris/cris.c	(working copy)
@@ -2571,8 +2571,8 @@  cris_file_start (void)
 {
   /* These expressions can vary at run time, so we cannot put
      them into TARGET_INITIALIZER.  */
-  targetm.file_start_app_off = !(TARGET_PDEBUG || flag_print_asm_name);
-  targetm.file_start_file_directive = TARGET_ELF;
+  targetm.asm_file_start_app_off = !(TARGET_PDEBUG || flag_print_asm_name);
+  targetm.asm_file_start_file_directive = TARGET_ELF;
 
   default_file_start ();
 }
Index: gcc/config/ia64/ia64.c
===================================================================
--- gcc/config/ia64/ia64.c	(revision 161494)
+++ gcc/config/ia64/ia64.c	(working copy)
@@ -510,8 +510,8 @@  static const struct attribute_spec ia64_
 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 #define TARGET_GIMPLIFY_VA_ARG_EXPR ia64_gimplify_va_arg
 
-#undef TARGET_UNWIND_EMIT
-#define TARGET_UNWIND_EMIT process_for_unwind_directive
+#undef TARGET_ASM_UNWIND_EMIT
+#define TARGET_ASM_UNWIND_EMIT process_for_unwind_directive
 
 #undef TARGET_SCALAR_MODE_SUPPORTED_P
 #define TARGET_SCALAR_MODE_SUPPORTED_P ia64_scalar_mode_supported_p
Index: gcc/config/rs6000/rs6000.c
===================================================================
--- gcc/config/rs6000/rs6000.c	(revision 161494)
+++ gcc/config/rs6000/rs6000.c	(working copy)
@@ -1462,11 +1462,11 @@  static const struct attribute_spec rs600
 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
 #undef TARGET_VECTORIZE_BUILTIN_VEC_PERM
 #define TARGET_VECTORIZE_BUILTIN_VEC_PERM rs6000_builtin_vec_perm
-#undef TARGET_SUPPORT_VECTOR_MISALIGNMENT
-#define TARGET_SUPPORT_VECTOR_MISALIGNMENT		\
+#undef TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
+#define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT		\
   rs6000_builtin_support_vector_misalignment
-#undef TARGET_VECTOR_ALIGNMENT_REACHABLE
-#define TARGET_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
+#undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
+#define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
 
 #undef TARGET_INIT_BUILTINS
 #define TARGET_INIT_BUILTINS rs6000_init_builtins
Index: gcc/config/arm/arm.c
===================================================================
--- gcc/config/arm/arm.c	(revision 161494)
+++ gcc/config/arm/arm.c	(working copy)
@@ -434,8 +434,8 @@  static const struct attribute_spec arm_a
 #define TARGET_MUST_PASS_IN_STACK arm_must_pass_in_stack
 
 #ifdef TARGET_UNWIND_INFO
-#undef TARGET_UNWIND_EMIT
-#define TARGET_UNWIND_EMIT arm_unwind_emit
+#undef TARGET_ASM_UNWIND_EMIT
+#define TARGET_ASM_UNWIND_EMIT arm_unwind_emit
 
 /* EABI unwinding tables use a different format for the typeinfo tables.  */
 #undef TARGET_ASM_TTYPE