From patchwork Wed Jun 9 03:03:24 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joern Rennecke X-Patchwork-Id: 55046 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id CFE58B7D48 for ; Wed, 9 Jun 2010 13:04:42 +1000 (EST) Received: (qmail 32669 invoked by alias); 9 Jun 2010 03:04:38 -0000 Received: (qmail 27163 invoked by uid 22791); 9 Jun 2010 03:04:07 -0000 X-SWARE-Spam-Status: No, hits=2.1 required=5.0 tests=AWL, BAYES_50, KAM_STOCKTIP, MIME_QP_LONG_LINE, RCVD_IN_DNSWL_LOW, TW_CX, TW_DD, TW_TJ X-Spam-Check-By: sourceware.org Received: from c60.cesmail.net (HELO c60.cesmail.net) (216.154.195.49) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Wed, 09 Jun 2010 03:03:29 +0000 Received: from unknown (HELO epsilon2) ([192.168.1.60]) by c60.cesmail.net with ESMTP; 08 Jun 2010 23:03:26 -0400 Received: from 78.146.185.72 ([78.146.185.72]) by webmail.spamcop.net (Horde MIME library) with HTTP; Tue, 08 Jun 2010 23:03:24 -0400 Message-ID: <20100608230324.rh3qk1dp9usgswsg-nzlynne@webmail.spamcop.net> Date: Tue, 08 Jun 2010 23:03:24 -0400 From: Joern Rennecke To: gcc-patches@gcc.gnu.org Cc: "Joseph S. Myers" , Gerald Pfeifer , Richard Guenther , bonzini@gnu.org, dj@redhat.com, neroden@gcc.gnu.org, aoliva@redhat.com Subject: Update^5: Fix PR other/44034 References: <20100526035246.h4v4fkajq8kcs0wk-nzlynne@webmail.spamcop.net> <20100526074705.ybxjn3la80cwkgg4-nzlynne@webmail.spamcop.net> <20100526114501.naowcook48wo0kwg-nzlynne@webmail.spamcop.net> <20100528121743.sj8wuutpdwo8ggkc-nzlynne@webmail.spamcop.net> <20100607181903.vsr8r9994w8sk4o0-nzlynne@webmail.spamcop.net> In-Reply-To: <20100607181903.vsr8r9994w8sk4o0-nzlynne@webmail.spamcop.net> MIME-Version: 1.0 User-Agent: Internet Messaging Program (IMP) H3 (4.1.4) Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Because a change tm.texi, I have rebaselined the patch to revision 160454. Bootstrapped and regression tested in revision 160454. 2010-06-09 Joern Rennecke 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 Index: gcc/doc/tm.texi =================================================================== --- gcc/doc/tm.texi (revision 160454) +++ gcc/doc/tm.texi (working copy) @@ -4460,8 +4460,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. @@ -5779,7 +5778,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 @@ -8706,7 +8705,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 @@ -8770,7 +8769,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 @@ -9635,9 +9634,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 @@ -9895,7 +9892,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 @@ -9921,12 +9918,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) @@ -9958,9 +9950,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 160454) +++ gcc/doc/tm.texi.in (working copy) @@ -750,7 +750,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 @@ -758,7 +758,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 @@ -775,7 +775,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 @@ -820,7 +820,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 @@ -858,7 +858,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 @@ -1054,7 +1054,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 @@ -1340,14 +1340,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. @@ -1409,21 +1409,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 @@ -1449,7 +1449,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 @@ -1477,15 +1477,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 @@ -1494,12 +1494,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++ @@ -1716,7 +1716,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 @@ -2275,7 +2275,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. @@ -2677,7 +2677,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 @@ -2917,7 +2917,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 @@ -3234,7 +3234,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 @@ -3301,7 +3301,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 @@ -3686,7 +3686,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 @@ -3770,7 +3770,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. @@ -3836,7 +3836,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} @@ -3863,7 +3863,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 @@ -4078,7 +4078,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 @@ -4100,7 +4100,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 @@ -4131,7 +4131,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 @@ -4280,7 +4280,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 @@ -4293,7 +4293,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 @@ -4312,32 +4312,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 @@ -4349,13 +4349,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 @@ -4396,7 +4396,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 @@ -4460,8 +4460,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. @@ -4493,7 +4492,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. @@ -4514,7 +4513,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} @@ -4544,7 +4543,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} @@ -4574,7 +4573,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 @@ -4643,7 +4642,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 @@ -4688,21 +4687,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 @@ -4841,7 +4840,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, @@ -4883,7 +4882,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 @@ -4936,7 +4935,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. @@ -4949,7 +4948,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 @@ -4962,7 +4961,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 @@ -4973,7 +4972,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. @@ -5076,7 +5075,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 @@ -5084,7 +5083,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 @@ -5118,7 +5117,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. @@ -5133,7 +5132,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 @@ -5170,7 +5169,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 @@ -5198,7 +5197,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 @@ -5217,7 +5216,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 @@ -5298,7 +5297,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}. @@ -5455,7 +5454,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}. @@ -5539,7 +5538,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. @@ -5609,7 +5608,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 @@ -5651,7 +5650,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 @@ -5661,7 +5660,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. @@ -5673,7 +5672,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}. @@ -5691,7 +5690,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 @@ -5720,7 +5719,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}. @@ -5731,7 +5730,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}. @@ -5742,23 +5741,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 @@ -5770,7 +5769,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. @@ -5779,7 +5778,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 @@ -5822,20 +5821,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 @@ -5847,7 +5846,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})}. @@ -6076,7 +6075,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 @@ -6091,7 +6090,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 @@ -6389,7 +6388,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 @@ -6416,7 +6415,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. @@ -6459,7 +6458,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 @@ -6471,7 +6470,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 @@ -6485,7 +6484,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 @@ -6500,7 +6499,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} @@ -6508,7 +6507,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). @@ -6525,7 +6524,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 @@ -6536,7 +6535,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 @@ -6546,7 +6545,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} @@ -6556,7 +6555,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} @@ -6565,20 +6564,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 @@ -6588,36 +6587,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 @@ -6646,7 +6645,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 @@ -6670,7 +6669,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 @@ -6691,35 +6690,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 @@ -6730,13 +6729,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. @@ -6747,7 +6746,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 @@ -6760,14 +6759,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 @@ -6951,7 +6950,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. @@ -6961,7 +6960,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 @@ -6973,7 +6972,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} @@ -6996,7 +6995,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 @@ -7008,7 +7007,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 @@ -7017,7 +7016,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 @@ -7029,7 +7028,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, @@ -7039,7 +7038,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). @@ -7077,23 +7076,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). @@ -7103,7 +7102,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 @@ -7185,7 +7184,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 @@ -7194,7 +7193,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 @@ -7208,14 +7207,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 @@ -7229,19 +7228,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, @@ -7293,7 +7292,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} @@ -7301,18 +7300,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 @@ -7324,7 +7323,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. @@ -7370,7 +7369,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. @@ -7381,7 +7380,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 @@ -7401,7 +7400,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 @@ -7513,8 +7512,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. @@ -7831,7 +7829,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. @@ -7840,7 +7838,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. @@ -7909,7 +7907,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}. @@ -7945,13 +7943,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. @@ -7983,7 +7981,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}. @@ -8322,13 +8320,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. @@ -8343,7 +8341,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 @@ -8468,7 +8466,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. @@ -8686,7 +8684,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 @@ -8698,7 +8696,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. @@ -8706,7 +8704,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 @@ -8770,10 +8768,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 @@ -8800,14 +8798,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 @@ -8816,7 +8814,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. @@ -8825,14 +8823,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 @@ -9265,7 +9263,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. @@ -9314,7 +9312,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 @@ -9574,7 +9572,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 @@ -9582,7 +9580,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 @@ -9590,7 +9588,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 @@ -9598,12 +9596,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 @@ -9612,7 +9610,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}. @@ -9634,11 +9632,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 @@ -9649,7 +9643,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 @@ -9662,7 +9656,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 @@ -9670,7 +9664,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 @@ -9682,20 +9676,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. @@ -9708,7 +9702,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 @@ -9731,13 +9725,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 @@ -9745,29 +9739,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 @@ -9775,20 +9769,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 @@ -9837,13 +9831,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 @@ -9858,7 +9852,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 @@ -9870,19 +9864,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 @@ -9890,12 +9884,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 @@ -9904,13 +9898,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 @@ -9920,16 +9914,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 @@ -9937,19 +9924,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 @@ -9957,11 +9944,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 @@ -10001,21 +9984,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, @@ -10025,7 +10008,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 @@ -10034,14 +10017,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 @@ -10050,7 +10033,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 @@ -10107,7 +10090,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 @@ -10168,7 +10151,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 @@ -10216,7 +10199,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}. @@ -10256,7 +10239,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 @@ -10579,9 +10562,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 @@ -10647,7 +10628,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 @@ -10740,7 +10721,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. @@ -10754,7 +10735,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. @@ -10772,7 +10753,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}. @@ -10782,7 +10763,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 @@ -10817,7 +10798,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 @@ -10841,14 +10822,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 @@ -10870,7 +10851,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 @@ -10879,7 +10860,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 @@ -10935,7 +10916,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 @@ -10950,7 +10931,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 @@ -10958,7 +10939,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 @@ -10972,13 +10953,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 @@ -11056,7 +11037,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 @@ -11066,47 +11047,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 @@ -11115,7 +11096,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. @@ -11142,19 +11123,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 @@ -11165,7 +11146,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 160454) +++ gcc/c-family/c-common.c (working copy) @@ -4921,13 +4921,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,2275 @@ +/* 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 + . + + 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. */ + +/* 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) + +/* 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 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 160454) +++ gcc/target.h (working copy) @@ -128,1176 +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); - - /* 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 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 160454) +++ gcc/df-scan.c (working copy) @@ -3950,7 +3950,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 160454) +++ gcc/haifa-sched.c (working copy) @@ -1793,7 +1793,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 @@ -2803,8 +2803,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; @@ -3278,9 +3278,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 @@ -3439,9 +3439,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) { @@ -3566,8 +3565,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 160454) +++ 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 160454) +++ gcc/dwarf2out.c (working copy) @@ -3452,8 +3452,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); @@ -3669,7 +3669,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 160454) +++ gcc/opts.c (working copy) @@ -1552,8 +1552,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 160454) +++ 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,338 @@ +/* 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 +. */ +#include "bconfig.h" +#include "system.h" +#include +#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"); + 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 160454) +++ gcc/except.c (working copy) @@ -2960,7 +2960,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/varasm.c =================================================================== --- gcc/varasm.c (revision 160454) +++ gcc/varasm.c (working copy) @@ -5984,7 +5984,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 @@ -6899,11 +6899,11 @@ default_internal_label (FILE *stream, co 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 160454) +++ 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,65 +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_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 @@ -141,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, \ @@ -285,811 +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_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_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_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 160454) +++ 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 @@ -3664,6 +3664,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 ; \ + echo Verify that you have permission to grant a GFDL license for all; \ + echo new text in tm.texi, then copy it to $(srcdir)/doc/tm.texi.; \ + false; \ + fi + GTFILES = $(CPP_ID_DATA_H) $(srcdir)/input.h $(srcdir)/coretypes.h \ $(srcdir)/vecprim.h $(srcdir)/vecir.h \ $(host_xm_file_list) \ @@ -3835,6 +3856,7 @@ build/genpreds.o : genpreds.c $(RTL_BASE coretypes.h $(GTM_H) errors.h gensupport.h $(OBSTACK_H) build/genrecog.o : genrecog.c $(RTL_BASE_H) $(BCONFIG_H) $(SYSTEM_H) \ coretypes.h $(GTM_H) errors.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, @@ -3859,6 +3881,7 @@ build/gengenrtl$(build_exeext) : $(BUILD build/genmodes$(build_exeext) : $(BUILD_ERRORS) build/gengtype$(build_exeext) : build/gengtype-lex.o build/gengtype-parse.o \ $(BUILD_ERRORS) +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 160454) +++ 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 160454) +++ 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 160454) +++ gcc/config/cris/cris.c (working copy) @@ -2552,8 +2552,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 160454) +++ gcc/config/ia64/ia64.c (working copy) @@ -496,8 +496,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 160454) +++ gcc/config/rs6000/rs6000.c (working copy) @@ -1439,11 +1439,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 160454) +++ gcc/config/arm/arm.c (working copy) @@ -424,8 +424,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