Lines Matching +refs:gdb +refs:fun +refs:name +refs:hook

15 includes a C header file conventionally given the name
144 The first item in the pair is the name of the default.  This must match
146 to apply if a default with this name was specified.  The string
215 @option{-o} option specifying the name of the output file.
323 containing a string constant, that defines the specification name, and a
396 @hook TARGET_ALWAYS_STRIP_DOTDOT
413 indicates an absolute file name.
495 Each array element should have four elements: the directory name (a
496 string constant), the component name (also a string constant), a flag
502 The component name denotes what GNU package the include file is part of,
505 operating system, code the component name as @samp{0}.
562 (or port-specific name; native only, cross compilers do not use this).
622 @code{builtin_define_std} takes a string representing the name of an
661 @hook TARGET_DEFAULT_TARGET_FLAGS
669 @hook TARGET_HANDLE_OPTION
670 This hook is called whenever the user specifies one of the
683 @hook TARGET_HANDLE_C_OPTION
684 This target hook is called whenever the user specifies one of the
697 @hook TARGET_OBJC_CONSTRUCT_STRING_OBJECT
699 @hook TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE
701 @hook TARGET_OBJC_DECLARE_CLASS_DEFINITION
703 @hook TARGET_STRING_OBJECT_REF_TYPE_P
705 @hook TARGET_CHECK_STRING_OBJECT_FORMAT_ARG
707 @hook TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
708 This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
718 This is similar to the @code{TARGET_OPTION_OVERRIDE} hook
725 @hook TARGET_OPTION_OPTIMIZATION_TABLE
739 @hook TARGET_OPTION_INIT_STRUCT
741 @hook TARGET_OPTION_DEFAULT_PARAMS
938 @hook TARGET_PROMOTE_FUNCTION_MODE
940 function return values.  The target hook should return the new mode
950 then the hook should return the same mode as @code{promote_mode}, though
956 also define the hook to @code{default_promote_function_mode_always_promote}
1100 @hook TARGET_VECTOR_ALIGNMENT
1234 @hook TARGET_ALIGN_ANON_BITFIELD
1235 When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine
1237 structure.  The hook should return true if the structure should inherit
1241 @hook TARGET_NARROW_VOLATILE_BITFIELD
1242 This target hook should return @code{true} if accesses to volatile bitfields
1303 @hook TARGET_LIBGCC_CMP_RETURN_MODE
1304 This target hook should return the mode to be used for the return value
1310 @hook TARGET_LIBGCC_SHIFT_COUNT_MODE
1311 This target hook should return the mode to be used for the shift count operand
1317 @hook TARGET_UNWIND_WORD_MODE
1343 @hook TARGET_MS_BITFIELD_LAYOUT_P
1344 This target hook returns @code{true} if bit-fields in the given
1353 another bit-field of nonzero size.  If this hook returns @code{true},
1371 @hook TARGET_DECIMAL_FLOAT_SUPPORTED_P
1375 @hook TARGET_FIXED_POINT_SUPPORTED_P
1379 @hook TARGET_EXPAND_TO_RTL_HOOK
1380 This hook is called just before expansion into rtl, allowing the target
1388 @hook TARGET_INSTANTIATE_DECLS
1389 This hook allows the backend to perform additional instantiations on rtl
1393 @hook TARGET_MANGLE_TYPE
1395 uses should be mangled differently from the default, define this hook
1397 mangled name.  The @var{type} argument is the tree structure representing
1398 the type to be mangled.  The hook may be applied to trees which are
1406 fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}
1407 is the name used for the type in source code, and @var{n} is the
1408 length of @var{name} in decimal.  Encode qualified versions of
1409 ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where
1410 @var{name} is the name used for the type qualifier in source code,
1411 @var{n} is the length of @var{name} as above, and @var{code} is the
1417 This hook is applied to types prior to typedef resolution.  If the mangled
1418 name for a particular type depends only on that type's main variant, you
1422 The default version of this hook always returns @code{NULL}, which is
1576 hook and should be defined if that hook is overriden to be true.  It
1578 prefix for their name rather than the default @code{__}.  A port which
1619 @hook TARGET_DEFAULT_SHORT_ENUMS
1620 This target hook should return true if the compiler should give an
1629 A C expression for a string describing the name of the data type to use
1630 for size values.  The typedef name @code{size_t} is defined using the
1646 A C expression for a string describing the name of the data type to use
1647 for the result of subtracting two pointers.  The typedef name
1655 A C expression for a string describing the name of the data type to use
1656 for wide characters.  The typedef name @code{wchar_t} is defined using
1670 A C expression for a string describing the name of the data type to
1672 @code{getwc}.  The typedef name @code{wint_t} is defined using the
1680 A C expression for a string describing the name of the data type that
1682 The typedef name @code{intmax_t} is defined using the contents of the
1691 A C expression for a string describing the name of the data type that
1693 type.  The typedef name @code{uintmax_t} is defined using the contents
1909 @hook TARGET_CONDITIONAL_REGISTER_USAGE
1910 This hook may conditionally modify five variables
2176 @hook TARGET_HARD_REGNO_SCRATCH_OK
2177 This target hook should return @code{true} if it is OK to use a hard register
2183 The default version of this hook always returns @code{true}.
2304 You define a number of register classes, giving each one a name and saying
2317 terribly special about the name, but the operand constraint letters
2373 the class name to type @code{int}.  The number serves as an index
2413 A macro whose definition is the name of the class to which a valid
2444 A macro whose definition is the name of the class to which a valid
2509 @hook TARGET_PREFERRED_RENAME_CLASS
2511 @hook TARGET_PREFERRED_RELOAD_CLASS
2512 A target hook that places additional restrictions on the register class
2517 The default version of this hook always returns value of @code{rclass} argument.
2582 @hook TARGET_PREFERRED_OUTPUT_RELOAD_CLASS
2586 The default version of this hook always returns value of @code{rclass}
2609 @hook TARGET_SECONDARY_RELOAD
2636 For input reloads, this target hook is called with nonzero @var{in_p},
2639 hook is called with zero @var{in_p}, and a register of class @var{reload_class}
2643 an intermediate register, the hook @code{secondary_reload} should
2664 hook will be called again to determine how to copy the intermediate
2665 register to/from the reload operand @var{x}, so your hook must also
2669 @c   the port maintainer could name a mov<mode> pattern that has clobbers -
2673 @c   constraints, or we need a new target macro / hook that tells us if an
2675 @c   Such a macro / hook would also be useful in other places.]
2687 @code{copy_cost} also uses this target hook to find out how values are
2698 These macros are obsolete, new ports should use the target hook
2702 target hook.  Older ports still define these macros to indicate to the
2800 @hook TARGET_CLASS_LIKELY_SPILLED_P
2801 A target hook which returns @code{true} if pseudos that have been assigned
2805 The default version of this target hook returns @code{true} if @var{rclass}
2807 default should be used.  Only use this target hook to some other expression
2809 hard registers were needed for spill registers.  If this target hook returns
2813 you should not change the implementation of this target hook since
2818 @hook TARGET_CLASS_MAX_NREGS
2819 A target hook returns the maximum number of consecutive registers
2824 @var{mode})} target hook should be the maximum value of
2828 This target hook helps control the handling of multiple-word values
2831 The default version of this target hook returns the size of @var{mode}
3156 @hook TARGET_BUILTIN_SETJMP_FRAME_VALUE
3157 This target hook should return an rtx that is used to store
3160 machines.  One reason you may need to define this target hook is if
3223 @hook TARGET_DWARF_HANDLE_FRAME_UNSPEC
3224 This target hook allows the backend to emit frame-related insns that
3616 defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
3619 @hook TARGET_STATIC_CHAIN
3620 This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for
3626 The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.
3628 If the static chain is passed in memory, this hook should be used to
3721 @hook TARGET_FRAME_POINTER_REQUIRED
3722 This target hook should return @code{true} if a function must have and use
3723 a frame pointer.  This target hook is called in the reload pass.  If its return
3726 This target hook can in principle examine the current function and decide
3787 @hook TARGET_CAN_ELIMINATE
3788 This target hook should returns @code{true} if the compiler is allowed to
3790 @var{to_reg}.  This target hook need only be defined if @code{ELIMINABLE_REGS}
3814 @hook TARGET_PROMOTE_PROTOTYPES
3815 This target hook returns @code{true} if an argument declared in a
3913 @hook TARGET_RETURN_POPS_ARGS
3914 This target hook returns the number of bytes of its own arguments that
3933 a function used to perform arithmetic, whose name is known specially
3975 @hook TARGET_FUNCTION_ARG
4006 The last time this hook is called, it is called with @code{MODE ==
4019 You may use the hook @code{targetm.calls.must_pass_in_stack}
4028 @hook TARGET_MUST_PASS_IN_STACK
4029 This target hook should return @code{true} if we should not pass @var{type}
4035 @hook TARGET_FUNCTION_INCOMING_ARG
4036 Define this hook if the target machine has ``register windows'', so
4051 @hook TARGET_ARG_PARTIAL_BYTES
4052 This target hook returns the number of bytes at the beginning of an
4070 @hook TARGET_PASS_BY_REFERENCE
4071 This target hook should return @code{true} if an argument at the
4076 If the hook returns true, a copy of that argument is made in memory and a
4082 @hook TARGET_CALLEE_COPIES
4083 The function argument described by the parameters to this hook is
4084 known to be passed by reference.  The hook should return true if the
4088 For any argument for which the hook returns true, if it can be
4092 The default version of this hook always returns false.
4134 contains the name of the function, as a string.  @var{libname} is 0 when
4161 @hook TARGET_FUNCTION_ARG_ADVANCE
4162 This hook updates the summarizer variable pointed to by @var{ca} to
4168 This hook need not do anything if the argument in question was passed
4188 target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}.  It is
4216 @hook TARGET_FUNCTION_ARG_BOUNDARY
4217 This hook returns the alignment boundary, in bits, of an argument
4218 with the specified mode and type.  The default hook returns
4222 @hook TARGET_FUNCTION_ARG_ROUND_BOUNDARY
4233 @hook TARGET_SPLIT_COMPLEX_ARG
4234 This hook should return true if parameter of type @var{type} are passed
4242 The default value of this hook is @code{NULL}, which is treated as always
4246 @hook TARGET_BUILD_BUILTIN_VA_LIST
4247 This hook returns a type node for @code{va_list} for the target.
4248 The default version of the hook returns @code{void*}.
4251 @hook TARGET_ENUM_VA_LIST_P
4252 This target hook is used in function @code{c_common_nodes_and_builtins}
4258 this macro and are set to the name of the va_list builtin type and its
4265 @hook TARGET_FN_ABI_VA_LIST
4266 This hook returns the va_list type of the calling convention specified by
4268 The default version of this hook returns @code{va_list_type_node}.
4271 @hook TARGET_CANONICAL_VA_LIST_TYPE
4272 This hook returns the va_list type of the calling convention specified by the
4277 @hook TARGET_GIMPLIFY_VA_ARG_EXPR
4278 This hook performs target-specific gimplification of
4284 @hook TARGET_VALID_POINTER_MODE
4287 hook returns true for both @code{ptr_mode} and @code{Pmode}.
4290 @hook TARGET_REF_MAY_ALIAS_ERRNO
4292 @hook TARGET_SCALAR_MODE_SUPPORTED_P
4298 The default version of this hook returns true for any mode
4304 @hook TARGET_VECTOR_MODE_SUPPORTED_P
4310 @hook TARGET_ARRAY_MODE_SUPPORTED_P
4312 @hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P
4314 small register classes.  If this target hook returns nonzero for a given
4316 in @var{mode}.  The hook may be called with @code{VOIDmode} as argument.
4317 In this case, the hook is expected to return nonzero if it returns nonzero
4333 strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P}
4336 The default version of this hook returns false for any mode.  It is always
4337 safe to redefine this hook to return with a nonzero value.  But if you
4339 that can be performed in some cases.  If you do not define this hook
4344 @hook TARGET_FLAGS_REGNUM
4355 @hook TARGET_FUNCTION_VALUE
4361 function being called.  If @var{outgoing} is false, the hook should
4363 Otherwise, the hook should return an RTX representing the place where
4409 support routine, used to perform arithmetic, whose name is known
4414 @hook TARGET_LIBCALL_VALUE
4415 Define this hook if the back-end needs to know the name of the libcall
4418 The mode of the result is given by @var{mode} and the name of the called
4419 library function is given by @var{fun}.  The hook should return an RTX
4422 If this hook is not defined, then LIBCALL_VALUE will be used.
4446 @hook TARGET_FUNCTION_VALUE_REGNO_P
4447 A target hook that return @code{true} if @var{regno} is the number of a hard
4452 recognized by this target hook.
4455 function use different registers for the return value, this target hook
4458 If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used.
4467 @hook TARGET_RETURN_IN_MSB
4468 This hook should return true if values of type @var{type} are returned
4497 @hook TARGET_RETURN_IN_MEMORY
4498 This target hook should return a nonzero value to say to return the
4507 possible to leave the hook undefined; this causes a default
4511 Do not use this hook to indicate that structures and unions should always
4522 target hook.
4527 @hook TARGET_STRUCT_VALUE_RTX
4528 This target hook should return the location of the structure value
4532 hook if the address is always passed as an ``invisible'' first
4562 @hook TARGET_GET_RAW_RESULT_MODE
4564 @hook TARGET_GET_RAW_ARG_MODE
4600 @hook TARGET_ASM_FUNCTION_PROLOGUE
4645 @hook TARGET_ASM_FUNCTION_END_PROLOGUE
4652 @hook TARGET_ASM_FUNCTION_BEGIN_EPILOGUE
4659 @hook TARGET_ASM_FUNCTION_EPILOGUE
4670 instruction the name @samp{return} and do not define the macro
4798 @hook TARGET_ASM_OUTPUT_MI_THUNK
4840 @hook TARGET_ASM_CAN_OUTPUT_MI_THUNK
4865 variable to be loaded into some register.  The name of this variable is
4867 the name using @samp{LP%d} in a @code{fprintf}.
4893 @hook TARGET_FUNCTION_OK_FOR_SIBCALL
4900 during PIC compilation.  The hook is used to enforce these restrictions,
4906 @hook TARGET_EXTRA_LIVE_ON_ENTRY
4908 function.  This hook only needs to be defined to provide registers that
4915 @hook TARGET_SET_UP_BY_PROLOGUE
4921 @hook TARGET_STACK_PROTECT_GUARD
4922 This hook returns a @code{DECL} node for the external variable to use
4928 The default version of this hook creates a variable called
4932 @hook TARGET_STACK_PROTECT_FAIL
4933 This hook returns a tree expression that alerts the runtime that the
4937 The default version of this hook invokes a function called
4942 @hook TARGET_SUPPORTS_SPLIT_STACK
4972 control of the target hook @code{TARGET_EXPAND_BUILTIN_SAVEREGS}.  On
5012 @hook TARGET_EXPAND_BUILTIN_SAVEREGS
5013 If defined, this hook produces the machine-specific code for a call to
5020 @hook TARGET_SETUP_INCOMING_VARARGS
5021 This target hook offers an alternative to using
5022 @code{__builtin_saveregs} and defining the hook
5034 The target hook should do two things: first, push onto the stack all the
5050 end of the source file.  The hook @code{TARGET_SETUP_INCOMING_VARARGS} should
5054 @hook TARGET_STRICT_ARGUMENT_NAMING
5055 Define this hook to return @code{true} if the location where a function
5058 This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}
5059 is set for varargs and stdarg functions.  If this hook returns
5066 You need not define this hook if it always returns @code{false}.
5069 @hook TARGET_PRETEND_OUTGOING_VARARGS_NAMED
5073 defined, then define this hook to return @code{true} if
5075 Otherwise, you should not define this hook.
5106 @hook TARGET_ASM_TRAMPOLINE_TEMPLATE
5107 This hook is called by @code{assemble_trampoline_template} to output,
5112 If you do not define this hook, it means no template is needed
5113 for the target.  Do not define this hook on systems where the block move
5134 @hook TARGET_TRAMPOLINE_INIT
5135 This hook is called to initialize a trampoline.
5142 first thing this hook should do is emit a block move into @var{m_tramp}
5153 @hook TARGET_TRAMPOLINE_ADJUST_ADDRESS
5154 This hook should perform any machine-specific adjustment in
5160 If this hook is not defined, @var{addr} will be used for function calls.
5221 @hook TARGET_INIT_LIBFUNCS
5222 This hook should declare additional library routines or rename
5228 The default is to do nothing.  Most ports don't need to define this hook.
5231 @hook TARGET_LIBFUNC_GNU_PREFIX
5365 @hook TARGET_LEGITIMATE_ADDRESS_P
5401 target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information
5409 this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro.  This macro
5426 Using the hook is usually simpler because it limits the number of
5454 @hook TARGET_LEGITIMIZE_ADDRESS
5455 This hook is given an invalid memory address @var{x} for an
5464 The code of the hook should not alter the substructure of
5468 It is not necessary for this hook to come up with a legitimate address.
5470 is safe to omit this hook or make it return @var{x} if it cannot find
5524 @hook TARGET_MODE_DEPENDENT_ADDRESS_P
5525 This hook returns @code{true} if memory address @var{addr} can have
5537 The default version of this hook returns @code{false}.
5555 @code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
5558 @hook TARGET_LEGITIMATE_CONSTANT_P
5559 This hook returns true if @var{x} is a legitimate constant for a
5566 @hook TARGET_DELEGITIMIZE_ADDRESS
5567 This hook is used to undo the possibly obfuscating effects of the
5571 addressing modes.  This target hook allows GCC's optimizers to understand
5576 @hook TARGET_CONST_NOT_OK_FOR_DEBUG_P
5577 This hook should return true if @var{x} should not be emitted into
5581 @hook TARGET_CANNOT_FORCE_CONST_MEM
5582 This hook should return true if @var{x} is of a form that cannot (or
5586 The default version of this hook returns false.
5588 The primary reason to define this hook is to prevent reload from
5595 @hook TARGET_USE_BLOCKS_FOR_CONSTANT_P
5596 This hook should return true if pool entries for constant @var{x} can
5603 @hook TARGET_BUILTIN_RECIPROCAL
5604 This hook should return the DECL of a function that implements reciprocal of
5613 @hook TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
5614 This hook should return the DECL of a function @var{f} that given an
5631 If this hook is defined, the autovectorizer will generate a call
5632 to @var{f} (using the DECL tree that this hook returns) and will
5637 If this hook is not defined, then @var{addr} will be used as
5642 @hook TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
5643 This hook should return the DECL of a function @var{f} that implements
5646 If this hook is defined, the autovectorizer will use it along with the
5647 @code{TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD} target hook when vectorizing
5653 @hook TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
5654 This hook should return the DECL of a function @var{f} that implements
5657 If this hook is defined, the autovectorizer will use it along with the
5658 @code{TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN} target hook when vectorizing
5664 @hook TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
5670 @hook TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
5674 @hook TARGET_VECTORIZE_VEC_PERM_CONST_OK
5678 @hook TARGET_VECTORIZE_BUILTIN_CONVERSION
5679 This hook should return the DECL of a function that implements conversion of the
5685 If this hook is defined, the autovectorizer will use the
5686 @code{TARGET_VECTORIZE_BUILTIN_CONVERSION} target hook when vectorizing
5690 @hook TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
5691 This hook should return the decl of a function that implements the
5699 @hook TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
5700 This hook should return true if the target supports misaligned vector
5707 @hook TARGET_VECTORIZE_PREFERRED_SIMD_MODE
5708 This hook should return the preferred mode for vectorizing scalar
5714 @hook TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES
5715 This hook should return a mask of sizes that should be iterated over
5721 @hook TARGET_VECTORIZE_BUILTIN_TM_LOAD
5723 @hook TARGET_VECTORIZE_BUILTIN_TM_STORE
5725 @hook TARGET_VECTORIZE_BUILTIN_GATHER
5768 @hook TARGET_MIN_ANCHOR_OFFSET
5775 @hook TARGET_MAX_ANCHOR_OFFSET
5781 @hook TARGET_ASM_OUTPUT_ANCHOR
5784 The hook is called with the assembly output position set to the beginning
5787 If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses
5789 If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition
5793 @hook TARGET_USE_ANCHORS_FOR_SYMBOL_P
5799 intercept this hook to handle things like target-specific attributes
6022 @hook TARGET_FIXED_CONDITION_CODE_REGS
6026 hard register is set to a common value.  Use this hook to enable a
6027 small pass which optimizes such cases.  This hook should return true
6034 The default version of this hook returns false.
6037 @hook TARGET_CC_MODES_COMPATIBLE
6041 target hook to take two mode arguments and to return a mode in which
6045 The default version of this hook checks whether the modes are the
6100 These macros are obsolete, new ports should use the target hook
6104 @hook TARGET_REGISTER_MOVE_COST
6105 This target hook should return the cost of moving data of mode @var{mode}
6148 These macros are obsolete, new ports should use the target hook
6152 @hook TARGET_MEMORY_MOVE_COST
6153 This target hook should return the cost of moving data of mode @var{mode}
6158 registers, you should add this target hook to express the relative cost.
6160 If you do not add this target hook, GCC uses a default cost of 4 plus
6164 more complex than copying via an intermediate, use this target hook to
6171 4 is not correct for your machine, use this target hook to add some other
6173 are the same as to this target hook.
6359 @hook TARGET_RTX_COSTS
6360 This target hook describes the relative costs of RTL expressions.
6365 That is, the hook can assume that there is some rtx @var{y} such
6373 In implementing this hook, you can use the construct
6377 On entry to the hook, @code{*@var{total}} contains a default estimate
6378 for the cost of the expression.  The hook should modify this value as
6384 false, this target hook should be used to estimate the relative
6387 The hook returns true when all subexpressions of @var{x} have been
6391 @hook TARGET_ADDRESS_COST
6392 This hook computes the cost of an addressing mode that contains
6394 the @var{address} expression and the @code{TARGET_RTX_COST} hook.
6414 This hook is never called with an invalid address.
6434 @hook TARGET_SCHED_ISSUE_RATE
6435 This hook returns the maximum number of instructions that can ever
6446 @hook TARGET_SCHED_VARIABLE_ISSUE
6447 This hook is executed by the scheduler after it has scheduled an insn
6452 You should define this hook if some insns take more machine resources
6460 @hook TARGET_SCHED_ADJUST_COST
6471 acceptable, you could use the hook to modify them too.  See also
6475 @hook TARGET_SCHED_ADJUST_PRIORITY
6476 This hook adjusts the integer scheduling priority @var{priority} of
6479 later.  Do not define this hook if you do not need to adjust the
6483 @hook TARGET_SCHED_REORDER
6484 This hook is executed by the scheduler after it has scheduled the ready
6500 @hook TARGET_SCHED_REORDER2
6506 this hook can be useful if there are frequent situations where
6511 @hook TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK
6512 This hook is called after evaluation forward dependencies of insns in
6516 analysis of dependencies.  This hook can use backward and forward
6521 @hook TARGET_SCHED_INIT
6522 This hook is executed by the scheduler at the beginning of each block of
6531 @hook TARGET_SCHED_FINISH
6532 This hook is executed by the scheduler at the end of each block of
6540 @hook TARGET_SCHED_INIT_GLOBAL
6541 This hook is executed by the scheduler after function level initializations.
6547 @hook TARGET_SCHED_FINISH_GLOBAL
6548 This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.
6553 @hook TARGET_SCHED_DFA_PRE_CYCLE_INSN
6554 The hook returns an RTL insn.  The automaton state used in the
6556 when the new simulated processor cycle starts.  Usage of the hook may
6558 processors.  If the hook is defined, it is used only for the automaton
6563 @hook TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN
6564 The hook can be used to initialize data used by the previous hook.
6567 @hook TARGET_SCHED_DFA_POST_CYCLE_INSN
6568 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
6573 @hook TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN
6574 The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but
6575 used to initialize data used by the previous hook.
6578 @hook TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE
6579 The hook to notify target that the current simulated cycle is about to finish.
6580 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
6585 @hook TARGET_SCHED_DFA_POST_ADVANCE_CYCLE
6586 The hook to notify target that new simulated cycle has just started.
6587 The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used
6592 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
6593 This hook controls better choosing an insn from the ready insn queue
6595 chooses the first insn from the queue.  If the hook returns a positive
6621 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
6623 This hook controls what insns from the ready insn queue will be
6624 considered for the multipass insn scheduling.  If the hook returns
6631 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN
6632 This hook prepares the target backend for a new round of multipass
6636 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE
6637 This hook is called when multipass scheduling evaluates instruction INSN.
6640 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK
6645 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END
6646 This hook notifies the target about the result of the concluded current
6650 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT
6651 This hook initializes target-specific data used in multipass scheduling.
6654 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI
6655 This hook finalizes target-specific data used in multipass scheduling.
6658 @hook TARGET_SCHED_DFA_NEW_CYCLE
6659 This hook is called by the insn scheduler before issuing @var{insn}
6660 on cycle @var{clock}.  If the hook returns nonzero,
6671 @hook TARGET_SCHED_IS_COSTLY_DEPENDENCE
6672 This hook is used to define which dependences are considered costly by
6675 to this hook are as follows:  The first parameter @var{_dep} is the dependence
6679 The hook returns @code{true} if considering the distance between the two
6683 Defining this hook can be useful in multiple-issue out-of-order machines,
6692 @hook TARGET_SCHED_H_I_D_EXTENDED
6693 This hook is called by the insn scheduler after emitting a new instruction to
6694 the instruction stream.  The hook notifies a target backend to extend its
6698 @hook TARGET_SCHED_ALLOC_SCHED_CONTEXT
6702 @hook TARGET_SCHED_INIT_SCHED_CONTEXT
6708 @hook TARGET_SCHED_SET_SCHED_CONTEXT
6712 @hook TARGET_SCHED_CLEAR_SCHED_CONTEXT
6716 @hook TARGET_SCHED_FREE_SCHED_CONTEXT
6720 @hook TARGET_SCHED_SPECULATE_INSN
6721 This hook is called by the insn scheduler when @var{insn} has only
6723 The hook is used to check if the pattern of @var{insn} has a speculative
6725 pattern.  The hook should return 1, if the instruction has a speculative form,
6731 @hook TARGET_SCHED_NEEDS_BLOCK_P
6732 This hook is called by the insn scheduler during generation of recovery code
6737 @hook TARGET_SCHED_GEN_SPEC_CHECK
6738 This hook is called by the insn scheduler to generate a pattern for recovery
6748 @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC
6749 This hook is used as a workaround for
6751 called on the first instruction of the ready list.  The hook is used to
6753 being scheduled on the current cycle.  If the hook returns @code{false},
6756 the hook should always return @code{true}.  For example, in the ia64 backend
6757 the hook is used to cancel data speculative insns when the ALAT table
6761 @hook TARGET_SCHED_SET_SCHED_FLAGS
6762 This hook is used by the insn scheduler to find out what features should be
6768 @hook TARGET_SCHED_SMS_RES_MII
6769 This hook is called by the swing modulo scheduler to calculate a
6773 bound will be used in case this hook is not implemented: the total number
6777 @hook TARGET_SCHED_DISPATCH
6778 This hook is called by Haifa Scheduler.  It returns true if dispatch scheduling
6782 @hook TARGET_SCHED_DISPATCH_DO
6783 This hook is called by Haifa Scheduler.  It performs the operation specified
6787 @hook TARGET_SCHED_EXPOSED_PIPELINE
6789 @hook TARGET_SCHED_REASSOCIATION_WIDTH
6817 should define the @code{TARGET_ASM_INIT_SECTIONS} hook and use
6837 If defined, a C string constant for the name of the section containing most
6843 If defined, a C string constant for the name of the section containing unlikely
6966 @hook TARGET_ASM_INIT_SECTIONS
6967 Define this hook if you need to do something special to set up the
6971 GCC calls this hook after processing the command line, but before writing
6976 @hook TARGET_ASM_RELOC_RW_MASK
6983 is in effect, and 0 otherwise.  The hook is typically redefined
6988 @hook TARGET_ASM_SELECT_SECTION
7011 @hook TARGET_ASM_UNIQUE_SECTION
7012 Build up a unique section name, expressed as a @code{STRING_CST} node,
7017 The default version of this function appends the symbol name to the
7018 ELF section name that would normally be used for the symbol.  For
7023 @hook TARGET_ASM_FUNCTION_RODATA_SECTION
7026 The default version of this function selects @code{.gnu.linkonce.r.name} if
7027 the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name}
7028 if function is in @code{.text.name}, and the normal readonly-data section
7032 @hook TARGET_ASM_MERGEABLE_RODATA_PREFIX
7034 @hook TARGET_ASM_TM_CLONE_TABLE_SECTION
7036 @hook TARGET_ASM_SELECT_RTX_SECTION
7048 @hook TARGET_MANGLE_DECL_ASSEMBLER_NAME
7049 Define this hook if you need to postprocess the assembler name generated
7050 by target-independent code.  The @var{id} provided to this hook will be
7051 the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C,
7052 or the mangled name of the @var{decl} in C++).  The return value of the
7053 hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on
7054 your target system.  The default implementation of this hook just
7058 @hook TARGET_ENCODE_SECTION_INFO
7059 Define this hook if references to a symbol or a constant must be
7063 The hook is executed immediately after rtl has been created for
7067 in this hook; that field may not have been initialized yet.
7080 declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}.
7081 @var{new_decl_p} is always true when the hook is called for a constant.
7084 The usual thing for this hook to do is to record flags in the
7086 Historically, the name string was modified if it was necessary to
7090 The default definition of this hook, @code{default_encode_section_info}
7096 @hook TARGET_STRIP_NAME_ENCODING
7097 Decode @var{name} and return the real name part, sans
7102 @hook TARGET_IN_SMALL_DATA_P
7104 The default version of this hook always returns false.
7107 @hook TARGET_HAVE_SRODATA_SECTION
7112 @hook TARGET_PROFILE_BEFORE_PROLOGUE
7114 @hook TARGET_BINDS_LOCAL_P
7115 Returns true if @var{exp} names an object for which name resolution
7119 The default version of this hook implements the name resolution rules
7120 for ELF, which has a looser model of global name binding than other
7124 @hook TARGET_HAVE_TLS
7137 generate valid PIC; you must also add support to the hook
7207 @hook TARGET_ASM_FILE_START
7212 @code{default_file_start} at some point in your target hook.  This
7216 @hook TARGET_ASM_FILE_START_APP_OFF
7230 @hook TARGET_ASM_FILE_START_FILE_DIRECTIVE
7237 @hook TARGET_ASM_FILE_END
7247 need to do other things in that hook, have your hook function call
7251 @hook TARGET_ASM_LTO_START
7257 @hook TARGET_ASM_LTO_END
7263 @hook TARGET_ASM_CODE_END
7292 @defmac ASM_OUTPUT_SOURCE_FILENAME (@var{stream}, @var{name})
7294 which indicates that filename @var{name} is the current source file to
7301 @hook TARGET_ASM_OUTPUT_SOURCE_FILENAME
7317 @hook TARGET_ASM_NAMED_SECTION
7318 Output assembly directives to switch to section @var{name}.  The section
7325 @hook TARGET_ASM_FUNCTION_SECTION
7335 @hook TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS
7337 @hook TARGET_HAVE_NAMED_SECTIONS
7343 @hook TARGET_HAVE_SWITCHABLE_BSS_SECTIONS
7349 @hook TARGET_SECTION_TYPE_FLAGS
7351 based on a variable or function decl, a section name, and whether or not the
7361 @hook TARGET_ASM_RECORD_GCC_SWITCHES
7381 target hook that either recording is starting or ending.  The first
7384 wind down.  This feature is to allow the target hook to make any
7390 This option can be ignored by this target hook.
7393 This option can be ignored by this target hook.
7396 The hook's return value must be zero.  Other return values may be
7399 By default this hook is set to NULL, but an example implementation is
7402 section in the assembler output file.  The name of the new section is
7404 hook.
7407 @hook TARGET_ASM_RECORD_GCC_SWITCHES_SECTION
7408 This is the name of the section that will be created by the example
7410 hook.
7418 @hook TARGET_ASM_BYTE_OP
7438 @hook TARGET_ASM_INTEGER
7439 The @code{assemble_integer} function uses this hook to output an
7446 The default implementation of this hook will use the
7451 @hook TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
7452 A target hook to recognize @var{rtx} patterns that @code{output_addr_const}
7457 If target hook fails to recognize a pattern, it must return @code{false},
7492 the name of the function.  Should the return type of the function
7531 pool for a function.  @var{funname} is a string giving the name of the
7550 @hook TARGET_ASM_OPEN_PAREN
7587 @defmac ASM_OUTPUT_COMMON (@var{stream}, @var{name}, @var{size}, @var{rounded})
7590 @var{name} whose size is @var{size} bytes.  The variable @var{rounded}
7600 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7601 output the name itself; before and after that, output the additional
7602 assembler syntax for defining the name, and a newline.
7608 @defmac ASM_OUTPUT_ALIGNED_COMMON (@var{stream}, @var{name}, @var{size}, @var{alignment})
7616 @defmac ASM_OUTPUT_ALIGNED_DECL_COMMON (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{alig…
7625 @defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{alignment})
7628 @var{name} whose size is @var{size} bytes.  The variable @var{alignment}
7633 @code{assemble_name (@var{stream}, @var{name})} to output the name itself;
7635 the name, and a newline.
7649 @defmac ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size}, @var{rounded})
7652 @var{name} whose size is @var{size} bytes.  The variable @var{rounded}
7655 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7656 output the name itself; before and after that, output the additional
7657 assembler syntax for defining the name, and a newline.
7663 @defmac ASM_OUTPUT_ALIGNED_LOCAL (@var{stream}, @var{name}, @var{size}, @var{alignment})
7671 @defmac ASM_OUTPUT_ALIGNED_DECL_LOCAL (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{align…
7687 @defmac ASM_OUTPUT_LABEL (@var{stream}, @var{name})
7689 @var{stream} the assembler definition of a label named @var{name}.
7690 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7691 output the name itself; before and after that, output the additional
7692 assembler syntax for defining the name, and a newline.  A default
7696 @defmac ASM_OUTPUT_FUNCTION_LABEL (@var{stream}, @var{name}, @var{decl})
7698 @var{stream} the assembler definition of a label named @var{name} of
7700 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7701 output the name itself; before and after that, output the additional
7702 assembler syntax for defining the name, and a newline.  A default
7705 If this macro is not defined, then the function name is defined in the
7710 @defmac ASM_OUTPUT_INTERNAL_LABEL (@var{stream}, @var{name})
7711 Identical to @code{ASM_OUTPUT_LABEL}, except that @var{name} is known
7730 @defmac ASM_OUTPUT_SIZE_DIRECTIVE (@var{stream}, @var{name}, @var{size})
7733 symbol @var{name} is @var{size}.  @var{size} is a @code{HOST_WIDE_INT}.
7738 @defmac ASM_OUTPUT_MEASURED_SIZE (@var{stream}, @var{name})
7741 the symbol @var{name} by subtracting its address from the current
7779 symbol @var{name} is @var{type}.  @var{type} is a C string; currently,
7787 @defmac ASM_DECLARE_FUNCTION_NAME (@var{stream}, @var{name}, @var{decl})
7789 @var{stream} any text necessary for declaring the name @var{name} of a
7795 If this macro is not defined, then the function name is defined in the
7802 @defmac ASM_DECLARE_FUNCTION_SIZE (@var{stream}, @var{name}, @var{decl})
7805 which is being defined.  The argument @var{name} is the name of the
7815 @defmac ASM_DECLARE_OBJECT_NAME (@var{stream}, @var{name}, @var{decl})
7817 @var{stream} any text necessary for declaring the name @var{name} of an
7822 If this macro is not defined, then the variable name is defined in the
7829 @hook TARGET_ASM_DECLARE_CONSTANT_NAME
7830 A target hook to output to the stdio stream @var{file} any text necessary
7831 for declaring the name @var{name} of a constant which is being defined.  This
7832 target hook is responsible for outputting the label definition (perhaps using
7834 and @var{size} is the size of the constant in bytes.  The @var{name}
7837 The default version of this target hook, define the @var{name} in the
7840 You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook.
7843 @defmac ASM_DECLARE_REGISTER_GLOBAL (@var{stream}, @var{decl}, @var{regno}, @var{name})
7846 for a global variable @var{decl} with name @var{name}.
7853 A C statement (sans semicolon) to finish up declaring a variable name
7866 @hook TARGET_ASM_GLOBALIZE_LABEL
7867 This target hook is a function to output to the stdio stream
7868 @var{stream} some commands that will make the label @var{name} global;
7875 @hook TARGET_ASM_GLOBALIZE_DECL_NAME
7876 This target hook is a function to output to the stdio stream
7877 @var{stream} some commands that will make the name associated with @var{decl}
7880 The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.
7883 @defmac ASM_WEAKEN_LABEL (@var{stream}, @var{name})
7885 @var{stream} some commands that will make the label @var{name} weak;
7888 @code{assemble_name (@var{stream}, @var{name})} to output the name
7890 for making that name weak, and a newline.
7897 @defmac ASM_WEAKEN_DECL (@var{stream}, @var{decl}, @var{name}, @var{value})
7902 defines (equates) the weak symbol @var{name} to have the value
7904 to make @var{name} weak.
7907 @defmac ASM_OUTPUT_WEAKREF (@var{stream}, @var{decl}, @var{name}, @var{value})
7908 Outputs a directive that enables @var{name} to be used to refer to
7910 declaration of @code{name}.
7952 @hook TARGET_ASM_ASSEMBLE_VISIBILITY
7953 This target hook is a function to output to @var{asm_out_file} some
7977 @defmac ASM_OUTPUT_EXTERNAL (@var{stream}, @var{decl}, @var{name})
7979 @var{stream} any text necessary for declaring the name of an external
7980 symbol named @var{name} which is referenced in this compilation but
7988 @hook TARGET_ASM_EXTERNAL_LIBCALL
7989 This target hook is a function to output to @var{asm_out_file} an assembler
7990 pseudo-op to declare a library function name external.  The name of the
7994 @hook TARGET_ASM_MARK_DECL_PRESERVED
7995 This target hook is a function to output to @var{asm_out_file} an assembler
8000 @defmac ASM_OUTPUT_LABELREF (@var{stream}, @var{name})
8003 @var{name}.  This should add @samp{_} to the front of the name, if that
8008 @hook TARGET_MANGLE_ASSEMBLER_NAME
8013 will be used to output the name of the symbol.  This macro may be used
8021 @code{assemble_name} will be used to output the name of the symbol.
8028 @hook TARGET_ASM_INTERNAL_LABEL
8030 name is made from the string @var{prefix} and the number @var{labelno}.
8034 will have name conflicts with internal labels.
8047 label whose name is made from the string @var{prefix} and the number
8059 A C statement to store into the string @var{string} a label whose name
8075 @defmac ASM_FORMAT_PRIVATE_NAME (@var{outvar}, @var{name}, @var{number})
8078 @var{name} and the number @var{number}, with some suitable punctuation
8082 produce an assembler label for an internal static variable whose name is
8083 @var{name}.  Therefore, the string must be such as to result in valid
8091 between the name and the number will suffice.
8097 @defmac ASM_OUTPUT_DEF (@var{stream}, @var{name}, @var{value})
8099 which defines (equates) the symbol @var{name} to have the value @var{value}.
8127 @defmac ASM_OUTPUT_WEAK_ALIAS (@var{stream}, @var{name}, @var{value})
8129 which defines (equates) the weak symbol @var{name} to have the value
8130 @var{value}.  If @var{value} is @code{NULL}, it defines @var{name} as
8141 The default name is a unique method number followed by the name of the
8142 class (e.g.@: @samp{_1_Foo}).  For methods in categories, the name of
8143 the category is also included in the assembler name (e.g.@:
8147 the method's selector is not present in the name.  Therefore, particular
8151 buffer in which to store the name; its length is as long as
8156 method or a class method; @var{class_name} is the name of the class;
8157 @var{cat_name} is the name of the category (or @code{NULL} if the method is not
8158 in a category); and @var{sel_name} is the name of the selector.
8259 entry of type @samp{N_SETT}, referencing the name @code{__CTOR_LIST__},
8353 @hook TARGET_HAVE_CTORS_DTORS
8359 @hook TARGET_ASM_CONSTRUCTOR
8374 @hook TARGET_ASM_DESTRUCTOR
8399 Define this macro as a C string constant containing the file name to use
8418 Define this macro to a C string constant containing the name of the program
8452 If defined, a C initializer for an array of structures containing a name
8460 name, a register number and a count of the number of consecutive
8461 machine registers the name overlaps.  This macro defines additional
8465 register name implies multiple underlying registers.
8469 register name.  For example, on ARM, clobbering the double-precision
8481 points to the opcode name in its ``internal'' form---the form that is
8483 opcode name to @var{stream}, performing any translation you desire, and
8488 name, or more than the opcode name; but if you want to process text
8523 @hook TARGET_ASM_FINAL_POSTSCAN_INSN
8524 If defined, this target hook is a function which is executed just after the
8550 If @var{x} is a register, this macro should print the register's name.
8576 section that the address refers to.  On these machines, define the hook
8741 @hook TARGET_ASM_EMIT_UNWIND_LABEL
8742 This target hook emits a label at the beginning of each FDE@.  It
8753 @hook TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL
8754 This target hook emits a label at the beginning of the exception table.
8761 @hook TARGET_ASM_EMIT_EXCEPT_PERSONALITY
8763 @hook TARGET_ASM_UNWIND_EMIT
8764 This target hook emits assembly directives required to unwind the
8769 @hook TARGET_ASM_UNWIND_EMIT_BEFORE_INSN
8780 If defined, a C string constant for the name of the section containing
8819 @hook TARGET_EXCEPT_UNWIND_INFO
8820 This hook defines the mechanism that will be used for exception handling
8821 by the target.  If the target has ABI specified unwind tables, the hook
8823 @code{setjmp}/@code{longjmp}-based exception handling scheme, the hook
8825 information, the hook should return @code{UI_DWARF2}.
8829 default implementation of this hook never returns @code{UI_NONE}.
8831 Note that the value returned by this hook should be constant.  It should
8838 The default implementation of the hook first honors the
8842 must define this hook so that @var{opts} is used correctly.
8845 @hook TARGET_UNWIND_TABLES_DEFAULT
8866 @hook TARGET_TERMINATE_DW2_EH_FRAME_INFO
8873 @hook TARGET_DWARF_REGISTER_SPAN
8874 Given a register, this hook should return a parallel of registers to
8875 represent where to find the register pieces.  Define this hook if the
8878 register in Dwarf.  Otherwise, this hook should return @code{NULL_RTX}.
8882 @hook TARGET_INIT_DWARF_REG_SIZES_EXTRA
8884 multiple pieces, define this hook to fill in information about the
8891 @hook TARGET_ASM_TTYPE
8892 This hook is used to output a reference from a frame unwinding table to
8898 @hook TARGET_ARM_EABI_UNWINDER
8925 @hook TARGET_ASM_JUMP_ALIGN_MAX_SKIP
8940 @hook TARGET_ASM_LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
8960 @hook TARGET_ASM_LOOP_ALIGN_MAX_SKIP
8977 @hook TARGET_ASM_LABEL_ALIGN_MAX_SKIP
9140 name.  If you don't define this macro, @code{"\t.stabn\t"} is used.  This
9152 A symbol name in DBX-format debugging information is normally
9233 @defmac DBX_OUTPUT_LBRAC (@var{stream}, @var{name})
9236 argument @var{name} is the name of an assembler symbol (for use with
9240 @defmac DBX_OUTPUT_RBRAC (@var{stream}, @var{name})
9262 @code{.stabs "",N_FUN,,0,0,Lscope-function-1} gdb dbx extension construct.
9264 disturbing the rest of the gdb extensions.
9268 Some assemblers cannot handle the @code{.stabd BNSYM/ENSYM,0,0} gdb dbx
9270 feature off without disturbing the rest of the gdb extensions.
9279 @defmac DBX_OUTPUT_MAIN_SOURCE_FILENAME (@var{stream}, @var{name})
9281 @var{stream}, which indicates that file @var{name} is the main source
9307 @defmac DBX_OUTPUT_MAIN_SOURCE_FILE_END (@var{stream}, @var{name})
9309 compilation of the main source file @var{name}.  Output should be
9339 @hook TARGET_DWARF_CALLING_CONVENTION
9360 @hook TARGET_DEBUG_UNWIND_INFO
9361 This hook defines the mechanism that will be used for describing frame
9362 unwind information to the debugger.  Normally the hook will return
9379 @hook TARGET_WANT_DEBUG_PUB_SECTIONS
9381 @hook TARGET_FORCE_AT_COMP_DIR
9383 @hook TARGET_DELAY_SCHED2
9385 @hook TARGET_DELAY_VARTRACK
9416 @hook TARGET_ASM_OUTPUT_DWARF_DTPREL
9417 If defined, this target hook is a function which outputs a DTP-relative
9676 @hook TARGET_ATTRIBUTE_TABLE
9677 If defined, this target hook points to an array of @samp{struct
9684 @hook TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P
9685 If defined, this target hook is a function which returns true if the
9686 machine-specific attribute named @var{name} expects an identifier
9688 subjected to name lookup.  If this is not defined, the default is
9692 @hook TARGET_COMP_TYPE_ATTRIBUTES
9693 If defined, this target hook is a function which returns zero if the attributes on
9700 @hook TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
9701 If defined, this target hook is a function which assigns default attributes to
9705 @hook TARGET_MERGE_TYPE_ATTRIBUTES
9706 Define this target hook if the merging of type attributes needs special
9714 @hook TARGET_MERGE_DECL_ATTRIBUTES
9715 Define this target hook if the merging of decl attributes needs special
9736 @hook TARGET_VALID_DLLIMPORT_ATTRIBUTE_P
9747 @hook TARGET_INSERT_ATTRIBUTES
9748 Define this target hook if you want to be able to add attributes to a decl
9760 @hook TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P
9762 This target hook returns @code{true} if it is ok to inline @var{fndecl}
9768 @hook TARGET_OPTION_VALID_ATTRIBUTE_P
9769 This hook is called to parse the @code{attribute(option("..."))}, and
9772 options specified on the command line.  The hook should return
9775 The hook should set the @var{DECL_FUNCTION_SPECIFIC_TARGET} field in
9780 @hook TARGET_OPTION_SAVE
9781 This hook is called to save any additional target specific information
9787 @hook TARGET_OPTION_RESTORE
9788 This hook is called to restore any additional target specific
9793 @hook TARGET_OPTION_PRINT
9794 This hook is called to print any additional target specific
9799 @hook TARGET_OPTION_PRAGMA_PARSE
9800 This target hook parses the options for @code{#pragma GCC option} to
9803 @code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook.
9806 @hook TARGET_OPTION_OVERRIDE
9808 a particular target machine.  You can override the hook
9812 Don't use this hook to turn on various extra optimizations for
9820 @hook TARGET_CAN_INLINE_P
9821 This target hook returns @code{false} if the @var{caller} function
9843 @hook TARGET_EMUTLS_GET_ADDRESS
9844 Contains the name of the helper function that uses a TLS control
9849 @hook TARGET_EMUTLS_REGISTER_COMMON
9850 Contains the name of the helper function that should be used at
9857 @hook TARGET_EMUTLS_VAR_SECTION
9858 Contains the name of the section in which TLS control variables should
9863 @hook TARGET_EMUTLS_TMPL_SECTION
9864 Contains the name of the section in which TLS initializers should be
9869 @hook TARGET_EMUTLS_VAR_PREFIX
9874 @hook TARGET_EMUTLS_TMPL_PREFIX
9879 @hook TARGET_EMUTLS_VAR_FIELDS
9882 @var{name} should be filled with the structure tag, if the default of
9887 @hook TARGET_EMUTLS_VAR_INIT
9894 @hook TARGET_EMUTLS_VAR_ALIGN_FIXED
9900 @hook TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS
9921 (``c0r1'' is the default name of register 1 in coprocessor 0; alternate
9949 @hook TARGET_GET_PCH_VALIDITY
9950 This hook returns a pointer to the data needed by
9955 @hook TARGET_PCH_VALID_P
9956 This hook checks whether the options used to create a PCH file are
9970 @hook TARGET_CHECK_PCH_TARGET_FLAGS
9971 If this hook is nonnull, the default implementation of
9978 @hook TARGET_PREPARE_PCH_SAVE
9984 @hook TARGET_CXX_GUARD_TYPE
9985 Define this hook to override the integer type used for guard variables.
9990 @hook TARGET_CXX_GUARD_MASK_BIT
9991 This hook determines how guard variables are used.  It should return
9996 @hook TARGET_CXX_GET_COOKIE_SIZE
9997 This hook returns the size of the cookie to use when allocating an array
10004 @hook TARGET_CXX_COOKIE_HAS_SIZE
10005 This hook should return @code{true} if the element size should be stored in
10009 @hook TARGET_CXX_IMPORT_EXPORT_CLASS
10010 If defined by a backend this hook allows the decision made to export
10018 @hook TARGET_CXX_CDTOR_RETURNS_THIS
10019 This hook should return @code{true} if constructors and destructors return
10024 @hook TARGET_CXX_KEY_METHOD_MAY_BE_INLINE
10025 This hook returns true if the key method for a class (i.e., the method
10034 @hook TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY
10036 @hook TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT
10037 This hook returns true (the default) if virtual tables and other
10039 external linkage.  If this hook returns false, then class data for
10044 @hook TARGET_CXX_LIBRARY_RTTI_COMDAT
10045 This hook returns true (the default) if the RTTI information for
10050 @hook TARGET_CXX_USE_AEABI_ATEXIT
10051 This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI)
10056 @hook TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT
10057 This hook returns true if the target @code{atexit} function can be used
10064 @hook TARGET_CXX_ADJUST_CLASS_AT_DEFINITION
10104 @hook TARGET_ADDR_SPACE_POINTER_MODE
10107 The default version of this hook returns @code{ptr_mode} for the
10111 @hook TARGET_ADDR_SPACE_ADDRESS_MODE
10114 The default version of this hook returns @code{Pmode} for the
10118 @hook TARGET_ADDR_SPACE_VALID_POINTER_MODE
10121 hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,
10123 version of this hook returns true for the modes returned by either the
10128 @hook TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P
10132 finished.  This target hook is the same as the
10133 @code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes
10137 @hook TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS
10140 hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,
10144 @hook TARGET_ADDR_SPACE_SUBSET_P
10153 @hook TARGET_ADDR_SPACE_CONVERT
10157 to a different named address space.  When this hook it called, it is
10159 as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.
10188 An alias for a machine mode name.  This is the machine mode that
10210 @hook TARGET_CASE_VALUES_THRESHOLD
10271 @hook TARGET_MIN_DIVISIONS_FOR_RECIP_MUL
10274 the reciprocal.  This target hook specifies the minimum number of divisions
10319 @hook TARGET_SHIFT_TRUNCATION_MASK
10359 @hook TARGET_MODE_REP_EXTENDED
10587 defining the target hook @samp{TARGET_INSERT_ATTRIBUTES} as well.
10594 @deftypefun void c_register_pragma (const char *@var{space}, const char *@var{name}, void (*@var{ca…
10595 @deftypefunx void c_register_pragma_with_expansion (const char *@var{space}, const char *@var{name}…
10603 #pragma [@var{space}] @var{name} @dots{}
10610 @var{name} by calling @code{pragma_lex}.  Tokens that are not read by the
10623 target entry in the @file{config.gcc} file.  These variables should name
10635 @hook TARGET_HANDLE_PRAGMA_EXTERN_PREFIX
10701 @hook TARGET_MD_ASM_CLOBBERS
10702 This target hook should add to @var{clobbers} @code{STRING_CST} trees for
10795 @hook TARGET_MACHINE_DEPENDENT_REORG
10796 If non-null, this hook performs a target-specific pass over the
10800 The exact purpose of the hook varies from target to target.  Some use
10805 You need not implement the hook if it has nothing to do.  The default
10809 @hook TARGET_INIT_BUILTINS
10810 Define this hook if you have any machine-specific built-in functions
10827 @hook TARGET_BUILTIN_DECL
10828 Define this hook if you have any machine-specific built-in functions
10837 @hook TARGET_EXPAND_BUILTIN
10849 @hook TARGET_RESOLVE_OVERLOADED_BUILTIN
10861 @hook TARGET_FOLD_BUILTIN
10870 @hook TARGET_INVALID_WITHIN_DOLOOP
10894 @hook TARGET_COMMUTATIVE_P
10895 This target hook returns @code{true} if @var{x} is considered to be commutative.
10901 @hook TARGET_ALLOCATE_INITIAL_VALUE
10916 You may use @code{current_function_leaf_function} in the hook, functions
10919 The default value of this hook is @code{NULL}, which disables any special
10923 @hook TARGET_UNSPEC_MAY_TRAP_P
10924 This target hook returns nonzero if @var{x}, an @code{unspec} or
10926 this hook to enhance precision of analysis for @code{unspec} and
10932 @hook TARGET_SET_CURRENT_FUNCTION
10933 The compiler invokes this hook whenever it changes its current function
10941 The default hook function does nothing.
10944 some parts of the back end.  The hook function is not invoked in this
10945 situation; you need not worry about the hook being invoked recursively,
10988 @hook TARGET_CANNOT_MODIFY_JUMPS_P
10989 This target hook returns @code{true} past the point in which new jump
10992 reload, so this target hook should be defined to a function such as:
11003 @hook TARGET_BRANCH_TARGET_REGISTER_CLASS
11004 This target hook returns a register class for which branch target register
11011 @hook TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED
11014 that are not already live during the current function; if this target hook
11025 @hook TARGET_HAVE_CONDITIONAL_EXECUTION
11026 This target hook returns true if the target supports conditional execution.
11027 This target hook is required only when the target has several different
11031 @hook TARGET_LOOP_UNROLL_ADJUST
11032 This target hook returns a new value for the number of times @var{loop}
11035 the loop, which is going to be checked for unrolling. This target hook
11051 This target hook should register any extra include files for the
11058 This target hook should register any extra include files for the
11066 This target hook should register special include paths for the target.
11081 If defined, this macro is the name of a global variable containing
11092 If defined, this macro is the name of a global variable containing
11109 @hook TARGET_RELAXED_ORDERING
11119 @hook TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
11125 @hook TARGET_INVALID_CONVERSION
11131 @hook TARGET_INVALID_UNARY_OP
11138 @hook TARGET_INVALID_BINARY_OP
11145 @hook TARGET_INVALID_PARAMETER_TYPE
11152 @hook TARGET_INVALID_RETURN_TYPE
11159 @hook TARGET_PROMOTED_TYPE
11160 If defined, this target hook returns the type to which values of
11163 front end's normal promotion rules.  This hook is useful when there are
11168 @hook TARGET_CONVERT_TO_TYPE
11169 If defined, this hook returns the result of converting @var{expr} to
11172 This hook is useful when there are target-specific types with special
11195 @hook TARGET_UPDATE_STACK_BOUNDARY
11200 @hook TARGET_GET_DRAP_RTX
11201 This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a
11207 @hook TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS
11208 When optimization is disabled, this hook indicates whether or not
11214 to the stack.  Therefore, this hook should return true in general, but
11218 @hook TARGET_CONST_ANCHOR
11235 @hook TARGET_ATOMIC_TEST_AND_SET_TRUEVAL