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
415 indicates an absolute file name.
497 Each array element should have four elements: the directory name (a
498 string constant), the component name (also a string constant), a flag
504 The component name denotes what GNU package the include file is part of,
507 operating system, code the component name as @samp{0}.
564 (or port-specific name; native only, cross compilers do not use this).
624 @code{builtin_define_std} takes a string representing the name of an
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
1419 mangled name.  The @var{type} argument is the tree structure representing
1420 the type to be mangled.  The hook may be applied to trees which are
1428 fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}
1429 is the name used for the type in source code, and @var{n} is the
1430 length of @var{name} in decimal.  Encode qualified versions of
1431 ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where
1432 @var{name} is the name used for the type qualifier in source code,
1433 @var{n} is the length of @var{name} as above, and @var{code} is the
1439 This hook is applied to types prior to typedef resolution.  If the mangled
1440 name for a particular type depends only on that type's main variant, you
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
1600 prefix for their name rather than the default @code{__}.  A port which
1642 This target hook should return true if the compiler should give an
1651 A C expression for a string describing the name of the data type to use
1652 for size values.  The typedef name @code{size_t} is defined using the
1668 A C expression for a string describing the name of the data type to use
1669 for the result of subtracting two pointers.  The typedef name
1677 A C expression for a string describing the name of the data type to use
1678 for wide characters.  The typedef name @code{wchar_t} is defined using
1692 A C expression for a string describing the name of the data type to
1694 @code{getwc}.  The typedef name @code{wint_t} is defined using the
1702 A C expression for a string describing the name of the data type that
1704 The typedef name @code{intmax_t} is defined using the contents of the
1713 A C expression for a string describing the name of the data type that
1715 type.  The typedef name @code{uintmax_t} is defined using the contents
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}.
2326 You define a number of register classes, giving each one a name and saying
2339 terribly special about the name, but the operand constraint letters
2395 the class name to type @code{int}.  The number serves as an index
2435 A macro whose definition is the name of the class to which a valid
2466 A macro whose definition is the name of the class to which a valid
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
2693 @c   the port maintainer could name a mov<mode> pattern that has clobbers -
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
3957 a function used to perform arithmetic, whose name is known specially
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.
4158 contains the name of the function, as a string.  @var{libname} is 0 when
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}
4287 this macro and are set to the name of the va_list builtin type and its
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
4468 support routine, used to perform arithmetic, whose name is known
4473 @deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode @var{mode}, const_rtx @var{fun…
4474 Define this hook if the back-end needs to know the name of the libcall
4477 The mode of the result is given by @var{mode} and the name of the called
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…
4733 instruction the name @samp{return} and do not define the macro
4928 variable to be loaded into some register.  The name of this variable is
4930 the name using @samp{LP%d} in a @code{fprintf}.
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
6922 If defined, a C string constant for the name of the section containing most
6928 If defined, a C string constant for the name of the section containing unlikely
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
7097 Build up a unique section name, expressed as a @code{STRING_CST} node,
7102 The default version of this function appends the symbol name to the
7103 ELF section name that would normally be used for the symbol.  For
7111 The default version of this function selects @code{.gnu.linkonce.r.name} if
7112 the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name}
7113 if function is in @code{.text.name}, and the normal readonly-data section
7120 the string if a different section name should be used.
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
7142 the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C,
7143 or the mangled name of the @var{decl} in C++).  The return value of the
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
7177 Historically, the name string was modified if it was necessary to
7181 The default definition of this hook, @code{default_encode_section_info}
7187 @deftypefn {Target Hook} {const char *} TARGET_STRIP_NAME_ENCODING (const char *@var{name})
7188 Decode @var{name} and return the real name part, sans
7195 The default version of this hook always returns false.
7206 The default version of this hook use the target macro
7211 Returns true if @var{exp} names an object for which name resolution
7215 The default version of this hook implements the name resolution rules
7216 for ELF, which has a looser model of global name binding than other
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
7388 @defmac ASM_OUTPUT_SOURCE_FILENAME (@var{stream}, @var{name})
7390 which indicates that filename @var{name} is the current source file to
7397 …efn {Target Hook} void TARGET_ASM_OUTPUT_SOURCE_FILENAME (FILE *@var{file}, const char *@var{name})
7398 Output COFF information or DWARF debugging information which indicates that filename @var{name} is …
7400 …This target hook need not be defined if the standard form of output for the file format in use is …
7417 @deftypefn {Target Hook} void TARGET_ASM_NAMED_SECTION (const char *@var{name}, unsigned int @var{f…
7418 Output assembly directives to switch to section @var{name}.  The section
7451 …{unsigned int} TARGET_SECTION_TYPE_FLAGS (tree @var{decl}, const char *@var{name}, int @var{reloc})
7453 based on a variable or function decl, a section name, and whether or not the
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
7504 section in the assembler output file.  The name of the new section is
7506 hook.
7510 This is the name of the section that will be created by the example
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},
7594 the name of the function.  Should the return type of the function
7633 pool for a function.  @var{funname} is a string giving the name of the
7690 @defmac ASM_OUTPUT_COMMON (@var{stream}, @var{name}, @var{size}, @var{rounded})
7693 @var{name} whose size is @var{size} bytes.  The variable @var{rounded}
7703 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7704 output the name itself; before and after that, output the additional
7705 assembler syntax for defining the name, and a newline.
7711 @defmac ASM_OUTPUT_ALIGNED_COMMON (@var{stream}, @var{name}, @var{size}, @var{alignment})
7719 @defmac ASM_OUTPUT_ALIGNED_DECL_COMMON (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{alig…
7728 @defmac ASM_OUTPUT_ALIGNED_BSS (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{alignment})
7731 @var{name} whose size is @var{size} bytes.  The variable @var{alignment}
7736 @code{assemble_name (@var{stream}, @var{name})} to output the name itself;
7738 the name, and a newline.
7752 @defmac ASM_OUTPUT_LOCAL (@var{stream}, @var{name}, @var{size}, @var{rounded})
7755 @var{name} whose size is @var{size} bytes.  The variable @var{rounded}
7758 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7759 output the name itself; before and after that, output the additional
7760 assembler syntax for defining the name, and a newline.
7766 @defmac ASM_OUTPUT_ALIGNED_LOCAL (@var{stream}, @var{name}, @var{size}, @var{alignment})
7774 @defmac ASM_OUTPUT_ALIGNED_DECL_LOCAL (@var{stream}, @var{decl}, @var{name}, @var{size}, @var{align…
7790 @defmac ASM_OUTPUT_LABEL (@var{stream}, @var{name})
7792 @var{stream} the assembler definition of a label named @var{name}.
7793 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7794 output the name itself; before and after that, output the additional
7795 assembler syntax for defining the name, and a newline.  A default
7799 @defmac ASM_OUTPUT_FUNCTION_LABEL (@var{stream}, @var{name}, @var{decl})
7801 @var{stream} the assembler definition of a label named @var{name} of
7803 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
7804 output the name itself; before and after that, output the additional
7805 assembler syntax for defining the name, and a newline.  A default
7808 If this macro is not defined, then the function name is defined in the
7813 @defmac ASM_OUTPUT_INTERNAL_LABEL (@var{stream}, @var{name})
7814 Identical to @code{ASM_OUTPUT_LABEL}, except that @var{name} is known
7833 @defmac ASM_OUTPUT_SIZE_DIRECTIVE (@var{stream}, @var{name}, @var{size})
7836 symbol @var{name} is @var{size}.  @var{size} is a @code{HOST_WIDE_INT}.
7841 @defmac ASM_OUTPUT_MEASURED_SIZE (@var{stream}, @var{name})
7844 the symbol @var{name} by subtracting its address from the current
7882 symbol @var{name} is @var{type}.  @var{type} is a C string; currently,
7890 @defmac ASM_DECLARE_FUNCTION_NAME (@var{stream}, @var{name}, @var{decl})
7892 @var{stream} any text necessary for declaring the name @var{name} of a
7898 If this macro is not defined, then the function name is defined in the
7905 @defmac ASM_DECLARE_FUNCTION_SIZE (@var{stream}, @var{name}, @var{decl})
7908 which is being defined.  The argument @var{name} is the name of the
7918 @defmac ASM_DECLARE_OBJECT_NAME (@var{stream}, @var{name}, @var{decl})
7920 @var{stream} any text necessary for declaring the name @var{name} of an
7925 If this macro is not defined, then the variable name is defined in the
7932 …void TARGET_ASM_DECLARE_CONSTANT_NAME (FILE *@var{file}, const char *@var{name}, const_tree @var{e…
7933 A target hook to output to the stdio stream @var{file} any text necessary
7934 for declaring the name @var{name} of a constant which is being defined.  This
7935 target hook is responsible for outputting the label definition (perhaps using
7937 and @var{size} is the size of the constant in bytes.  The @var{name}
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.
7946 @defmac ASM_DECLARE_REGISTER_GLOBAL (@var{stream}, @var{decl}, @var{regno}, @var{name})
7949 for a global variable @var{decl} with name @var{name}.
7956 A C statement (sans semicolon) to finish up declaring a variable name
7969 @deftypefn {Target Hook} void TARGET_ASM_GLOBALIZE_LABEL (FILE *@var{stream}, const char *@var{name…
7970 This target hook is a function to output to the stdio stream
7971 @var{stream} some commands that will make the label @var{name} global;
7979 This target hook is a function to output to the stdio stream
7980 @var{stream} some commands that will make the name associated with @var{decl}
7983 The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.
7986 @defmac ASM_WEAKEN_LABEL (@var{stream}, @var{name})
7988 @var{stream} some commands that will make the label @var{name} weak;
7991 @code{assemble_name (@var{stream}, @var{name})} to output the name
7993 for making that name weak, and a newline.
8000 @defmac ASM_WEAKEN_DECL (@var{stream}, @var{decl}, @var{name}, @var{value})
8005 defines (equates) the weak symbol @var{name} to have the value
8007 to make @var{name} weak.
8010 @defmac ASM_OUTPUT_WEAKREF (@var{stream}, @var{decl}, @var{name}, @var{value})
8011 Outputs a directive that enables @var{name} to be used to refer to
8013 declaration of @code{name}.
8056 This target hook is a function to output to @var{asm_out_file} some
8080 @defmac ASM_OUTPUT_EXTERNAL (@var{stream}, @var{decl}, @var{name})
8082 @var{stream} any text necessary for declaring the name of an external
8083 symbol named @var{name} which is referenced in this compilation but
8092 This target hook is a function to output to @var{asm_out_file} an assembler
8093 pseudo-op to declare a library function name external.  The name of the
8098 This target hook is a function to output to @var{asm_out_file} an assembler
8103 @defmac ASM_OUTPUT_LABELREF (@var{stream}, @var{name})
8106 @var{name}.  This should add @samp{_} to the front of the name, if that
8111 @deftypefn {Target Hook} tree TARGET_MANGLE_ASSEMBLER_NAME (const char *@var{name})
8112 …name}, perform same mangling as @code{varasm.c}'s @code{assemble_name}, but in memory rather than …
8118 will be used to output the name of the symbol.  This macro may be used
8126 @code{assemble_name} will be used to output the name of the symbol.
8135 name is made from the string @var{prefix} and the number @var{labelno}.
8139 will have name conflicts with internal labels.
8152 label whose name is made from the string @var{prefix} and the number
8164 A C statement to store into the string @var{string} a label whose name
8180 @defmac ASM_FORMAT_PRIVATE_NAME (@var{outvar}, @var{name}, @var{number})
8183 @var{name} and the number @var{number}, with some suitable punctuation
8187 produce an assembler label for an internal static variable whose name is
8188 @var{name}.  Therefore, the string must be such as to result in valid
8196 between the name and the number will suffice.
8202 @defmac ASM_OUTPUT_DEF (@var{stream}, @var{name}, @var{value})
8204 which defines (equates) the symbol @var{name} to have the value @var{value}.
8232 @defmac ASM_OUTPUT_WEAK_ALIAS (@var{stream}, @var{name}, @var{value})
8234 which defines (equates) the weak symbol @var{name} to have the value
8235 @var{value}.  If @var{value} is @code{NULL}, it defines @var{name} as
8246 The default name is a unique method number followed by the name of the
8247 class (e.g.@: @samp{_1_Foo}).  For methods in categories, the name of
8248 the category is also included in the assembler name (e.g.@:
8252 the method's selector is not present in the name.  Therefore, particular
8256 buffer in which to store the name; its length is as long as
8261 method or a class method; @var{class_name} is the name of the class;
8262 @var{cat_name} is the name of the category (or @code{NULL} if the method is not
8263 in a category); and @var{sel_name} is the name of the selector.
8364 entry of type @samp{N_SETT}, referencing the name @code{__CTOR_LIST__},
8504 Define this macro as a C string constant containing the file name to use
8523 Define this macro to a C string constant containing the name of the program
8557 If defined, a C initializer for an array of structures containing a name
8565 name, a register number and a count of the number of consecutive
8566 machine registers the name overlaps.  This macro defines additional
8570 register name implies multiple underlying registers.
8574 register name.  For example, on ARM, clobbering the double-precision
8586 points to the opcode name in its ``internal'' form---the form that is
8588 opcode name to @var{stream}, performing any translation you desire, and
8593 name, or more than the opcode name; but if you want to process text
8629 If defined, this target hook is a function which is executed just after the
8655 If @var{x} is a register, this macro should print the register's name.
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…
8889 If defined, a C string constant for the name of the section containing
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
9249 name.  If you don't define this macro, @code{"\t.stabn\t"} is used.  This
9261 A symbol name in DBX-format debugging information is normally
9342 @defmac DBX_OUTPUT_LBRAC (@var{stream}, @var{name})
9345 argument @var{name} is the name of an assembler symbol (for use with
9349 @defmac DBX_OUTPUT_RBRAC (@var{stream}, @var{name})
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.
9388 @defmac DBX_OUTPUT_MAIN_SOURCE_FILENAME (@var{stream}, @var{name})
9390 @var{stream}, which indicates that file @var{name} is the main source
9416 @defmac DBX_OUTPUT_MAIN_SOURCE_FILE_END (@var{stream}, @var{name})
9418 compilation of the main source file @var{name}.  Output should be
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
9801 @deftypefn {Target Hook} bool TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P (const_tree @var{name})
9802 If defined, this target hook is a function which returns true if the
9803 machine-specific attribute named @var{name} expects an identifier
9805 subjected to name lookup.  If this is not defined, the default is
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}
9887 @deftypefn {Target Hook} bool TARGET_OPTION_VALID_ATTRIBUTE_P (tree @var{fndecl}, tree @var{name}, …
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
9963 Contains the name of the helper function that uses a TLS control
9969 Contains the name of the helper function that should be used at
9977 Contains the name of the section in which TLS control variables should
9983 Contains the name of the section in which TLS initializers should be
9998 @deftypefn {Target Hook} tree TARGET_EMUTLS_VAR_FIELDS (tree @var{type}, tree *@var{name})
10001 @var{name} should be filled with the structure tag, if the default of
10040 (``c0r1'' is the default name of register 1 in coprocessor 0; alternate
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.
10320 An alias for a machine mode name.  This is the machine mode that
10406 the reciprocal.  This target hook specifies the minimum number of divisions
10719 defining the target hook @samp{TARGET_INSERT_ATTRIBUTES} as well.
10726 @deftypefun void c_register_pragma (const char *@var{space}, const char *@var{name}, void (*@var{ca…
10727 @deftypefunx void c_register_pragma_with_expansion (const char *@var{space}, const char *@var{name}…
10735 #pragma [@var{space}] @var{name} @dots{}
10742 @var{name} by calling @code{pragma_lex}.  Tokens that are not read by the
10755 target entry in the @file{config.gcc} file.  These variables should name
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.
11215 If defined, this macro is the name of a global variable containing
11226 If defined, this macro is the name of a global variable containing
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