Lines Matching +refs:gdb +refs:comment +refs:hook

672 This hook is called whenever the user specifies one of the
686 This target hook is called whenever the user specifies one of the
700 …s hook should return a reference to such an object constructed from the normal `C' string represen…
712 If a target implements string objects then this hook should return @code{true} if @var{stringref} i…
716 If a target implements string objects then this hook should should  provide a facility to check the…
720 This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}
730 This is similar to the @code{TARGET_OPTION_OVERRIDE} hook
956 function return values.  The target hook should return the new mode
966 then the hook should return the same mode as @code{promote_mode}, though
972 also define the hook to @code{default_promote_function_mode_always_promote}
1117 This hook can be used to define the alignment for a vector of type
1120 this hook must be a power-of-two multiple of the default alignment of
1257 When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine
1259 structure.  The hook should return true if the structure should inherit
1264 This target hook should return @code{true} if accesses to volatile bitfields
1326 This target hook should return the mode to be used for the return value
1333 This target hook should return the mode to be used for the shift count operand
1366 This target hook returns @code{true} if bit-fields in the given
1375 another bit-field of nonzero size.  If this hook returns @code{true},
1402 This hook is called just before expansion into rtl, allowing the target
1411 This hook allows the backend to perform additional instantiations on rtl
1417 uses should be mangled differently from the default, define this hook
1420 the type to be mangled.  The hook may be applied to trees which are
1439 This hook is applied to types prior to typedef resolution.  If the mangled
1444 The default version of this hook always returns @code{NULL}, which is
1598 hook and should be defined if that hook is overriden to be true.  It
1642 This target hook should return true if the compiler should give an
1932 This hook may conditionally modify five variables
2199 This target hook should return @code{true} if it is OK to use a hard register
2205 The default version of this hook always returns @code{true}.
2532 …hook that places additional preference on the register class to use when it is necessary to rename…
2536 A target hook that places additional restrictions on the register class
2541 The default version of this hook always returns value of @code{rclass} argument.
2610 The default version of this hook always returns value of @code{rclass}
2660 For input reloads, this target hook is called with nonzero @var{in_p},
2663 hook is called with zero @var{in_p}, and a register of class @var{reload_class}
2667 an intermediate register, the hook @code{secondary_reload} should
2688 hook will be called again to determine how to copy the intermediate
2689 register to/from the reload operand @var{x}, so your hook must also
2697 @c   constraints, or we need a new target macro / hook that tells us if an
2699 @c   Such a macro / hook would also be useful in other places.]
2711 @code{copy_cost} also uses this target hook to find out how values are
2722 These macros are obsolete, new ports should use the target hook
2726 target hook.  Older ports still define these macros to indicate to the
2825 A target hook which returns @code{true} if pseudos that have been assigned
2829 The default version of this target hook returns @code{true} if @var{rclass}
2831 default should be used.  Only use this target hook to some other expression
2833 hard registers were needed for spill registers.  If this target hook returns
2837 you should not change the implementation of this target hook since
2843 A target hook returns the maximum number of consecutive registers
2848 @var{mode})} target hook should be the maximum value of
2852 This target hook helps control the handling of multiple-word values
2855 The default version of this target hook returns the size of @var{mode}
3181 This target hook should return an rtx that is used to store
3184 machines.  One reason you may need to define this target hook is if
3248 This target hook allows the backend to emit frame-related insns that
3640 defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
3644 This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for
3650 The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.
3652 If the static chain is passed in memory, this hook should be used to
3746 This target hook should return @code{true} if a function must have and use
3747 a frame pointer.  This target hook is called in the reload pass.  If its return
3750 This target hook can in principle examine the current function and decide
3812 This target hook should returns @code{true} if the compiler is allowed to
3814 @var{to_reg}.  This target hook need only be defined if @code{ELIMINABLE_REGS}
3839 This target hook returns @code{true} if an argument declared in a
3938 This target hook returns the number of bytes of its own arguments that
4030 The last time this hook is called, it is called with @code{MODE ==
4043 You may use the hook @code{targetm.calls.must_pass_in_stack}
4053 This target hook should return @code{true} if we should not pass @var{type}
4060 Define this hook if the target machine has ``register windows'', so
4076 This target hook returns the number of bytes at the beginning of an
4095 This target hook should return @code{true} if an argument at the
4100 If the hook returns true, a copy of that argument is made in memory and a
4107 The function argument described by the parameters to this hook is
4108 known to be passed by reference.  The hook should return true if the
4112 For any argument for which the hook returns true, if it can be
4116 The default version of this hook always returns false.
4186 This hook updates the summarizer variable pointed to by @var{ca} to
4192 This hook need not do anything if the argument in question was passed
4212 target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}.  It is
4241 This hook returns the alignment boundary, in bits, of an argument
4242 with the specified mode and type.  The default hook returns
4248 which is the default value for this hook.  You can define this hook to
4263 This hook should return true if parameter of type @var{type} are passed
4271 The default value of this hook is @code{NULL}, which is treated as always
4276 This hook returns a type node for @code{va_list} for the target.
4277 The default version of the hook returns @code{void*}.
4281 This target hook is used in function @code{c_common_nodes_and_builtins}
4295 This hook returns the va_list type of the calling convention specified by
4297 The default version of this hook returns @code{va_list_type_node}.
4301 This hook returns the va_list type of the calling convention specified by the
4307 This hook performs target-specific gimplification of
4316 hook returns true for both @code{ptr_mode} and @code{Pmode}.
4320 …s with the system C library errno location.  The default  version of this hook assumes the system …
4329 The default version of this hook returns true for any mode
4347 One use of this hook is to support vector load and store operations
4364 If this hook allows @code{val} to have a scalar mode, then
4371 small register classes.  If this target hook returns nonzero for a given
4373 in @var{mode}.  The hook may be called with @code{VOIDmode} as argument.
4374 In this case, the hook is expected to return nonzero if it returns nonzero
4390 strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P}
4393 The default version of this hook returns false for any mode.  It is always
4394 safe to redefine this hook to return with a nonzero value.  But if you
4396 that can be performed in some cases.  If you do not define this hook
4420 function being called.  If @var{outgoing} is false, the hook should
4422 Otherwise, the hook should return an RTX representing the place where
4474 Define this hook if the back-end needs to know the name of the libcall
4478 library function is given by @var{fun}.  The hook should return an RTX
4481 If this hook is not defined, then LIBCALL_VALUE will be used.
4506 A target hook that return @code{true} if @var{regno} is the number of a hard
4511 recognized by this target hook.
4514 function use different registers for the return value, this target hook
4517 If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used.
4527 This hook should return true if values of type @var{type} are returned
4557 This target hook should return a nonzero value to say to return the
4566 possible to leave the hook undefined; this causes a default
4570 Do not use this hook to indicate that structures and unions should always
4581 target hook.
4587 This target hook should return the location of the structure value
4591 hook if the address is always passed as an ``invisible'' first
4622 This target hook returns the mode to be used when accessing raw return registers in @code{__builtin…
4626 This target hook returns the mode to be used when accessing raw argument registers in @code{__built…
4963 during PIC compilation.  The hook is used to enforce these restrictions,
4971 function.  This hook only needs to be defined to provide registers that
4979 This hook should add additional registers that are computed by the prologue to the hard regset for …
4987 This hook returns a @code{DECL} node for the external variable to use
4993 The default version of this hook creates a variable called
4998 This hook returns a tree expression that alerts the runtime that the
5002 The default version of this hook invokes a function called
5008 … splitting the stack in some configurations.  The default version of this hook returns false.  If …
5039 control of the target hook @code{TARGET_EXPAND_BUILTIN_SAVEREGS}.  On
5080 If defined, this hook produces the machine-specific code for a call to
5088 This target hook offers an alternative to using
5089 @code{__builtin_saveregs} and defining the hook
5101 The target hook should do two things: first, push onto the stack all the
5117 end of the source file.  The hook @code{TARGET_SETUP_INCOMING_VARARGS} should
5122 Define this hook to return @code{true} if the location where a function
5125 This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}
5126 is set for varargs and stdarg functions.  If this hook returns
5133 You need not define this hook if it always returns @code{false}.
5140 defined, then define this hook to return @code{true} if
5142 Otherwise, you should not define this hook.
5174 This hook is called by @code{assemble_trampoline_template} to output,
5179 If you do not define this hook, it means no template is needed
5180 for the target.  Do not define this hook on systems where the block move
5202 This hook is called to initialize a trampoline.
5209 first thing this hook should do is emit a block move into @var{m_tramp}
5221 This hook should perform any machine-specific adjustment in
5227 If this hook is not defined, @var{addr} will be used for function calls.
5289 This hook should declare additional library routines or rename
5295 The default is to do nothing.  Most ports don't need to define this hook.
5475 target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information
5483 this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro.  This macro
5500 Using the hook is usually simpler because it limits the number of
5529 This hook is given an invalid memory address @var{x} for an
5538 The code of the hook should not alter the substructure of
5542 It is not necessary for this hook to come up with a legitimate address.
5544 is safe to omit this hook or make it return @var{x} if it cannot find
5599 This hook returns @code{true} if memory address @var{addr} can have
5611 The default version of this hook returns @code{false}.
5629 @code{TARGET_MODE_DEPENDENT_ADDRESS_P} target hook.
5633 This hook returns true if @var{x} is a legitimate constant for a
5641 This hook is used to undo the possibly obfuscating effects of the
5645 addressing modes.  This target hook allows GCC's optimizers to understand
5651 This hook should return true if @var{x} should not be emitted into
5656 This hook should return true if @var{x} is of a form that cannot (or
5660 The default version of this hook returns false.
5662 The primary reason to define this hook is to prevent reload from
5670 This hook should return true if pool entries for constant @var{x} can
5678 This hook should return the DECL of a function that implements reciprocal of
5688 This hook should return the DECL of a function @var{f} that given an
5705 If this hook is defined, the autovectorizer will generate a call
5706 to @var{f} (using the DECL tree that this hook returns) and will
5711 If this hook is not defined, then @var{addr} will be used as
5717 This hook should return the DECL of a function @var{f} that implements
5720 If this hook is defined, the autovectorizer will use it along with the
5721 @code{TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD} target hook when vectorizing
5728 This hook should return the DECL of a function @var{f} that implements
5731 If this hook is defined, the autovectorizer will use it along with the
5732 @code{TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN} target hook when vectorizing
5753 This hook should return the DECL of a function that implements conversion of the
5759 If this hook is defined, the autovectorizer will use the
5760 @code{TARGET_VECTORIZE_BUILTIN_CONVERSION} target hook when vectorizing
5765 This hook should return the decl of a function that implements the
5774 This hook should return true if the target supports misaligned vector
5782 This hook should return the preferred mode for vectorizing scalar
5789 This hook should return a mask of sizes that should be iterated over
5796 This hook should return the built-in decl needed to load a vector of the given type within a transa…
5800 This hook should return the built-in decl needed to store a vector of the given type within a trans…
5862 The hook is called with the assembly output position set to the beginning
5865 If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses
5867 If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition
5877 intercept this hook to handle things like target-specific attributes
6104 hard register is set to a common value.  Use this hook to enable a
6105 small pass which optimizes such cases.  This hook should return true
6112 The default version of this hook returns false.
6119 target hook to take two mode arguments and to return a mode in which
6123 The default version of this hook checks whether the modes are the
6178 These macros are obsolete, new ports should use the target hook
6183 This target hook should return the cost of moving data of mode @var{mode}
6226 These macros are obsolete, new ports should use the target hook
6231 This target hook should return the cost of moving data of mode @var{mode}
6236 registers, you should add this target hook to express the relative cost.
6238 If you do not add this target hook, GCC uses a default cost of 4 plus
6242 more complex than copying via an intermediate, use this target hook to
6249 4 is not correct for your machine, use this target hook to add some other
6251 are the same as to this target hook.
6438 This target hook describes the relative costs of RTL expressions.
6443 That is, the hook can assume that there is some rtx @var{y} such
6451 In implementing this hook, you can use the construct
6455 On entry to the hook, @code{*@var{total}} contains a default estimate
6456 for the cost of the expression.  The hook should modify this value as
6462 false, this target hook should be used to estimate the relative
6465 The hook returns true when all subexpressions of @var{x} have been
6470 This hook computes the cost of an addressing mode that contains
6472 the @var{address} expression and the @code{TARGET_RTX_COST} hook.
6492 This hook is never called with an invalid address.
6513 This hook returns the maximum number of instructions that can ever
6525 This hook is executed by the scheduler after it has scheduled an insn
6530 You should define this hook if some insns take more machine resources
6549 acceptable, you could use the hook to modify them too.  See also
6554 This hook adjusts the integer scheduling priority @var{priority} of
6557 later.  Do not define this hook if you do not need to adjust the
6562 This hook is executed by the scheduler after it has scheduled the ready
6584 this hook can be useful if there are frequent situations where
6590 This hook is called after evaluation forward dependencies of insns in
6594 analysis of dependencies.  This hook can use backward and forward
6600 This hook is executed by the scheduler at the beginning of each block of
6610 This hook is executed by the scheduler at the end of each block of
6619 This hook is executed by the scheduler after function level initializations.
6626 This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.
6632 The hook returns an RTL insn.  The automaton state used in the
6634 when the new simulated processor cycle starts.  Usage of the hook may
6636 processors.  If the hook is defined, it is used only for the automaton
6642 The hook can be used to initialize data used by the previous hook.
6646 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
6652 The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but
6653 used to initialize data used by the previous hook.
6657 The hook to notify target that the current simulated cycle is about to finish.
6658 The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used
6664 The hook to notify target that new simulated cycle has just started.
6665 The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used
6671 This hook controls better choosing an insn from the ready insn queue
6673 chooses the first insn from the queue.  If the hook returns a positive
6701 This hook controls what insns from the ready insn queue will be
6702 considered for the multipass insn scheduling.  If the hook returns
6710 This hook prepares the target backend for a new round of multipass
6715 This hook is called when multipass scheduling evaluates instruction INSN.
6724 This hook notifies the target about the result of the concluded current
6729 This hook initializes target-specific data used in multipass scheduling.
6733 This hook finalizes target-specific data used in multipass scheduling.
6737 This hook is called by the insn scheduler before issuing @var{insn}
6738 on cycle @var{clock}.  If the hook returns nonzero,
6750 This hook is used to define which dependences are considered costly by
6753 to this hook are as follows:  The first parameter @var{_dep} is the dependence
6757 The hook returns @code{true} if considering the distance between the two
6761 Defining this hook can be useful in multiple-issue out-of-order machines,
6771 This hook is called by the insn scheduler after emitting a new instruction to
6772 the instruction stream.  The hook notifies a target backend to extend its
6799 This hook is called by the insn scheduler when @var{insn} has only
6801 The hook is used to check if the pattern of @var{insn} has a speculative
6803 pattern.  The hook should return 1, if the instruction has a speculative form,
6810 This hook is called by the insn scheduler during generation of recovery code
6816 This hook is called by the insn scheduler to generate a pattern for recovery
6827 This hook is used as a workaround for
6829 called on the first instruction of the ready list.  The hook is used to
6831 being scheduled on the current cycle.  If the hook returns @code{false},
6834 the hook should always return @code{true}.  For example, in the ia64 backend
6835 the hook is used to cancel data speculative insns when the ALAT table
6840 This hook is used by the insn scheduler to find out what features should be
6847 This hook is called by the swing modulo scheduler to calculate a
6851 bound will be used in case this hook is not implemented: the total number
6856 This hook is called by Haifa Scheduler.  It returns true if dispatch scheduling
6861 This hook is called by Haifa Scheduler.  It performs the operation specified
6872 This hook is called by tree reassociator to determine a level of
6902 should define the @code{TARGET_ASM_INIT_SECTIONS} hook and use
7052 Define this hook if you need to do something special to set up the
7056 GCC calls this hook after processing the command line, but before writing
7068 is in effect, and 0 otherwise.  The hook is typically redefined
7140 Define this hook if you need to postprocess the assembler name generated
7141 by target-independent code.  The @var{id} provided to this hook will be
7144 hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on
7145 your target system.  The default implementation of this hook just
7150 Define this hook if references to a symbol or a constant must be
7154 The hook is executed immediately after rtl has been created for
7158 in this hook; that field may not have been initialized yet.
7171 declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}.
7172 @var{new_decl_p} is always true when the hook is called for a constant.
7175 The usual thing for this hook to do is to record flags in the
7181 The default definition of this hook, @code{default_encode_section_info}
7195 The default version of this hook always returns false.
7206 The default version of this hook use the target macro
7215 The default version of this hook implements the name resolution rules
7233 generate valid PIC; you must also add support to the hook
7308 @code{default_file_start} at some point in your target hook.  This
7343 need to do other things in that hook, have your hook function call
7368 A C string constant describing how to begin a comment in the target
7369 assembler language.  The compiler assumes that the comment will end at
7376 @code{"#APP"}, which is a comment that has no effect on most
7400 …This target hook need not be defined if the standard form of output for the file format in use is …
7483 target hook that either recording is starting or ending.  The first
7486 wind down.  This feature is to allow the target hook to make any
7492 This option can be ignored by this target hook.
7495 This option can be ignored by this target hook.
7498 The hook's return value must be zero.  Other return values may be
7501 By default this hook is set to NULL, but an example implementation is
7506 hook.
7512 hook.
7541 The @code{assemble_integer} function uses this hook to output an
7548 The default implementation of this hook will use the
7554 A target hook to recognize @var{rtx} patterns that @code{output_addr_const}
7559 If target hook fails to recognize a pattern, it must return @code{false},
7933 A target hook to output to the stdio stream @var{file} any text necessary
7935 target hook is responsible for outputting the label definition (perhaps using
7940 The default version of this target hook, define the @var{name} in the
7943 You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook.
7970 This target hook is a function to output to the stdio stream
7979 This target hook is a function to output to the stdio stream
7983 The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.
8056 This target hook is a function to output to @var{asm_out_file} some
8092 This target hook is a function to output to @var{asm_out_file} an assembler
8098 This target hook is a function to output to @var{asm_out_file} an assembler
8112 ….  The default implementation calls the @code{TARGET_STRIP_NAME_ENCODING} hook and then prepends t…
8629 If defined, this target hook is a function which is executed just after the
8681 section that the address refers to.  On these machines, define the hook
8847 This target hook emits a label at the beginning of each FDE@.  It
8859 This target hook emits a label at the beginning of the exception table.
8867 …GET_ASM_UNWIND_EMIT}, this hook may be used to emit a directive to install a personality hook into…
8871 This target hook emits assembly directives required to unwind the
8877 …@code{TARGET_ASM_UNWIND_EMIT} hook should be called before the assembly for @var{insn} has been em…
8929 This hook defines the mechanism that will be used for exception handling
8930 by the target.  If the target has ABI specified unwind tables, the hook
8932 @code{setjmp}/@code{longjmp}-based exception handling scheme, the hook
8934 information, the hook should return @code{UI_DWARF2}.
8938 default implementation of this hook never returns @code{UI_NONE}.
8940 Note that the value returned by this hook should be constant.  It should
8947 The default implementation of the hook first honors the
8951 must define this hook so that @var{opts} is used correctly.
8983 Given a register, this hook should return a parallel of registers to
8984 represent where to find the register pieces.  Define this hook if the
8987 register in Dwarf.  Otherwise, this hook should return @code{NULL_RTX}.
8993 multiple pieces, define this hook to fill in information about the
9001 This hook is used to output a reference from a frame unwinding table to
9371 @code{.stabs "",N_FUN,,0,0,Lscope-function-1} gdb dbx extension construct.
9373 disturbing the rest of the gdb extensions.
9377 Some assemblers cannot handle the @code{.stabd BNSYM/ENSYM,0,0} gdb dbx
9379 feature off without disturbing the rest of the gdb extensions.
9470 This hook defines the mechanism that will be used for describing frame
9471 unwind information to the debugger.  Normally the hook will return
9534 If defined, this target hook is a function which outputs a DTP-relative
9794 If defined, this target hook points to an array of @samp{struct
9802 If defined, this target hook is a function which returns true if the
9810 If defined, this target hook is a function which returns zero if the attributes on
9818 If defined, this target hook is a function which assigns default attributes to
9823 Define this target hook if the merging of type attributes needs special
9832 Define this target hook if the merging of decl attributes needs special
9854 …e or function with @code{__attribute__((dllimport))} specified.  Use this hook if the target needs…
9867 Define this target hook if you want to be able to add attributes to a decl
9881 This target hook returns @code{true} if it is ok to inline @var{fndecl}
9888 This hook is called to parse the @code{attribute(option("..."))}, and
9891 options specified on the command line.  The hook should return
9894 The hook should set the @var{DECL_FUNCTION_SPECIFIC_TARGET} field in
9900 This hook is called to save any additional target specific information
9907 This hook is called to restore any additional target specific
9913 This hook is called to print any additional target specific
9919 This target hook parses the options for @code{#pragma GCC option} to
9922 @code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook.
9927 a particular target machine.  You can override the hook
9931 Don't use this hook to turn on various extra optimizations for
9940 This target hook returns @code{false} if the @var{caller} function
10069 This hook returns a pointer to the data needed by
10075 This hook checks whether the options used to create a PCH file are
10090 If this hook is nonnull, the default implementation of
10100 it can use this hook to enforce that state.  Very few targets need
10109 Define this hook to override the integer type used for guard variables.
10115 This hook determines how guard variables are used.  It should return
10121 This hook returns the size of the cookie to use when allocating an array
10129 This hook should return @code{true} if the element size should be stored in
10134 If defined by a backend this hook allows the decision made to export
10143 This hook should return @code{true} if constructors and destructors return
10149 This hook returns true if the key method for a class (i.e., the method
10159 …to specify a visibility other than that of the containing class, use this hook to set @code{DECL_V…
10163 This hook returns true (the default) if virtual tables and other
10165 external linkage.  If this hook returns false, then class data for
10171 This hook returns true (the default) if the RTTI information for
10177 This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI)
10183 This hook returns true if the target @code{atexit} function can be used
10191 …s (i.e., RECORD_TYPE or UNION_TYPE) that has just been defined.  Use this hook to make adjustments…
10239 The default version of this hook returns @code{ptr_mode} for the
10246 The default version of this hook returns @code{Pmode} for the
10253 hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,
10255 version of this hook returns true for the modes returned by either the
10264 finished.  This target hook is the same as the
10265 @code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes
10272 hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,
10289 to a different named address space.  When this hook it called, it is
10291 as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.
10406 the reciprocal.  This target hook specifies the minimum number of divisions
10719 defining the target hook @samp{TARGET_INSERT_ATTRIBUTES} as well.
10836 This target hook should add to @var{clobbers} @code{STRING_CST} trees for
10930 If non-null, this hook performs a target-specific pass over the
10934 The exact purpose of the hook varies from target to target.  Some use
10939 You need not implement the hook if it has nothing to do.  The default
10944 Define this hook if you have any machine-specific built-in functions
10962 Define this hook if you have any machine-specific built-in functions
11029 This target hook returns @code{true} if @var{x} is considered to be commutative.
11050 You may use @code{current_function_leaf_function} in the hook, functions
11053 The default value of this hook is @code{NULL}, which disables any special
11058 This target hook returns nonzero if @var{x}, an @code{unspec} or
11060 this hook to enhance precision of analysis for @code{unspec} and
11067 The compiler invokes this hook whenever it changes its current function
11075 The default hook function does nothing.
11078 some parts of the back end.  The hook function is not invoked in this
11079 situation; you need not worry about the hook being invoked recursively,
11123 This target hook returns @code{true} past the point in which new jump
11126 reload, so this target hook should be defined to a function such as:
11138 This target hook returns a register class for which branch target register
11148 that are not already live during the current function; if this target hook
11160 This target hook returns true if the target supports conditional execution.
11161 This target hook is required only when the target has several different
11166 This target hook returns a new value for the number of times @var{loop}
11169 the loop, which is going to be checked for unrolling. This target hook
11185 This target hook should register any extra include files for the
11192 This target hook should register any extra include files for the
11200 This target hook should register special include paths for the target.
11294 If defined, this target hook returns the type to which values of
11297 front end's normal promotion rules.  This hook is useful when there are
11303 If defined, this hook returns the result of converting @var{expr} to
11306 This hook is useful when there are target-specific types with special
11335 This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a
11342 When optimization is disabled, this hook indicates whether or not
11348 to the stack.  Therefore, this hook should return true in general, but