diff options
Diffstat (limited to 'gcc/doc/tm.texi.in')
-rw-r--r-- | gcc/doc/tm.texi.in | 2783 |
1 files changed, 0 insertions, 2783 deletions
diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index 667d5d1..fad6d10 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -698,14 +698,6 @@ should use @code{TARGET_HANDLE_C_OPTION} instead. @hook TARGET_CHECK_STRING_OBJECT_FORMAT_ARG @hook TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE -This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE} -but is called when the optimize level is changed via an attribute or -pragma or when it is reset at the end of the code affected by the -attribute or pragma. It is not called at the beginning of compilation -when @code{TARGET_OPTION_OVERRIDE} is called so if you want to perform these -actions then, you should have @code{TARGET_OPTION_OVERRIDE} call -@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}. -@end deftypefn @defmac C_COMMON_OVERRIDE_OPTIONS This is similar to the @code{TARGET_OPTION_OVERRIDE} hook @@ -929,26 +921,6 @@ Do not define this macro if it would never modify @var{m}. @end defmac @hook TARGET_PROMOTE_FUNCTION_MODE -Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or -function return values. The target hook should return the new mode -and possibly change @code{*@var{punsignedp}} if the promotion should -change signedness. This function is called only for scalar @emph{or -pointer} types. - -@var{for_return} allows to distinguish the promotion of arguments and -return values. If it is @code{1}, a return value is being promoted and -@code{TARGET_FUNCTION_VALUE} must perform the same promotions done here. -If it is @code{2}, the returned mode should be that of the register in -which an incoming parameter is copied, or the outgoing result is computed; -then the hook should return the same mode as @code{promote_mode}, though -the signedness may be different. - -@var{type} can be NULL when promoting function arguments of libcalls. - -The default is to not promote arguments and return values. You can -also define the hook to @code{default_promote_function_mode_always_promote} -if you would like to apply the same rules given by @code{PROMOTE_MODE}. -@end deftypefn @defmac PARM_BOUNDARY Normal alignment required for function parameters on the stack, in @@ -1234,31 +1206,10 @@ to aligning a bit-field within the structure. @end defmac @hook TARGET_ALIGN_ANON_BITFIELD -When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine -whether unnamed bitfields affect the alignment of the containing -structure. The hook should return true if the structure should inherit -the alignment requirements of an unnamed bitfield's type. -@end deftypefn @hook TARGET_NARROW_VOLATILE_BITFIELD -This target hook should return @code{true} if accesses to volatile bitfields -should use the narrowest mode possible. It should return @code{false} if -these accesses should use the bitfield container type. - -The default is @code{!TARGET_STRICT_ALIGN}. -@end deftypefn @hook TARGET_MEMBER_TYPE_FORCES_BLK -Return true if a structure, union or array containing @var{field} should -be accessed using @code{BLKMODE}. - -If @var{field} is the only field in the structure, @var{mode} is its -mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the -case where structures of one field would require the structure's mode to -retain the field's mode. - -Normally, this is not needed. -@end deftypefn @defmac ROUND_TYPE_ALIGN (@var{type}, @var{computed}, @var{specified}) Define this macro as an expression for the alignment of a type (given @@ -1303,23 +1254,10 @@ pattern needs to support both a 32- and a 64-bit mode. @end defmac @hook TARGET_LIBGCC_CMP_RETURN_MODE -This target hook should return the mode to be used for the return value -of compare instructions expanded to libgcc calls. If not defined -@code{word_mode} is returned which is the right choice for a majority of -targets. -@end deftypefn @hook TARGET_LIBGCC_SHIFT_COUNT_MODE -This target hook should return the mode to be used for the shift count operand -of shift instructions expanded to libgcc calls. If not defined -@code{word_mode} is returned which is the right choice for a majority of -targets. -@end deftypefn @hook TARGET_UNWIND_WORD_MODE -Return machine mode to be used for @code{_Unwind_Word} type. -The default is to use @code{word_mode}. -@end deftypefn @defmac ROUND_TOWARDS_ZERO If defined, this macro should be true if the prevailing rounding @@ -1343,88 +1281,16 @@ The default definition of this macro returns false for all sizes. @end defmac @hook TARGET_MS_BITFIELD_LAYOUT_P -This target hook returns @code{true} if bit-fields in the given -@var{record_type} are to be laid out following the rules of Microsoft -Visual C/C++, namely: (i) a bit-field won't share the same storage -unit with the previous bit-field if their underlying types have -different sizes, and the bit-field will be aligned to the highest -alignment of the underlying types of itself and of the previous -bit-field; (ii) a zero-sized bit-field will affect the alignment of -the whole enclosing structure, even if it is unnamed; except that -(iii) a zero-sized bit-field will be disregarded unless it follows -another bit-field of nonzero size. If this hook returns @code{true}, -other macros that control bit-field layout are ignored. - -When a bit-field is inserted into a packed record, the whole size -of the underlying type is used by one or more same-size adjacent -bit-fields (that is, if its long:3, 32 bits is used in the record, -and any additional adjacent long bit-fields are packed into the same -chunk of 32 bits. However, if the size changes, a new field of that -size is allocated). In an unpacked record, this is the same as using -alignment, but not equivalent when packing. - -If both MS bit-fields and @samp{__attribute__((packed))} are used, -the latter will take precedence. If @samp{__attribute__((packed))} is -used on a single field when MS bit-fields are in use, it will take -precedence for that field, but the alignment of the rest of the structure -may affect its placement. -@end deftypefn @hook TARGET_DECIMAL_FLOAT_SUPPORTED_P -Returns true if the target supports decimal floating point. -@end deftypefn @hook TARGET_FIXED_POINT_SUPPORTED_P -Returns true if the target supports fixed-point arithmetic. -@end deftypefn @hook TARGET_EXPAND_TO_RTL_HOOK -This hook is called just before expansion into rtl, allowing the target -to perform additional initializations or analysis before the expansion. -For example, the rs6000 port uses it to allocate a scratch stack slot -for use in copying SDmode values between memory and floating point -registers whenever the function being expanded has any SDmode -usage. -@end deftypefn @hook TARGET_INSTANTIATE_DECLS -This hook allows the backend to perform additional instantiations on rtl -that are not actually in any insns yet, but will be later. -@end deftypefn @hook TARGET_MANGLE_TYPE -If your target defines any fundamental types, or any types your target -uses should be mangled differently from the default, define this hook -to return the appropriate encoding for these types as part of a C++ -mangled name. The @var{type} argument is the tree structure representing -the type to be mangled. The hook may be applied to trees which are -not target-specific fundamental types; it should return @code{NULL} -for all such types, as well as arguments it does not recognize. If the -return value is not @code{NULL}, it must point to a statically-allocated -string constant. - -Target-specific fundamental types might be new fundamental types or -qualified versions of ordinary fundamental types. Encode new -fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name} -is the name used for the type in source code, and @var{n} is the -length of @var{name} in decimal. Encode qualified versions of -ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where -@var{name} is the name used for the type qualifier in source code, -@var{n} is the length of @var{name} as above, and @var{code} is the -code used to represent the unqualified version of this type. (See -@code{write_builtin_type} in @file{cp/mangle.c} for the list of -codes.) In both cases the spaces are for clarity; do not include any -spaces in your string. - -This hook is applied to types prior to typedef resolution. If the mangled -name for a particular type depends only on that type's main variant, you -can perform typedef resolution yourself using @code{TYPE_MAIN_VARIANT} -before mangling. - -The default version of this hook always returns @code{NULL}, which is -appropriate for a target that does not define any new fundamental -types. -@end deftypefn @node Type Layout @section Layout of Source Language Data Types @@ -1619,13 +1485,6 @@ and @option{-funsigned-char}. @end defmac @hook TARGET_DEFAULT_SHORT_ENUMS -This target hook should return true if the compiler should give an -@code{enum} type only as many bytes as it takes to represent the range -of possible values of that type. It should return false if all -@code{enum} types should be allocated like @code{int}. - -The default is to return false. -@end deftypefn @defmac SIZE_TYPE A C expression for a string describing the name of the data type to use @@ -1921,36 +1780,6 @@ preserve the entire contents of a register across a call. @findex reg_names @findex reg_class_contents @hook TARGET_CONDITIONAL_REGISTER_USAGE -This hook may conditionally modify five variables -@code{fixed_regs}, @code{call_used_regs}, @code{global_regs}, -@code{reg_names}, and @code{reg_class_contents}, to take into account -any dependence of these register sets on target flags. The first three -of these are of type @code{char []} (interpreted as Boolean vectors). -@code{global_regs} is a @code{const char *[]}, and -@code{reg_class_contents} is a @code{HARD_REG_SET}. Before the macro is -called, @code{fixed_regs}, @code{call_used_regs}, -@code{reg_class_contents}, and @code{reg_names} have been initialized -from @code{FIXED_REGISTERS}, @code{CALL_USED_REGISTERS}, -@code{REG_CLASS_CONTENTS}, and @code{REGISTER_NAMES}, respectively. -@code{global_regs} has been cleared, and any @option{-ffixed-@var{reg}}, -@option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}} -command options have been applied. - -@cindex disabling certain registers -@cindex controlling register usage -If the usage of an entire class of registers depends on the target -flags, you may indicate this to GCC by using this macro to modify -@code{fixed_regs} and @code{call_used_regs} to 1 for each of the -registers in the classes which should not be used by GCC@. Also define -the macro @code{REG_CLASS_FROM_LETTER} / @code{REG_CLASS_FROM_CONSTRAINT} -to return @code{NO_REGS} if it -is called with a letter for a class that shouldn't be used. - -(However, if this class is not included in @code{GENERAL_REGS} and all -of the insn patterns whose constraints permit this class are -controlled by target switches, then GCC will automatically avoid using -these registers when the target switches are opposed to them.) -@end deftypefn @defmac INCOMING_REGNO (@var{out}) Define this macro if the target machine has register windows. This C @@ -2188,14 +2017,6 @@ allocation. @end defmac @hook TARGET_HARD_REGNO_SCRATCH_OK -This target hook should return @code{true} if it is OK to use a hard register -@var{regno} as scratch reg in peephole2. - -One common use of this macro is to prevent using of a register that -is not saved by a prologue in an interrupt handler. - -The default version of this hook always returns @code{true}. -@end deftypefn @defmac AVOID_CCMODE_COPIES Define this macro if the compiler should avoid copies to/from @code{CCmode} @@ -2523,38 +2344,6 @@ only if neither labeling works. @hook TARGET_PREFERRED_RENAME_CLASS @hook TARGET_PREFERRED_RELOAD_CLASS -A target hook that places additional restrictions on the register class -to use when it is necessary to copy value @var{x} into a register in class -@var{rclass}. The value is a register class; perhaps @var{rclass}, or perhaps -another, smaller class. - -The default version of this hook always returns value of @code{rclass} argument. - -Sometimes returning a more restrictive class makes better code. For -example, on the 68000, when @var{x} is an integer constant that is in range -for a @samp{moveq} instruction, the value of this macro is always -@code{DATA_REGS} as long as @var{rclass} includes the data registers. -Requiring a data register guarantees that a @samp{moveq} will be used. - -One case where @code{TARGET_PREFERRED_RELOAD_CLASS} must not return -@var{rclass} is if @var{x} is a legitimate constant which cannot be -loaded into some register class. By returning @code{NO_REGS} you can -force @var{x} into a memory location. For example, rs6000 can load -immediate values into general-purpose registers, but does not have an -instruction for loading an immediate value into a floating-point -register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when -@var{x} is a floating-point constant. If the constant can't be loaded -into any kind of register, code generation will be better if -@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead -of using @code{TARGET_PREFERRED_RELOAD_CLASS}. - -If an insn has pseudos in it after register allocation, reload will go -through the alternatives and call repeatedly @code{TARGET_PREFERRED_RELOAD_CLASS} -to find the best one. Returning @code{NO_REGS}, in this case, makes -reload add a @code{!} in front of the constraint: the x86 back-end uses -this feature to discourage usage of 387 registers when math is done in -the SSE registers (and vice versa). -@end deftypefn @defmac PREFERRED_RELOAD_CLASS (@var{x}, @var{class}) A C expression that places additional restrictions on the register class @@ -2594,15 +2383,6 @@ the SSE registers (and vice versa). @end defmac @hook TARGET_PREFERRED_OUTPUT_RELOAD_CLASS -Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of -input reloads. - -The default version of this hook always returns value of @code{rclass} -argument. - -You can also use @code{TARGET_PREFERRED_OUTPUT_RELOAD_CLASS} to discourage -reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}. -@end deftypefn @defmac LIMIT_RELOAD_CLASS (@var{mode}, @var{class}) A C expression that places additional restrictions on the register class @@ -2621,90 +2401,6 @@ require the macro to do something nontrivial. @end defmac @hook TARGET_SECONDARY_RELOAD -Many machines have some registers that cannot be copied directly to or -from memory or even from other types of registers. An example is the -@samp{MQ} register, which on most machines, can only be copied to or -from general registers, but not memory. Below, we shall be using the -term 'intermediate register' when a move operation cannot be performed -directly, but has to be done by copying the source into the intermediate -register first, and then copying the intermediate register to the -destination. An intermediate register always has the same mode as -source and destination. Since it holds the actual value being copied, -reload might apply optimizations to re-use an intermediate register -and eliding the copy from the source when it can determine that the -intermediate register still holds the required value. - -Another kind of secondary reload is required on some machines which -allow copying all registers to and from memory, but require a scratch -register for stores to some memory locations (e.g., those with symbolic -address on the RT, and those with certain symbolic address on the SPARC -when compiling PIC)@. Scratch registers need not have the same mode -as the value being copied, and usually hold a different value than -that being copied. Special patterns in the md file are needed to -describe how the copy is performed with the help of the scratch register; -these patterns also describe the number, register class(es) and mode(s) -of the scratch register(s). - -In some cases, both an intermediate and a scratch register are required. - -For input reloads, this target hook is called with nonzero @var{in_p}, -and @var{x} is an rtx that needs to be copied to a register of class -@var{reload_class} in @var{reload_mode}. For output reloads, this target -hook is called with zero @var{in_p}, and a register of class @var{reload_class} -needs to be copied to rtx @var{x} in @var{reload_mode}. - -If copying a register of @var{reload_class} from/to @var{x} requires -an intermediate register, the hook @code{secondary_reload} should -return the register class required for this intermediate register. -If no intermediate register is required, it should return NO_REGS. -If more than one intermediate register is required, describe the one -that is closest in the copy chain to the reload register. - -If scratch registers are needed, you also have to describe how to -perform the copy from/to the reload register to/from this -closest intermediate register. Or if no intermediate register is -required, but still a scratch register is needed, describe the -copy from/to the reload register to/from the reload operand @var{x}. - -You do this by setting @code{sri->icode} to the instruction code of a pattern -in the md file which performs the move. Operands 0 and 1 are the output -and input of this copy, respectively. Operands from operand 2 onward are -for scratch operands. These scratch operands must have a mode, and a -single-register-class -@c [later: or memory] -output constraint. - -When an intermediate register is used, the @code{secondary_reload} -hook will be called again to determine how to copy the intermediate -register to/from the reload operand @var{x}, so your hook must also -have code to handle the register class of the intermediate operand. - -@c [For later: maybe we'll allow multi-alternative reload patterns - -@c the port maintainer could name a mov<mode> pattern that has clobbers - -@c and match the constraints of input and output to determine the required -@c alternative. A restriction would be that constraints used to match -@c against reloads registers would have to be written as register class -@c constraints, or we need a new target macro / hook that tells us if an -@c arbitrary constraint can match an unknown register of a given class. -@c Such a macro / hook would also be useful in other places.] - - -@var{x} might be a pseudo-register or a @code{subreg} of a -pseudo-register, which could either be in a hard register or in memory. -Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is -in memory and the hard register number if it is in a register. - -Scratch operands in memory (constraint @code{"=m"} / @code{"=&m"}) are -currently not supported. For the time being, you will have to continue -to use @code{SECONDARY_MEMORY_NEEDED} for that purpose. - -@code{copy_cost} also uses this target hook to find out how values are -copied. If you want it to include some extra cost for the need to allocate -(a) scratch register(s), set @code{sri->extra_cost} to the additional cost. -Or if two dependent moves are supposed to have a lower cost than the sum -of the individual moves due to expected fortuitous scheduling and/or special -forwarding logic, you can set @code{sri->extra_cost} to a negative amount. -@end deftypefn @defmac SECONDARY_RELOAD_CLASS (@var{class}, @var{mode}, @var{x}) @defmacx SECONDARY_INPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x}) @@ -2812,37 +2508,8 @@ is @code{BITS_PER_WORD} bits wide is correct for your machine. @end defmac @hook TARGET_CLASS_LIKELY_SPILLED_P -A target hook which returns @code{true} if pseudos that have been assigned -to registers of class @var{rclass} would likely be spilled because -registers of @var{rclass} are needed for spill registers. - -The default version of this target hook returns @code{true} if @var{rclass} -has exactly one register and @code{false} otherwise. On most machines, this -default should be used. For generally register-starved machines, such as -i386, or machines with right register constraints, such as SH, this hook -can be used to avoid excessive spilling. - -This hook is also used by some of the global intra-procedural code -transformations to throtle code motion, to avoid increasing register -pressure. -@end deftypefn @hook TARGET_CLASS_MAX_NREGS -A target hook returns the maximum number of consecutive registers -of class @var{rclass} needed to hold a value of mode @var{mode}. - -This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact, -the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass}, -@var{mode})} target hook should be the maximum value of -@code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno} -values in the class @var{rclass}. - -This target hook helps control the handling of multiple-word values -in the reload pass. - -The default version of this target hook returns the size of @var{mode} -in words. -@end deftypefn @defmac CLASS_MAX_NREGS (@var{class}, @var{mode}) A C expression for the maximum number of consecutive registers @@ -3178,12 +2845,6 @@ define this macro. @end defmac @hook TARGET_BUILTIN_SETJMP_FRAME_VALUE -This target hook should return an rtx that is used to store -the address of the current frame into the built in @code{setjmp} buffer. -The default value, @code{virtual_stack_vars_rtx}, is correct for most -machines. One reason you may need to define this target hook is if -@code{hard_frame_pointer_rtx} is the appropriate value on your machine. -@end deftypefn @defmac FRAME_ADDR_RTX (@var{frameaddr}) A C expression whose value is RTL representing the value of the frame @@ -3245,20 +2906,6 @@ terminate the stack backtrace. New ports should avoid this. @end defmac @hook TARGET_DWARF_HANDLE_FRAME_UNSPEC -This target hook allows the backend to emit frame-related insns that -contain UNSPECs or UNSPEC_VOLATILEs. The DWARF 2 call frame debugging -info engine will invoke it on insns of the form -@smallexample -(set (reg) (unspec [@dots{}] UNSPEC_INDEX)) -@end smallexample -and -@smallexample -(set (reg) (unspec_volatile [@dots{}] UNSPECV_INDEX)). -@end smallexample -to let the backend emit the call frame instructions. @var{label} is -the CFI label attached to the insn, @var{pattern} is the pattern of -the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}. -@end deftypefn @defmac INCOMING_FRAME_SP_OFFSET A C expression whose value is an integer giving the offset, in bytes, @@ -3641,26 +3288,6 @@ defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used. @end defmac @hook TARGET_STATIC_CHAIN -This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for -targets that may use different static chain locations for different -nested functions. This may be required if the target has function -attributes that affect the calling conventions of the function and -those calling conventions use different static chain locations. - -The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al. - -If the static chain is passed in memory, this hook should be used to -provide rtx giving @code{mem} expressions that denote where they are stored. -Often the @code{mem} expression as seen by the caller will be at an offset -from the stack pointer and the @code{mem} expression as seen by the callee -will be at an offset from the frame pointer. -@findex stack_pointer_rtx -@findex frame_pointer_rtx -@findex arg_pointer_rtx -The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and -@code{arg_pointer_rtx} will have been initialized and should be used -to refer to those items. -@end deftypefn @defmac DWARF_FRAME_REGISTERS This macro specifies the maximum number of hard registers that can be @@ -3743,29 +3370,6 @@ defined and 0 otherwise. This is about eliminating the frame pointer and arg pointer. @hook TARGET_FRAME_POINTER_REQUIRED -This target hook should return @code{true} if a function must have and use -a frame pointer. This target hook is called in the reload pass. If its return -value is @code{true} the function will have a frame pointer. - -This target hook can in principle examine the current function and decide -according to the facts, but on most machines the constant @code{false} or the -constant @code{true} suffices. Use @code{false} when the machine allows code -to be generated with no frame pointer, and doing so saves some time or space. -Use @code{true} when there is no possible advantage to avoiding a frame -pointer. - -In certain cases, the compiler does not know how to produce valid code -without a frame pointer. The compiler recognizes those cases and -automatically gives the function a frame pointer regardless of what -@code{TARGET_FRAME_POINTER_REQUIRED} returns. You don't need to worry about -them. - -In a function that does not require a frame pointer, the frame pointer -register can be allocated for ordinary usage, unless you mark it as a -fixed register. See @code{FIXED_REGISTERS} for more information. - -Default return value is @code{false}. -@end deftypefn @findex get_frame_size @defmac INITIAL_FRAME_POINTER_OFFSET (@var{depth-var}) @@ -3809,15 +3413,6 @@ specified first since that is the preferred elimination. @end defmac @hook TARGET_CAN_ELIMINATE -This target hook should returns @code{true} if the compiler is allowed to -try to replace register number @var{from_reg} with register number -@var{to_reg}. This target hook need only be defined if @code{ELIMINABLE_REGS} -is defined, and will usually be @code{true}, since most of the cases -preventing register elimination are things that the compiler already -knows about. - -Default return value is @code{true}. -@end deftypefn @defmac INITIAL_ELIMINATION_OFFSET (@var{from-reg}, @var{to-reg}, @var{offset-var}) This macro is similar to @code{INITIAL_FRAME_POINTER_OFFSET}. It @@ -3836,12 +3431,6 @@ on the stack. See the following section for other macros that control passing certain arguments in registers. @hook TARGET_PROMOTE_PROTOTYPES -This target hook returns @code{true} if an argument declared in a -prototype as an integral type smaller than @code{int} should actually be -passed as an @code{int}. In addition to avoiding errors in certain -cases of mismatch, it also makes for better code on certain machines. -The default is to not promote prototypes. -@end deftypefn @defmac PUSH_ARGS A C expression. If nonzero, push insns will be used to pass @@ -3936,42 +3525,6 @@ stack in its natural location. @end defmac @hook TARGET_RETURN_POPS_ARGS -This target hook returns the number of bytes of its own arguments that -a function pops on returning, or 0 if the function pops no arguments -and the caller must therefore pop them all after the function returns. - -@var{fundecl} is a C variable whose value is a tree node that describes -the function in question. Normally it is a node of type -@code{FUNCTION_DECL} that describes the declaration of the function. -From this you can obtain the @code{DECL_ATTRIBUTES} of the function. - -@var{funtype} is a C variable whose value is a tree node that -describes the function in question. Normally it is a node of type -@code{FUNCTION_TYPE} that describes the data type of the function. -From this it is possible to obtain the data types of the value and -arguments (if known). - -When a call to a library function is being considered, @var{fundecl} -will contain an identifier node for the library function. Thus, if -you need to distinguish among various library functions, you can do so -by their names. Note that ``library function'' in this context means -a function used to perform arithmetic, whose name is known specially -in the compiler and was not mentioned in the C code being compiled. - -@var{size} is the number of bytes of arguments passed on the -stack. If a variable number of bytes is passed, it is zero, and -argument popping will always be the responsibility of the calling function. - -On the VAX, all functions always pop their arguments, so the definition -of this macro is @var{size}. On the 68000, using the standard -calling convention, no functions pop their arguments, so the value of -the macro is always 0 in this case. But an alternative calling -convention is available in which functions that take a fixed number of -arguments pop them but other functions (such as @code{printf}) pop -nothing (the caller pops all). When this convention is in use, -@var{funtype} is examined to determine whether a function takes a fixed -number of arguments. -@end deftypefn @defmac CALL_POPS_ARGS (@var{cum}) A C expression that should indicate the number of bytes a call sequence @@ -3998,124 +3551,16 @@ types of arguments are passed in registers or how they are arranged in the stack. @hook TARGET_FUNCTION_ARG -Return an RTX indicating whether a function argument is passed in a -register and if so, which register. - -The arguments are @var{ca}, which summarizes all the previous -arguments; @var{mode}, the machine mode of the argument; @var{type}, -the data type of the argument as a tree node or 0 if that is not known -(which happens for C support library functions); and @var{named}, -which is @code{true} for an ordinary argument and @code{false} for -nameless arguments that correspond to @samp{@dots{}} in the called -function's prototype. @var{type} can be an incomplete type if a -syntax error has previously occurred. - -The return value is usually either a @code{reg} RTX for the hard -register in which to pass the argument, or zero to pass the argument -on the stack. - -The value of the expression can also be a @code{parallel} RTX@. This is -used when an argument is passed in multiple locations. The mode of the -@code{parallel} should be the mode of the entire argument. The -@code{parallel} holds any number of @code{expr_list} pairs; each one -describes where part of the argument is passed. In each -@code{expr_list} the first operand must be a @code{reg} RTX for the hard -register in which to pass this part of the argument, and the mode of the -register RTX indicates how large this part of the argument is. The -second operand of the @code{expr_list} is a @code{const_int} which gives -the offset in bytes into the entire argument of where this part starts. -As a special exception the first @code{expr_list} in the @code{parallel} -RTX may have a first operand of zero. This indicates that the entire -argument is also stored on the stack. - -The last time this hook is called, it is called with @code{MODE == -VOIDmode}, and its result is passed to the @code{call} or @code{call_value} -pattern as operands 2 and 3 respectively. - -@cindex @file{stdarg.h} and register arguments -The usual way to make the ISO library @file{stdarg.h} work on a -machine where some arguments are usually passed in registers, is to -cause nameless arguments to be passed on the stack instead. This is -done by making @code{TARGET_FUNCTION_ARG} return 0 whenever -@var{named} is @code{false}. - -@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG} -@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG} -You may use the hook @code{targetm.calls.must_pass_in_stack} -in the definition of this macro to determine if this argument is of a -type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE} -is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an -argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is -defined, the argument will be computed in the stack and then loaded into -a register. -@end deftypefn @hook TARGET_MUST_PASS_IN_STACK -This target hook should return @code{true} if we should not pass @var{type} -solely in registers. The file @file{expr.h} defines a -definition that is usually appropriate, refer to @file{expr.h} for additional -documentation. -@end deftypefn @hook TARGET_FUNCTION_INCOMING_ARG -Define this hook if the target machine has ``register windows'', so -that the register in which a function sees an arguments is not -necessarily the same as the one in which the caller passed the -argument. - -For such machines, @code{TARGET_FUNCTION_ARG} computes the register in -which the caller passes the value, and -@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar -fashion to tell the function being called where the arguments will -arrive. - -If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined, -@code{TARGET_FUNCTION_ARG} serves both purposes. -@end deftypefn @hook TARGET_ARG_PARTIAL_BYTES -This target hook returns the number of bytes at the beginning of an -argument that must be put in registers. The value must be zero for -arguments that are passed entirely in registers or that are entirely -pushed on the stack. - -On some machines, certain arguments must be passed partially in -registers and partially in memory. On these machines, typically the -first few words of arguments are passed in registers, and the rest -on the stack. If a multi-word argument (a @code{double} or a -structure) crosses that boundary, its first few words must be passed -in registers and the rest must be pushed. This macro tells the -compiler when this occurs, and how many bytes should go in registers. - -@code{TARGET_FUNCTION_ARG} for these arguments should return the first -register to be used by the caller for this argument; likewise -@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function. -@end deftypefn @hook TARGET_PASS_BY_REFERENCE -This target hook should return @code{true} if an argument at the -position indicated by @var{cum} should be passed by reference. This -predicate is queried after target independent reasons for being -passed by reference, such as @code{TREE_ADDRESSABLE (type)}. - -If the hook returns true, a copy of that argument is made in memory and a -pointer to the argument is passed instead of the argument itself. -The pointer is passed in whatever way is appropriate for passing a pointer -to that type. -@end deftypefn @hook TARGET_CALLEE_COPIES -The function argument described by the parameters to this hook is -known to be passed by reference. The hook should return true if the -function argument should be copied by the callee instead of copied -by the caller. - -For any argument for which the hook returns true, if it can be -determined that the argument is not modified, then a copy need -not be generated. - -The default version of this hook always returns false. -@end deftypefn @defmac CUMULATIVE_ARGS A C type for declaring a variable that is used as the first argument @@ -4184,16 +3629,6 @@ argument @var{libname} exists for symmetry with @end defmac @hook TARGET_FUNCTION_ARG_ADVANCE -This hook updates the summarizer variable pointed to by @var{ca} to -advance past an argument in the argument list. The values @var{mode}, -@var{type} and @var{named} describe that argument. Once this is done, -the variable @var{cum} is suitable for analyzing the @emph{following} -argument with @code{TARGET_FUNCTION_ARG}, etc. - -This hook need not do anything if the argument in question was passed -on the stack. The compiler knows how to track the amount of stack space -used for arguments without any special help. -@end deftypefn @defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type}) If defined, a C expression that is the number of bytes to add to the @@ -4239,10 +3674,6 @@ required. @end defmac @hook TARGET_FUNCTION_ARG_BOUNDARY -This hook returns the alignment boundary, in bits, of an argument -with the specified mode and type. The default hook returns -@code{PARM_BOUNDARY} for all arguments. -@end deftypefn @hook TARGET_FUNCTION_ARG_ROUND_BOUNDARY @@ -4256,115 +3687,28 @@ stack. @end defmac @hook TARGET_SPLIT_COMPLEX_ARG -This hook should return true if parameter of type @var{type} are passed -as two scalar parameters. By default, GCC will attempt to pack complex -arguments into the target's word size. Some ABIs require complex arguments -to be split and treated as their individual components. For example, on -AIX64, complex floats should be passed in a pair of floating point -registers, even though a complex float would fit in one 64-bit floating -point register. - -The default value of this hook is @code{NULL}, which is treated as always -false. -@end deftypefn @hook TARGET_BUILD_BUILTIN_VA_LIST -This hook returns a type node for @code{va_list} for the target. -The default version of the hook returns @code{void*}. -@end deftypefn @hook TARGET_ENUM_VA_LIST_P -This target hook is used in function @code{c_common_nodes_and_builtins} -to iterate through the target specific builtin types for va_list. The -variable @var{idx} is used as iterator. @var{pname} has to be a pointer -to a @code{const char *} and @var{ptree} a pointer to a @code{tree} typed -variable. -The arguments @var{pname} and @var{ptree} are used to store the result of -this macro and are set to the name of the va_list builtin type and its -internal type. -If the return value of this macro is zero, then there is no more element. -Otherwise the @var{IDX} should be increased for the next call of this -macro to iterate through all types. -@end deftypefn @hook TARGET_FN_ABI_VA_LIST -This hook returns the va_list type of the calling convention specified by -@var{fndecl}. -The default version of this hook returns @code{va_list_type_node}. -@end deftypefn @hook TARGET_CANONICAL_VA_LIST_TYPE -This hook returns the va_list type of the calling convention specified by the -type of @var{type}. If @var{type} is not a valid va_list type, it returns -@code{NULL_TREE}. -@end deftypefn @hook TARGET_GIMPLIFY_VA_ARG_EXPR -This hook performs target-specific gimplification of -@code{VA_ARG_EXPR}. The first two parameters correspond to the -arguments to @code{va_arg}; the latter two are as in -@code{gimplify.c:gimplify_expr}. -@end deftypefn @hook TARGET_VALID_POINTER_MODE -Define this to return nonzero if the port can handle pointers -with machine mode @var{mode}. The default version of this -hook returns true for both @code{ptr_mode} and @code{Pmode}. -@end deftypefn @hook TARGET_REF_MAY_ALIAS_ERRNO @hook TARGET_SCALAR_MODE_SUPPORTED_P -Define this to return nonzero if the port is prepared to handle -insns involving scalar mode @var{mode}. For a scalar mode to be -considered supported, all the basic arithmetic and comparisons -must work. - -The default version of this hook returns true for any mode -required to handle the basic C types (as defined by the port). -Included here are the double-word arithmetic supported by the -code in @file{optabs.c}. -@end deftypefn @hook TARGET_VECTOR_MODE_SUPPORTED_P -Define this to return nonzero if the port is prepared to handle -insns involving vector mode @var{mode}. At the very least, it -must have move patterns for this mode. -@end deftypefn @hook TARGET_ARRAY_MODE_SUPPORTED_P @hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P -Define this to return nonzero for machine modes for which the port has -small register classes. If this target hook returns nonzero for a given -@var{mode}, the compiler will try to minimize the lifetime of registers -in @var{mode}. The hook may be called with @code{VOIDmode} as argument. -In this case, the hook is expected to return nonzero if it returns nonzero -for any mode. - -On some machines, it is risky to let hard registers live across arbitrary -insns. Typically, these machines have instructions that require values -to be in specific registers (like an accumulator), and reload will fail -if the required hard register is used for another purpose across such an -insn. - -Passes before reload do not know which hard registers will be used -in an instruction, but the machine modes of the registers set or used in -the instruction are already known. And for some machines, register -classes are small for, say, integer registers but not for floating point -registers. For example, the AMD x86-64 architecture requires specific -registers for the legacy x86 integer instructions, but there are many -SSE registers for floating point operations. On such targets, a good -strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P} -machine modes but zero for the SSE register classes. - -The default version of this hook returns false for any mode. It is always -safe to redefine this hook to return with a nonzero value. But if you -unnecessarily define it, you will reduce the amount of optimizations -that can be performed in some cases. If you do not define this hook -to return a nonzero value when it is required, the compiler will run out -of spill registers and print a fatal error message. -@end deftypefn @hook TARGET_FLAGS_REGNUM @@ -4379,48 +3723,6 @@ values---values that can fit in registers. @hook TARGET_FUNCTION_VALUE -Define this to return an RTX representing the place where a function -returns or receives a value of data type @var{ret_type}, a tree node -representing a data type. @var{fn_decl_or_type} is a tree node -representing @code{FUNCTION_DECL} or @code{FUNCTION_TYPE} of a -function being called. If @var{outgoing} is false, the hook should -compute the register in which the caller will see the return value. -Otherwise, the hook should return an RTX representing the place where -a function returns a value. - -On many machines, only @code{TYPE_MODE (@var{ret_type})} is relevant. -(Actually, on most machines, scalar values are returned in the same -place regardless of mode.) The value of the expression is usually a -@code{reg} RTX for the hard register where the return value is stored. -The value can also be a @code{parallel} RTX, if the return value is in -multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the -@code{parallel} form. Note that the callee will populate every -location specified in the @code{parallel}, but if the first element of -the @code{parallel} contains the whole return value, callers will use -that element as the canonical location and ignore the others. The m68k -port uses this type of @code{parallel} to return pointers in both -@samp{%a0} (the canonical location) and @samp{%d0}. - -If @code{TARGET_PROMOTE_FUNCTION_RETURN} returns true, you must apply -the same promotion rules specified in @code{PROMOTE_MODE} if -@var{valtype} is a scalar type. - -If the precise function being called is known, @var{func} is a tree -node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null -pointer. This makes it possible to use a different value-returning -convention for specific functions when all their calls are -known. - -Some target machines have ``register windows'' so that the register in -which a function returns its value is not the same as the one in which -the caller sees the value. For such machines, you should return -different RTX depending on @var{outgoing}. - -@code{TARGET_FUNCTION_VALUE} is not used for return values with -aggregate data types, because these are returned in another way. See -@code{TARGET_STRUCT_VALUE_RTX} and related macros, below. -@end deftypefn - @defmac FUNCTION_VALUE (@var{valtype}, @var{func}) This macro has been deprecated. Use @code{TARGET_FUNCTION_VALUE} for a new target instead. @@ -4437,15 +3739,6 @@ compiled. @end defmac @hook TARGET_LIBCALL_VALUE -Define this hook if the back-end needs to know the name of the libcall -function in order to determine where the result should be returned. - -The mode of the result is given by @var{mode} and the name of the called -library function is given by @var{fun}. The hook should return an RTX -representing the place where the library function result will be returned. - -If this hook is not defined, then LIBCALL_VALUE will be used. -@end deftypefn @defmac FUNCTION_VALUE_REGNO_P (@var{regno}) A C expression that is nonzero if @var{regno} is the number of a hard @@ -4469,19 +3762,6 @@ for a new target instead. @end defmac @hook TARGET_FUNCTION_VALUE_REGNO_P -A target hook that return @code{true} if @var{regno} is the number of a hard -register in which the values of called function may come back. - -A register whose use for returning values is limited to serving as the -second of a pair (for a value of type @code{double}, say) need not be -recognized by this target hook. - -If the machine has register windows, so that the caller and the called -function use different registers for the return value, this target hook -should recognize only the caller's register numbers. - -If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used. -@end deftypefn @defmac APPLY_RESULT_SIZE Define this macro if @samp{untyped_call} and @samp{untyped_return} @@ -4490,17 +3770,6 @@ saving and restoring an arbitrary return value. @end defmac @hook TARGET_RETURN_IN_MSB -This hook should return true if values of type @var{type} are returned -at the most significant end of a register (in other words, if they are -padded at the least significant end). You can assume that @var{type} -is returned in a register; the caller is required to check this. - -Note that the register provided by @code{TARGET_FUNCTION_VALUE} must -be able to hold the complete return value. For example, if a 1-, 2- -or 3-byte structure is returned at the most significant end of a -4-byte register, @code{TARGET_FUNCTION_VALUE} should provide an -@code{SImode} rtx. -@end deftypefn @node Aggregate Return @subsection How Large Values Are Returned @@ -4520,23 +3789,6 @@ This section describes how to control returning structure values in memory. @hook TARGET_RETURN_IN_MEMORY -This target hook should return a nonzero value to say to return the -function value in memory, just as large structures are always returned. -Here @var{type} will be the data type of the value, and @var{fntype} -will be the type of the function doing the returning, or @code{NULL} for -libcalls. - -Note that values of mode @code{BLKmode} must be explicitly handled -by this function. Also, the option @option{-fpcc-struct-return} -takes effect regardless of this macro. On most systems, it is -possible to leave the hook undefined; this causes a default -definition to be used, whose value is the constant 1 for @code{BLKmode} -values, and 0 otherwise. - -Do not use this hook to indicate that structures and unions should always -be returned in memory. You should instead use @code{DEFAULT_PCC_STRUCT_RETURN} -to indicate this. -@end deftypefn @defmac DEFAULT_PCC_STRUCT_RETURN Define this macro to be 1 if all structure and union return values must be @@ -4550,27 +3802,6 @@ If not defined, this defaults to the value 1. @end defmac @hook TARGET_STRUCT_VALUE_RTX -This target hook should return the location of the structure value -address (normally a @code{mem} or @code{reg}), or 0 if the address is -passed as an ``invisible'' first argument. Note that @var{fndecl} may -be @code{NULL}, for libcalls. You do not need to define this target -hook if the address is always passed as an ``invisible'' first -argument. - -On some architectures the place where the structure value address -is found by the called function is not the same place that the -caller put it. This can be due to register windows, or it could -be because the function prologue moves it to a different place. -@var{incoming} is @code{1} or @code{2} when the location is needed in -the context of the called function, and @code{0} in the context of -the caller. - -If @var{incoming} is nonzero and the address is to be found on the -stack, return a @code{mem} which refers to the frame pointer. If -@var{incoming} is @code{2}, the result is being used to fetch the -structure value address at the beginning of a function. If you need -to emit adjusting code, you should do it at this point. -@end deftypefn @defmac PCC_STATIC_STRUCT_RETURN Define this macro if the usual system convention on the target machine @@ -4623,110 +3854,12 @@ This section describes the macros that output function entry (@dfn{prologue}) and exit (@dfn{epilogue}) code. @hook TARGET_ASM_FUNCTION_PROLOGUE -If defined, a function that outputs the assembler code for entry to a -function. The prologue is responsible for setting up the stack frame, -initializing the frame pointer register, saving registers that must be -saved, and allocating @var{size} additional bytes of storage for the -local variables. @var{size} is an integer. @var{file} is a stdio -stream to which the assembler code should be output. - -The label for the beginning of the function need not be output by this -macro. That has already been done when the macro is run. - -@findex regs_ever_live -To determine which registers to save, the macro can refer to the array -@code{regs_ever_live}: element @var{r} is nonzero if hard register -@var{r} is used anywhere within the function. This implies the function -prologue should save register @var{r}, provided it is not one of the -call-used registers. (@code{TARGET_ASM_FUNCTION_EPILOGUE} must likewise use -@code{regs_ever_live}.) - -On machines that have ``register windows'', the function entry code does -not save on the stack the registers that are in the windows, even if -they are supposed to be preserved by function calls; instead it takes -appropriate steps to ``push'' the register stack, if any non-call-used -registers are used in the function. - -@findex frame_pointer_needed -On machines where functions may or may not have frame-pointers, the -function entry code must vary accordingly; it must set up the frame -pointer if one is wanted, and not otherwise. To determine whether a -frame pointer is in wanted, the macro can refer to the variable -@code{frame_pointer_needed}. The variable's value will be 1 at run -time in a function that needs a frame pointer. @xref{Elimination}. - -The function entry code is responsible for allocating any stack space -required for the function. This stack space consists of the regions -listed below. In most cases, these regions are allocated in the -order listed, with the last listed region closest to the top of the -stack (the lowest address if @code{STACK_GROWS_DOWNWARD} is defined, and -the highest address if it is not defined). You can use a different order -for a machine if doing so is more convenient or required for -compatibility reasons. Except in cases where required by standard -or by a debugger, there is no reason why the stack layout used by GCC -need agree with that used by other compilers for a machine. -@end deftypefn @hook TARGET_ASM_FUNCTION_END_PROLOGUE -If defined, a function that outputs assembler code at the end of a -prologue. This should be used when the function prologue is being -emitted as RTL, and you have some extra assembler that needs to be -emitted. @xref{prologue instruction pattern}. -@end deftypefn @hook TARGET_ASM_FUNCTION_BEGIN_EPILOGUE -If defined, a function that outputs assembler code at the start of an -epilogue. This should be used when the function epilogue is being -emitted as RTL, and you have some extra assembler that needs to be -emitted. @xref{epilogue instruction pattern}. -@end deftypefn @hook TARGET_ASM_FUNCTION_EPILOGUE -If defined, a function that outputs the assembler code for exit from a -function. The epilogue is responsible for restoring the saved -registers and stack pointer to their values when the function was -called, and returning control to the caller. This macro takes the -same arguments as the macro @code{TARGET_ASM_FUNCTION_PROLOGUE}, and the -registers to restore are determined from @code{regs_ever_live} and -@code{CALL_USED_REGISTERS} in the same way. - -On some machines, there is a single instruction that does all the work -of returning from the function. On these machines, give that -instruction the name @samp{return} and do not define the macro -@code{TARGET_ASM_FUNCTION_EPILOGUE} at all. - -Do not define a pattern named @samp{return} if you want the -@code{TARGET_ASM_FUNCTION_EPILOGUE} to be used. If you want the target -switches to control whether return instructions or epilogues are used, -define a @samp{return} pattern with a validity condition that tests the -target switches appropriately. If the @samp{return} pattern's validity -condition is false, epilogues will be used. - -On machines where functions may or may not have frame-pointers, the -function exit code must vary accordingly. Sometimes the code for these -two cases is completely different. To determine whether a frame pointer -is wanted, the macro can refer to the variable -@code{frame_pointer_needed}. The variable's value will be 1 when compiling -a function that needs a frame pointer. - -Normally, @code{TARGET_ASM_FUNCTION_PROLOGUE} and -@code{TARGET_ASM_FUNCTION_EPILOGUE} must treat leaf functions specially. -The C variable @code{current_function_is_leaf} is nonzero for such a -function. @xref{Leaf Functions}. - -On some machines, some functions pop their arguments on exit while -others leave that for the caller to do. For example, the 68020 when -given @option{-mrtd} pops arguments in functions that take a fixed -number of arguments. - -@findex pops_args -@findex crtl->args.pops_args -Your definition of the macro @code{RETURN_POPS_ARGS} decides which -functions pop their own arguments. @code{TARGET_ASM_FUNCTION_EPILOGUE} -needs to know what was decided. The number of bytes of the current -function's arguments that this function should pop is available in -@code{crtl->args.pops_args}. @xref{Scalar Return}. -@end deftypefn @itemize @bullet @item @@ -4789,54 +3922,8 @@ on entry to an exception edge. @end defmac @hook TARGET_ASM_OUTPUT_MI_THUNK -A function that outputs the assembler code for a thunk -function, used to implement C++ virtual function calls with multiple -inheritance. The thunk acts as a wrapper around a virtual function, -adjusting the implicit object parameter before handing control off to -the real function. - -First, emit code to add the integer @var{delta} to the location that -contains the incoming first argument. Assume that this argument -contains a pointer, and is the one used to pass the @code{this} pointer -in C++. This is the incoming argument @emph{before} the function prologue, -e.g.@: @samp{%o0} on a sparc. The addition must preserve the values of -all other incoming arguments. - -Then, if @var{vcall_offset} is nonzero, an additional adjustment should be -made after adding @code{delta}. In particular, if @var{p} is the -adjusted pointer, the following adjustment should be made: - -@smallexample -p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)] -@end smallexample - -After the additions, emit code to jump to @var{function}, which is a -@code{FUNCTION_DECL}. This is a direct pure jump, not a call, and does -not touch the return address. Hence returning from @var{FUNCTION} will -return to whoever called the current @samp{thunk}. - -The effect must be as if @var{function} had been called directly with -the adjusted first argument. This macro is responsible for emitting all -of the code for a thunk function; @code{TARGET_ASM_FUNCTION_PROLOGUE} -and @code{TARGET_ASM_FUNCTION_EPILOGUE} are not invoked. - -The @var{thunk_fndecl} is redundant. (@var{delta} and @var{function} -have already been extracted from it.) It might possibly be useful on -some targets, but probably not. - -If you do not define this macro, the target-independent code in the C++ -front end will generate a less efficient heavyweight thunk that calls -@var{function} instead of jumping to it. The generic approach does -not support varargs. -@end deftypefn @hook TARGET_ASM_CAN_OUTPUT_MI_THUNK -A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able -to output the assembler code for the thunk function specified by the -arguments it is passed, and false otherwise. In the latter case, the -generic approach will be used by the C++ front end, with the limitations -previously exposed. -@end deftypefn @node Profiling @subsection Generating Code for Profiling @@ -4884,26 +3971,8 @@ the function prologue. Normally, the profiling code comes after. @cindex tail calls @hook TARGET_FUNCTION_OK_FOR_SIBCALL -True if it is ok to do sibling call optimization for the specified -call expression @var{exp}. @var{decl} will be the called function, -or @code{NULL} if this is an indirect call. - -It is not uncommon for limitations of calling conventions to prevent -tail calls to functions outside the current unit of translation, or -during PIC compilation. The hook is used to enforce these restrictions, -as the @code{sibcall} md pattern can not fail, or fall over to a -``normal'' call. The criteria for successful sibling call optimization -may vary greatly between different architectures. -@end deftypefn @hook TARGET_EXTRA_LIVE_ON_ENTRY -Add any hard registers to @var{regs} that are live on entry to the -function. This hook only needs to be defined to provide registers that -cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved -registers, STATIC_CHAIN_INCOMING_REGNUM, STATIC_CHAIN_REGNUM, -TARGET_STRUCT_VALUE_RTX, FRAME_POINTER_REGNUM, EH_USES, -FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM. -@end deftypefn @hook TARGET_SET_UP_BY_PROLOGUE @@ -4914,25 +3983,8 @@ FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM. @cindex stack smashing protection @hook TARGET_STACK_PROTECT_GUARD -This hook returns a @code{DECL} node for the external variable to use -for the stack protection guard. This variable is initialized by the -runtime to some random value and is used to initialize the guard value -that is placed at the top of the local stack frame. The type of this -variable must be @code{ptr_type_node}. - -The default version of this hook creates a variable called -@samp{__stack_chk_guard}, which is normally defined in @file{libgcc2.c}. -@end deftypefn @hook TARGET_STACK_PROTECT_FAIL -This hook returns a @code{CALL_EXPR} that alerts the runtime that the -stack protect guard variable has been modified. This expression should -involve a call to a @code{noreturn} function. - -The default version of this hook invokes a function called -@samp{__stack_chk_fail}, taking no arguments. This function is -normally defined in @file{libgcc2.c}. -@end deftypefn @hook TARGET_SUPPORTS_SPLIT_STACK @@ -5005,70 +4057,12 @@ interpret the values of @code{__builtin_classify_type}. These machine description macros help implement varargs: @hook TARGET_EXPAND_BUILTIN_SAVEREGS -If defined, this hook produces the machine-specific code for a call to -@code{__builtin_saveregs}. This code will be moved to the very -beginning of the function, before any parameter access are made. The -return value of this function should be an RTX that contains the value -to use as the return of @code{__builtin_saveregs}. -@end deftypefn @hook TARGET_SETUP_INCOMING_VARARGS -This target hook offers an alternative to using -@code{__builtin_saveregs} and defining the hook -@code{TARGET_EXPAND_BUILTIN_SAVEREGS}. Use it to store the anonymous -register arguments into the stack so that all the arguments appear to -have been passed consecutively on the stack. Once this is done, you can -use the standard implementation of varargs that works for machines that -pass all their arguments on the stack. - -The argument @var{args_so_far} points to the @code{CUMULATIVE_ARGS} data -structure, containing the values that are obtained after processing the -named arguments. The arguments @var{mode} and @var{type} describe the -last named argument---its machine mode and its data type as a tree node. - -The target hook should do two things: first, push onto the stack all the -argument registers @emph{not} used for the named arguments, and second, -store the size of the data thus pushed into the @code{int}-valued -variable pointed to by @var{pretend_args_size}. The value that you -store here will serve as additional offset for setting up the stack -frame. - -Because you must generate code to push the anonymous arguments at -compile time without knowing their data types, -@code{TARGET_SETUP_INCOMING_VARARGS} is only useful on machines that -have just a single category of argument register and use it uniformly -for all data types. - -If the argument @var{second_time} is nonzero, it means that the -arguments of the function are being analyzed for the second time. This -happens for an inline function, which is not actually compiled until the -end of the source file. The hook @code{TARGET_SETUP_INCOMING_VARARGS} should -not generate any instructions in this case. -@end deftypefn @hook TARGET_STRICT_ARGUMENT_NAMING -Define this hook to return @code{true} if the location where a function -argument is passed depends on whether or not it is a named argument. - -This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG} -is set for varargs and stdarg functions. If this hook returns -@code{true}, the @var{named} argument is always true for named -arguments, and false for unnamed arguments. If it returns @code{false}, -but @code{TARGET_PRETEND_OUTGOING_VARARGS_NAMED} returns @code{true}, -then all arguments are treated as named. Otherwise, all named arguments -except the last are treated as named. - -You need not define this hook if it always returns @code{false}. -@end deftypefn @hook TARGET_PRETEND_OUTGOING_VARARGS_NAMED -If you need to conditionally change ABIs so that one works with -@code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither -@code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING} was -defined, then define this hook to return @code{true} if -@code{TARGET_SETUP_INCOMING_VARARGS} is used, @code{false} otherwise. -Otherwise, you should not define this hook. -@end deftypefn @node Trampolines @section Trampolines for Nested Functions @@ -5099,16 +4093,6 @@ may be necessary to take out pieces of the address and store them separately. @hook TARGET_ASM_TRAMPOLINE_TEMPLATE -This hook is called by @code{assemble_trampoline_template} to output, -on the stream @var{f}, assembler code for a block of data that contains -the constant parts of a trampoline. This code should not include a -label---the label is taken care of automatically. - -If you do not define this hook, it means no template is needed -for the target. Do not define this hook on systems where the block move -code to copy the trampoline into place would be larger than the code -to generate it on the spot. -@end deftypefn @defmac TRAMPOLINE_SECTION Return the section into which the trampoline template is to be placed @@ -5127,33 +4111,8 @@ is used for aligning trampolines. @end defmac @hook TARGET_TRAMPOLINE_INIT -This hook is called to initialize a trampoline. -@var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl} -is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an -RTX for the static chain value that should be passed to the function -when it is called. - -If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the -first thing this hook should do is emit a block move into @var{m_tramp} -from the memory block returned by @code{assemble_trampoline_template}. -Note that the block move need only cover the constant parts of the -trampoline. If the target isolates the variable parts of the trampoline -to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied. - -If the target requires any other actions, such as flushing caches or -enabling stack execution, these actions should be performed after -initializing the trampoline proper. -@end deftypefn @hook TARGET_TRAMPOLINE_ADJUST_ADDRESS -This hook should perform any machine-specific adjustment in -the address of the trampoline. Its argument contains the address of the -memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}. In case -the address to be used for a function call should be different from the -address at which the template was stored, the different address should -be returned; otherwise @var{addr} should be returned unchanged. -If this hook is not defined, @var{addr} will be used for function calls. -@end deftypefn Implementing trampolines is difficult on many machines because they have separate instruction and data caches. Writing into a stack location @@ -5214,14 +4173,6 @@ are ABI-mandated names that the compiler should provide. @findex set_optab_libfunc @findex init_one_libfunc @hook TARGET_INIT_LIBFUNCS -This hook should declare additional library routines or rename -existing ones, using the functions @code{set_optab_libfunc} and -@code{init_one_libfunc} defined in @file{optabs.c}. -@code{init_optabs} calls this macro after initializing all the normal -library routines. - -The default is to do nothing. Most ports don't need to define this hook. -@end deftypefn @hook TARGET_LIBFUNC_GNU_PREFIX @@ -5358,69 +4309,6 @@ accept. @end defmac @hook TARGET_LEGITIMATE_ADDRESS_P -A function that returns whether @var{x} (an RTX) is a legitimate memory -address on the target machine for a memory operand of mode @var{mode}. - -Legitimate addresses are defined in two variants: a strict variant and a -non-strict one. The @var{strict} parameter chooses which variant is -desired by the caller. - -The strict variant is used in the reload pass. It must be defined so -that any pseudo-register that has not been allocated a hard register is -considered a memory reference. This is because in contexts where some -kind of register is required, a pseudo-register with no hard register -must be rejected. For non-hard registers, the strict variant should look -up the @code{reg_renumber} array; it should then proceed using the hard -register number in the array, or treat the pseudo as a memory reference -if the array holds @code{-1}. - -The non-strict variant is used in other passes. It must be defined to -accept all pseudo-registers in every context where some kind of -register is required. - -Normally, constant addresses which are the sum of a @code{symbol_ref} -and an integer are stored inside a @code{const} RTX to mark them as -constant. Therefore, there is no need to recognize such sums -specifically as legitimate addresses. Normally you would simply -recognize any @code{const} as legitimate. - -Usually @code{PRINT_OPERAND_ADDRESS} is not prepared to handle constant -sums that are not marked with @code{const}. It assumes that a naked -@code{plus} indicates indexing. If so, then you @emph{must} reject such -naked constant sums as illegitimate addresses, so that none of them will -be given to @code{PRINT_OPERAND_ADDRESS}. - -@cindex @code{TARGET_ENCODE_SECTION_INFO} and address validation -On some machines, whether a symbolic address is legitimate depends on -the section that the address refers to. On these machines, define the -target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information -into the @code{symbol_ref}, and then check for it here. When you see a -@code{const}, you will have to look inside it to find the -@code{symbol_ref} in order to determine the section. @xref{Assembler -Format}. - -@cindex @code{GO_IF_LEGITIMATE_ADDRESS} -Some ports are still using a deprecated legacy substitute for -this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro. This macro -has this syntax: - -@example -#define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label}) -@end example - -@noindent -and should @code{goto @var{label}} if the address @var{x} is a valid -address on the target machine for a memory operand of mode @var{mode}. - -@findex REG_OK_STRICT -Compiler source files that want to use the strict variant of this -macro define the macro @code{REG_OK_STRICT}. You should use an -@code{#ifdef REG_OK_STRICT} conditional to define the strict variant in -that case and the non-strict variant otherwise. - -Using the hook is usually simpler because it limits the number of -files that are recompiled when changes are made. -@end deftypefn @defmac TARGET_MEM_CONSTRAINT A single character to be used instead of the default @code{'m'} @@ -5447,27 +4335,6 @@ a label_ref or symbol_ref within an UNSPEC@. @end defmac @hook TARGET_LEGITIMIZE_ADDRESS -This hook is given an invalid memory address @var{x} for an -operand of mode @var{mode} and should try to return a valid memory -address. - -@findex break_out_memory_refs -@var{x} will always be the result of a call to @code{break_out_memory_refs}, -and @var{oldx} will be the operand that was given to that function to produce -@var{x}. - -The code of the hook should not alter the substructure of -@var{x}. If it transforms @var{x} into a more legitimate form, it -should return the new @var{x}. - -It is not necessary for this hook to come up with a legitimate address, -with the exception of native TLS addresses (@pxref{Emulated TLS}). -The compiler has standard ways of doing so in all cases. In fact, if -the target supports only emulated TLS, it -is safe to omit this hook or make it return @var{x} if it cannot find -a valid way to legitimize the address. But often a machine-dependent -strategy can generate better code. -@end deftypefn @defmac LEGITIMIZE_RELOAD_ADDRESS (@var{x}, @var{mode}, @var{opnum}, @var{type}, @var{ind_levels}, @var{win}) A C compound statement that attempts to replace @var{x}, which is an address @@ -5519,169 +4386,38 @@ address; but often a machine-dependent strategy can generate better code. @end defmac @hook TARGET_MODE_DEPENDENT_ADDRESS_P -This hook returns @code{true} if memory address @var{addr} in address -space @var{addrspace} can have -different meanings depending on the machine mode of the memory -reference it is used for or if the address is valid for some modes -but not others. - -Autoincrement and autodecrement addresses typically have mode-dependent -effects because the amount of the increment or decrement is the size -of the operand being addressed. Some machines have other mode-dependent -addresses. Many RISC machines have no mode-dependent addresses. - -You may assume that @var{addr} is a valid address for the machine. - -The default version of this hook returns @code{false}. -@end deftypefn @hook TARGET_LEGITIMATE_CONSTANT_P -This hook returns true if @var{x} is a legitimate constant for a -@var{mode}-mode immediate operand on the target machine. You can assume that -@var{x} satisfies @code{CONSTANT_P}, so you need not check this. - -The default definition returns true. -@end deftypefn @hook TARGET_DELEGITIMIZE_ADDRESS -This hook is used to undo the possibly obfuscating effects of the -@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target -macros. Some backend implementations of these macros wrap symbol -references inside an @code{UNSPEC} rtx to represent PIC or similar -addressing modes. This target hook allows GCC's optimizers to understand -the semantics of these opaque @code{UNSPEC}s by converting them back -into their original form. -@end deftypefn @hook TARGET_CONST_NOT_OK_FOR_DEBUG_P -This hook should return true if @var{x} should not be emitted into -debug sections. -@end deftypefn @hook TARGET_CANNOT_FORCE_CONST_MEM -This hook should return true if @var{x} is of a form that cannot (or -should not) be spilled to the constant pool. @var{mode} is the mode -of @var{x}. - -The default version of this hook returns false. - -The primary reason to define this hook is to prevent reload from -deciding that a non-legitimate constant would be better reloaded -from the constant pool instead of spilling and reloading a register -holding the constant. This restriction is often true of addresses -of TLS symbols for various targets. -@end deftypefn @hook TARGET_USE_BLOCKS_FOR_CONSTANT_P -This hook should return true if pool entries for constant @var{x} can -be placed in an @code{object_block} structure. @var{mode} is the mode -of @var{x}. - -The default version returns false for all constants. -@end deftypefn @hook TARGET_USE_BLOCKS_FOR_DECL_P -This hook should return true if pool entries for @var{decl} should -be placed in an @code{object_block} structure. - -The default version returns true for all decls. -@end deftypefn @hook TARGET_BUILTIN_RECIPROCAL -This hook should return the DECL of a function that implements reciprocal of -the builtin function with builtin function code @var{fn}, or -@code{NULL_TREE} if such a function is not available. @var{md_fn} is true -when @var{fn} is a code of a machine-dependent builtin function. When -@var{sqrt} is true, additional optimizations that apply only to the reciprocal -of a square root function are performed, and only reciprocals of @code{sqrt} -function are valid. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD -This hook should return the DECL of a function @var{f} that given an -address @var{addr} as an argument returns a mask @var{m} that can be -used to extract from two vectors the relevant data that resides in -@var{addr} in case @var{addr} is not properly aligned. - -The autovectorizer, when vectorizing a load operation from an address -@var{addr} that may be unaligned, will generate two vector loads from -the two aligned addresses around @var{addr}. It then generates a -@code{REALIGN_LOAD} operation to extract the relevant data from the -two loaded vectors. The first two arguments to @code{REALIGN_LOAD}, -@var{v1} and @var{v2}, are the two vectors, each of size @var{VS}, and -the third argument, @var{OFF}, defines how the data will be extracted -from these two vectors: if @var{OFF} is 0, then the returned vector is -@var{v2}; otherwise, the returned vector is composed from the last -@var{VS}-@var{OFF} elements of @var{v1} concatenated to the first -@var{OFF} elements of @var{v2}. - -If this hook is defined, the autovectorizer will generate a call -to @var{f} (using the DECL tree that this hook returns) and will -use the return value of @var{f} as the argument @var{OFF} to -@code{REALIGN_LOAD}. Therefore, the mask @var{m} returned by @var{f} -should comply with the semantics expected by @code{REALIGN_LOAD} -described above. -If this hook is not defined, then @var{addr} will be used as -the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low -log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST -Returns cost of different scalar or vector statements for vectorization cost model. -For vector memory operations the cost may depend on type (@var{vectype}) and -misalignment value (@var{misalign}). -@end deftypefn @hook TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE -Return true if vector alignment is reachable (by peeling N iterations) for the given type. -@end deftypefn @hook TARGET_VECTORIZE_VEC_PERM_CONST_OK -Return true if a vector created for @code{vec_perm_const} is valid. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_CONVERSION -This hook should return the DECL of a function that implements conversion of the -input vector of type @var{src_type} to type @var{dest_type}. -The value of @var{code} is one of the enumerators in @code{enum tree_code} and -specifies how the conversion is to be applied -(truncation, rounding, etc.). - -If this hook is defined, the autovectorizer will use the -@code{TARGET_VECTORIZE_BUILTIN_CONVERSION} target hook when vectorizing -conversion. Otherwise, it will return @code{NULL_TREE}. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION -This hook should return the decl of a function that implements the -vectorized variant of the builtin function with builtin function code -@var{code} or @code{NULL_TREE} if such a function is not available. -The value of @var{fndecl} is the builtin function declaration. The -return type of the vectorized function shall be of vector type -@var{vec_type_out} and the argument types should be @var{vec_type_in}. -@end deftypefn @hook TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT -This hook should return true if the target supports misaligned vector -store/load of a specific factor denoted in the @var{misalignment} -parameter. The vector store/load should be of machine mode @var{mode} and -the elements in the vectors should be of type @var{type}. @var{is_packed} -parameter is true if the memory access is defined in a packed struct. -@end deftypefn @hook TARGET_VECTORIZE_PREFERRED_SIMD_MODE -This hook should return the preferred mode for vectorizing scalar -mode @var{mode}. The default is -equal to @code{word_mode}, because the vectorizer can do some -transformations even in absence of specialized @acronym{SIMD} hardware. -@end deftypefn @hook TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES -This hook should return a mask of sizes that should be iterated over -after trying to autovectorize using the vector size derived from the -mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}. -The default is zero which means to not iterate over other vector sizes. -@end deftypefn @hook TARGET_VECTORIZE_INIT_COST @@ -5696,12 +4432,6 @@ The default is zero which means to not iterate over other vector sizes. @hook TARGET_VECTORIZE_BUILTIN_TM_STORE @hook TARGET_VECTORIZE_BUILTIN_GATHER -Target builtin that implements vector gather operation. @var{mem_vectype} -is the vector type of the load and @var{index_type} is scalar type of -the index, scaled by @var{scale}. -The default is @code{NULL_TREE} which means to not vectorize gather -loads. -@end deftypefn @node Anchored Addresses @section Anchored Addresses @@ -5739,39 +4469,12 @@ section anchors at all unless either @code{TARGET_MIN_ANCHOR_OFFSET} or @code{TARGET_MAX_ANCHOR_OFFSET} is set to a nonzero value. @hook TARGET_MIN_ANCHOR_OFFSET -The minimum offset that should be applied to a section anchor. -On most targets, it should be the smallest offset that can be -applied to a base register while still giving a legitimate address -for every mode. The default value is 0. -@end deftypevr @hook TARGET_MAX_ANCHOR_OFFSET -Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive) -offset that should be applied to section anchors. The default -value is 0. -@end deftypevr @hook TARGET_ASM_OUTPUT_ANCHOR -Write the assembly code to define section anchor @var{x}, which is a -@code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true. -The hook is called with the assembly output position set to the beginning -of @code{SYMBOL_REF_BLOCK (@var{x})}. - -If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses -it to define the symbol as @samp{. + SYMBOL_REF_BLOCK_OFFSET (@var{x})}. -If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition -is @code{NULL}, which disables the use of section anchors altogether. -@end deftypefn @hook TARGET_USE_ANCHORS_FOR_SYMBOL_P -Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF} -@var{x}. You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and -@samp{!SYMBOL_REF_ANCHOR_P (@var{x})}. - -The default version is correct for most targets, but you might need to -intercept this hook to handle things like target-specific attributes -or target-specific sections. -@end deftypefn @node Condition Code @section Condition Code Status @@ -5941,26 +4644,6 @@ in @file{@var{machine}-modes.def}. @end defmac @hook TARGET_CANONICALIZE_COMPARISON -On some machines not all possible comparisons are defined, but you can -convert an invalid comparison into a valid one. For example, the Alpha -does not have a @code{GT} comparison, but you can use an @code{LT} -comparison instead and swap the order of the operands. - -On such machines, implement this hook to do any required conversions. -@var{code} is the initial comparison code and @var{op0} and @var{op1} -are the left and right operands of the comparison, respectively. If -@var{op0_preserve_value} is @code{true} the implementation is not -allowed to change the value of @var{op0} since the value might be used -in RTXs which aren't comparisons. E.g. the implementation is not -allowed to swap operands in that case. - -GCC will not assume that the comparison resulting from this macro is -valid but will see if the resulting insn matches a pattern in the -@file{md} file. - -You need not to implement this hook if it would never change the -comparison code or operands. -@end deftypefn @defmac REVERSIBLE_CC_MODE (@var{mode}) A C expression whose value is one if it is always safe to reverse a @@ -5995,32 +4678,8 @@ like: @end defmac @hook TARGET_FIXED_CONDITION_CODE_REGS -On targets which do not use @code{(cc0)}, and which use a hard -register rather than a pseudo-register to hold condition codes, the -regular CSE passes are often not able to identify cases in which the -hard register is set to a common value. Use this hook to enable a -small pass which optimizes such cases. This hook should return true -to enable this pass, and it should set the integers to which its -arguments point to the hard register numbers used for condition codes. -When there is only one such register, as is true on most systems, the -integer pointed to by @var{p2} should be set to -@code{INVALID_REGNUM}. - -The default version of this hook returns false. -@end deftypefn @hook TARGET_CC_MODES_COMPATIBLE -On targets which use multiple condition code modes in class -@code{MODE_CC}, it is sometimes the case that a comparison can be -validly done in more than one mode. On such a system, define this -target hook to take two mode arguments and to return a mode in which -both comparisons may be validly done. If there is no such mode, -return @code{VOIDmode}. - -The default version of this hook checks whether the modes are the -same. If they are, it returns that mode. If they are different, it -returns @code{VOIDmode}. -@end deftypefn @node Cond Exec Macros @subsection Macros to control conditional execution @@ -6063,25 +4722,6 @@ These macros are obsolete, new ports should use the target hook @end defmac @hook TARGET_REGISTER_MOVE_COST -This target hook should return the cost of moving data of mode @var{mode} -from a register in class @var{from} to one in class @var{to}. The classes -are expressed using the enumeration values such as @code{GENERAL_REGS}. -A value of 2 is the default; other values are interpreted relative to -that. - -It is not required that the cost always equal 2 when @var{from} is the -same as @var{to}; on some machines it is expensive to move between -registers if they are not general registers. - -If reload sees an insn consisting of a single @code{set} between two -hard registers, and if @code{TARGET_REGISTER_MOVE_COST} applied to their -classes returns a value of 2, reload does not check to ensure that the -constraints of the insn are met. Setting a cost of other than 2 will -allow reload to verify that the constraints are met. You should do this -if the @samp{mov@var{m}} pattern's constraints do not allow such copying. - -The default version of this function returns 2. -@end deftypefn @defmac MEMORY_MOVE_COST (@var{mode}, @var{class}, @var{in}) A C expression for the cost of moving data of mode @var{mode} between a @@ -6111,28 +4751,6 @@ These macros are obsolete, new ports should use the target hook @end defmac @hook TARGET_MEMORY_MOVE_COST -This target hook should return the cost of moving data of mode @var{mode} -between a register of class @var{rclass} and memory; @var{in} is @code{false} -if the value is to be written to memory, @code{true} if it is to be read in. -This cost is relative to those in @code{TARGET_REGISTER_MOVE_COST}. -If moving between registers and memory is more expensive than between two -registers, you should add this target hook to express the relative cost. - -If you do not add this target hook, GCC uses a default cost of 4 plus -the cost of copying via a secondary reload register, if one is -needed. If your machine requires a secondary reload register to copy -between memory and a register of @var{rclass} but the reload mechanism is -more complex than copying via an intermediate, use this target hook to -reflect the actual cost of the move. - -GCC defines the function @code{memory_move_secondary_cost} if -secondary reloads are needed. It computes the costs due to copying via -a secondary register. If your machine copies from memory using a -secondary register in the conventional way but the default base value of -4 is not correct for your machine, use this target hook to add some other -value to the result of that function. The arguments to that function -are the same as to this target hook. -@end deftypefn @defmac BRANCH_COST (@var{speed_p}, @var{predictable_p}) A C expression for the cost of a branch instruction. A value of 1 is @@ -6318,71 +4936,8 @@ Define this macro if a non-short-circuit operation produced by @end defmac @hook TARGET_RTX_COSTS -This target hook describes the relative costs of RTL expressions. - -The cost may depend on the precise form of the expression, which is -available for examination in @var{x}, and the fact that @var{x} appears -as operand @var{opno} of an expression with rtx code @var{outer_code}. -That is, the hook can assume that there is some rtx @var{y} such -that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that -either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or -(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}. - -@var{code} is @var{x}'s expression code---redundant, since it can be -obtained with @code{GET_CODE (@var{x})}. - -In implementing this hook, you can use the construct -@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast -instructions. - -On entry to the hook, @code{*@var{total}} contains a default estimate -for the cost of the expression. The hook should modify this value as -necessary. Traditionally, the default costs are @code{COSTS_N_INSNS (5)} -for multiplications, @code{COSTS_N_INSNS (7)} for division and modulus -operations, and @code{COSTS_N_INSNS (1)} for all other operations. - -When optimizing for code size, i.e.@: when @code{speed} is -false, this target hook should be used to estimate the relative -size cost of an expression, again relative to @code{COSTS_N_INSNS}. - -The hook returns true when all subexpressions of @var{x} have been -processed, and false when @code{rtx_cost} should recurse. -@end deftypefn @hook TARGET_ADDRESS_COST -This hook computes the cost of an addressing mode that contains -@var{address}. If not defined, the cost is computed from -the @var{address} expression and the @code{TARGET_RTX_COST} hook. - -For most CISC machines, the default cost is a good approximation of the -true cost of the addressing mode. However, on RISC machines, all -instructions normally have the same length and execution time. Hence -all addresses will have equal costs. - -In cases where more than one form of an address is known, the form with -the lowest cost will be used. If multiple forms have the same, lowest, -cost, the one that is the most complex will be used. - -For example, suppose an address that is equal to the sum of a register -and a constant is used twice in the same basic block. When this macro -is not defined, the address will be computed in a register and memory -references will be indirect through that register. On machines where -the cost of the addressing mode containing the sum is no higher than -that of a simple indirect reference, this will produce an additional -instruction and possibly require an additional register. Proper -specification of this macro eliminates this overhead for such machines. - -This hook is never called with an invalid address. - -On machines where an address involving more than one register is as -cheap as an address computation involving only one register, defining -@code{TARGET_ADDRESS_COST} to reflect this can cause two registers to -be live over a region of code where only one would have been if -@code{TARGET_ADDRESS_COST} were not defined in that manner. This effect -should be considered in the definition of this macro. Equivalent costs -should probably only be given to addresses with different numbers of -registers on machines with lots of registers. -@end deftypefn @node Scheduling @section Adjusting the Instruction Scheduler @@ -6393,357 +4948,86 @@ hooks for this purpose. It is usually enough to define just a few of them: try the first ones in this list first. @hook TARGET_SCHED_ISSUE_RATE -This hook returns the maximum number of instructions that can ever -issue at the same time on the target machine. The default is one. -Although the insn scheduler can define itself the possibility of issue -an insn on the same cycle, the value can serve as an additional -constraint to issue insns on the same simulated processor cycle (see -hooks @samp{TARGET_SCHED_REORDER} and @samp{TARGET_SCHED_REORDER2}). -This value must be constant over the entire compilation. If you need -it to vary depending on what the instructions are, you must use -@samp{TARGET_SCHED_VARIABLE_ISSUE}. -@end deftypefn @hook TARGET_SCHED_VARIABLE_ISSUE -This hook is executed by the scheduler after it has scheduled an insn -from the ready list. It should return the number of insns which can -still be issued in the current cycle. The default is -@samp{@w{@var{more} - 1}} for insns other than @code{CLOBBER} and -@code{USE}, which normally are not counted against the issue rate. -You should define this hook if some insns take more machine resources -than others, so that fewer insns can follow them in the same cycle. -@var{file} is either a null pointer, or a stdio stream to write any -debug output to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. @var{insn} is the instruction that -was scheduled. -@end deftypefn @hook TARGET_SCHED_ADJUST_COST -This function corrects the value of @var{cost} based on the -relationship between @var{insn} and @var{dep_insn} through the -dependence @var{link}. It should return the new value. The default -is to make no adjustment to @var{cost}. This can be used for example -to specify to the scheduler using the traditional pipeline description -that an output- or anti-dependence does not incur the same cost as a -data-dependence. If the scheduler using the automaton based pipeline -description, the cost of anti-dependence is zero and the cost of -output-dependence is maximum of one and the difference of latency -times of the first and the second insns. If these values are not -acceptable, you could use the hook to modify them too. See also -@pxref{Processor pipeline description}. -@end deftypefn @hook TARGET_SCHED_ADJUST_PRIORITY -This hook adjusts the integer scheduling priority @var{priority} of -@var{insn}. It should return the new priority. Increase the priority to -execute @var{insn} earlier, reduce the priority to execute @var{insn} -later. Do not define this hook if you do not need to adjust the -scheduling priorities of insns. -@end deftypefn @hook TARGET_SCHED_REORDER -This hook is executed by the scheduler after it has scheduled the ready -list, to allow the machine description to reorder it (for example to -combine two small instructions together on @samp{VLIW} machines). -@var{file} is either a null pointer, or a stdio stream to write any -debug output to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. @var{ready} is a pointer to the ready -list of instructions that are ready to be scheduled. @var{n_readyp} is -a pointer to the number of elements in the ready list. The scheduler -reads the ready list in reverse order, starting with -@var{ready}[@var{*n_readyp} @minus{} 1] and going to @var{ready}[0]. @var{clock} -is the timer tick of the scheduler. You may modify the ready list and -the number of ready insns. The return value is the number of insns that -can issue this cycle; normally this is just @code{issue_rate}. See also -@samp{TARGET_SCHED_REORDER2}. -@end deftypefn @hook TARGET_SCHED_REORDER2 -Like @samp{TARGET_SCHED_REORDER}, but called at a different time. That -function is called whenever the scheduler starts a new cycle. This one -is called once per iteration over a cycle, immediately after -@samp{TARGET_SCHED_VARIABLE_ISSUE}; it can reorder the ready list and -return the number of insns to be scheduled in the same cycle. Defining -this hook can be useful if there are frequent situations where -scheduling one insn causes other insns to become ready in the same -cycle. These other insns can then be taken into account properly. -@end deftypefn @hook TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK -This hook is called after evaluation forward dependencies of insns in -chain given by two parameter values (@var{head} and @var{tail} -correspondingly) but before insns scheduling of the insn chain. For -example, it can be used for better insn classification if it requires -analysis of dependencies. This hook can use backward and forward -dependencies of the insn scheduler because they are already -calculated. -@end deftypefn @hook TARGET_SCHED_INIT -This hook is executed by the scheduler at the beginning of each block of -instructions that are to be scheduled. @var{file} is either a null -pointer, or a stdio stream to write any debug output to. @var{verbose} -is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@var{max_ready} is the maximum number of insns in the current scheduling -region that can be live at the same time. This can be used to allocate -scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}. -@end deftypefn @hook TARGET_SCHED_FINISH -This hook is executed by the scheduler at the end of each block of -instructions that are to be scheduled. It can be used to perform -cleanup of any actions done by the other scheduling hooks. @var{file} -is either a null pointer, or a stdio stream to write any debug output -to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. -@end deftypefn @hook TARGET_SCHED_INIT_GLOBAL -This hook is executed by the scheduler after function level initializations. -@var{file} is either a null pointer, or a stdio stream to write any debug output to. -@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@var{old_max_uid} is the maximum insn uid when scheduling begins. -@end deftypefn @hook TARGET_SCHED_FINISH_GLOBAL -This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}. -@var{file} is either a null pointer, or a stdio stream to write any debug output to. -@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@end deftypefn @hook TARGET_SCHED_DFA_PRE_CYCLE_INSN -The hook returns an RTL insn. The automaton state used in the -pipeline hazard recognizer is changed as if the insn were scheduled -when the new simulated processor cycle starts. Usage of the hook may -simplify the automaton pipeline description for some @acronym{VLIW} -processors. If the hook is defined, it is used only for the automaton -based pipeline description. The default is not to change the state -when the new simulated processor cycle starts. -@end deftypefn @hook TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN -The hook can be used to initialize data used by the previous hook. -@end deftypefn @hook TARGET_SCHED_DFA_POST_CYCLE_INSN -The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used -to changed the state as if the insn were scheduled when the new -simulated processor cycle finishes. -@end deftypefn @hook TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN -The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but -used to initialize data used by the previous hook. -@end deftypefn @hook TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE -The hook to notify target that the current simulated cycle is about to finish. -The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used -to change the state in more complicated situations - e.g., when advancing -state on a single insn is not enough. -@end deftypefn @hook TARGET_SCHED_DFA_POST_ADVANCE_CYCLE -The hook to notify target that new simulated cycle has just started. -The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used -to change the state in more complicated situations - e.g., when advancing -state on a single insn is not enough. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD -This hook controls better choosing an insn from the ready insn queue -for the @acronym{DFA}-based insn scheduler. Usually the scheduler -chooses the first insn from the queue. If the hook returns a positive -value, an additional scheduler code tries all permutations of -@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ()} -subsequent ready insns to choose an insn whose issue will result in -maximal number of issued insns on the same cycle. For the -@acronym{VLIW} processor, the code could actually solve the problem of -packing simple insns into the @acronym{VLIW} insn. Of course, if the -rules of @acronym{VLIW} packing are described in the automaton. - -This code also could be used for superscalar @acronym{RISC} -processors. Let us consider a superscalar @acronym{RISC} processor -with 3 pipelines. Some insns can be executed in pipelines @var{A} or -@var{B}, some insns can be executed only in pipelines @var{B} or -@var{C}, and one insn can be executed in pipeline @var{B}. The -processor may issue the 1st insn into @var{A} and the 2nd one into -@var{B}. In this case, the 3rd insn will wait for freeing @var{B} -until the next cycle. If the scheduler issues the 3rd insn the first, -the processor could issue all 3 insns per cycle. - -Actually this code demonstrates advantages of the automaton based -pipeline hazard recognizer. We try quickly and easy many insn -schedules to choose the best one. - -The default is no multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD -This hook controls what insns from the ready insn queue will be -considered for the multipass insn scheduling. If the hook returns -zero for @var{insn}, the insn will be not chosen to -be issued. - -The default is that any ready insns can be chosen to be issued. -@end deftypefn - @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN -This hook prepares the target backend for a new round of multipass -scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE -This hook is called when multipass scheduling evaluates instruction INSN. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK -This is called when multipass scheduling backtracks from evaluation of -an instruction. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END -This hook notifies the target about the result of the concluded current -round of multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT -This hook initializes target-specific data used in multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI -This hook finalizes target-specific data used in multipass scheduling. -@end deftypefn @hook TARGET_SCHED_DFA_NEW_CYCLE -This hook is called by the insn scheduler before issuing @var{insn} -on cycle @var{clock}. If the hook returns nonzero, -@var{insn} is not issued on this processor cycle. Instead, -the processor cycle is advanced. If *@var{sort_p} -is zero, the insn ready queue is not sorted on the new cycle -start as usually. @var{dump} and @var{verbose} specify the file and -verbosity level to use for debugging output. -@var{last_clock} and @var{clock} are, respectively, the -processor cycle on which the previous insn has been issued, -and the current processor cycle. -@end deftypefn @hook TARGET_SCHED_IS_COSTLY_DEPENDENCE -This hook is used to define which dependences are considered costly by -the target, so costly that it is not advisable to schedule the insns that -are involved in the dependence too close to one another. The parameters -to this hook are as follows: The first parameter @var{_dep} is the dependence -being evaluated. The second parameter @var{cost} is the cost of the -dependence as estimated by the scheduler, and the third -parameter @var{distance} is the distance in cycles between the two insns. -The hook returns @code{true} if considering the distance between the two -insns the dependence between them is considered costly by the target, -and @code{false} otherwise. - -Defining this hook can be useful in multiple-issue out-of-order machines, -where (a) it's practically hopeless to predict the actual data/resource -delays, however: (b) there's a better chance to predict the actual grouping -that will be formed, and (c) correctly emulating the grouping can be very -important. In such targets one may want to allow issuing dependent insns -closer to one another---i.e., closer than the dependence distance; however, -not in cases of ``costly dependences'', which this hooks allows to define. -@end deftypefn @hook TARGET_SCHED_H_I_D_EXTENDED -This hook is called by the insn scheduler after emitting a new instruction to -the instruction stream. The hook notifies a target backend to extend its -per instruction data structures. -@end deftypefn @hook TARGET_SCHED_ALLOC_SCHED_CONTEXT -Return a pointer to a store large enough to hold target scheduling context. -@end deftypefn @hook TARGET_SCHED_INIT_SCHED_CONTEXT -Initialize store pointed to by @var{tc} to hold target scheduling context. -It @var{clean_p} is true then initialize @var{tc} as if scheduler is at the -beginning of the block. Otherwise, copy the current context into @var{tc}. -@end deftypefn @hook TARGET_SCHED_SET_SCHED_CONTEXT -Copy target scheduling context pointed to by @var{tc} to the current context. -@end deftypefn @hook TARGET_SCHED_CLEAR_SCHED_CONTEXT -Deallocate internal data in target scheduling context pointed to by @var{tc}. -@end deftypefn @hook TARGET_SCHED_FREE_SCHED_CONTEXT -Deallocate a store for target scheduling context pointed to by @var{tc}. -@end deftypefn @hook TARGET_SCHED_SPECULATE_INSN -This hook is called by the insn scheduler when @var{insn} has only -speculative dependencies and therefore can be scheduled speculatively. -The hook is used to check if the pattern of @var{insn} has a speculative -version and, in case of successful check, to generate that speculative -pattern. The hook should return 1, if the instruction has a speculative form, -or @minus{}1, if it doesn't. @var{request} describes the type of requested -speculation. If the return value equals 1 then @var{new_pat} is assigned -the generated speculative pattern. -@end deftypefn @hook TARGET_SCHED_NEEDS_BLOCK_P -This hook is called by the insn scheduler during generation of recovery code -for @var{insn}. It should return @code{true}, if the corresponding check -instruction should branch to recovery code, or @code{false} otherwise. -@end deftypefn @hook TARGET_SCHED_GEN_SPEC_CHECK -This hook is called by the insn scheduler to generate a pattern for recovery -check instruction. If @var{mutate_p} is zero, then @var{insn} is a -speculative instruction for which the check should be generated. -@var{label} is either a label of a basic block, where recovery code should -be emitted, or a null pointer, when requested check doesn't branch to -recovery code (a simple check). If @var{mutate_p} is nonzero, then -a pattern for a branchy check corresponding to a simple check denoted by -@var{insn} should be generated. In this case @var{label} can't be null. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC -This hook is used as a workaround for -@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD} not being -called on the first instruction of the ready list. The hook is used to -discard speculative instructions that stand first in the ready list from -being scheduled on the current cycle. If the hook returns @code{false}, -@var{insn} will not be chosen to be issued. -For non-speculative instructions, -the hook should always return @code{true}. For example, in the ia64 backend -the hook is used to cancel data speculative insns when the ALAT table -is nearly full. -@end deftypefn @hook TARGET_SCHED_SET_SCHED_FLAGS -This hook is used by the insn scheduler to find out what features should be -enabled/used. -The structure *@var{spec_info} should be filled in by the target. -The structure describes speculation types that can be used in the scheduler. -@end deftypefn @hook TARGET_SCHED_SMS_RES_MII -This hook is called by the swing modulo scheduler to calculate a -resource-based lower bound which is based on the resources available in -the machine and the resources required by each instruction. The target -backend can use @var{g} to calculate such bound. A very simple lower -bound will be used in case this hook is not implemented: the total number -of instructions divided by the issue rate. -@end deftypefn @hook TARGET_SCHED_DISPATCH -This hook is called by Haifa Scheduler. It returns true if dispatch scheduling -is supported in hardware and the condition specified in the parameter is true. -@end deftypefn @hook TARGET_SCHED_DISPATCH_DO -This hook is called by Haifa Scheduler. It performs the operation specified -in its second parameter. -@end deftypefn @hook TARGET_SCHED_EXPOSED_PIPELINE @@ -6925,40 +5209,10 @@ This macro is irrelevant if there is no separate readonly data section. @end defmac @hook TARGET_ASM_INIT_SECTIONS -Define this hook if you need to do something special to set up the -@file{varasm.c} sections, or if your target has some special sections -of its own that you need to create. - -GCC calls this hook after processing the command line, but before writing -any assembly code, and before calling any of the section-returning hooks -described below. -@end deftypefn @hook TARGET_ASM_RELOC_RW_MASK -Return a mask describing how relocations should be treated when -selecting sections. Bit 1 should be set if global relocations -should be placed in a read-write section; bit 0 should be set if -local relocations should be placed in a read-write section. - -The default version of this function returns 3 when @option{-fpic} -is in effect, and 0 otherwise. The hook is typically redefined -when the target cannot support (some kinds of) dynamic relocations -in read-only sections even in executables. -@end deftypefn @hook TARGET_ASM_SELECT_SECTION -Return the section into which @var{exp} should be placed. You can -assume that @var{exp} is either a @code{VAR_DECL} node or a constant of -some sort. @var{reloc} indicates whether the initial value of @var{exp} -requires link-time relocations. Bit 0 is set when variable contains -local relocations only, while bit 1 is set for global relocations. -@var{align} is the constant alignment in bits. - -The default version of this function takes care of putting read-only -variables in @code{readonly_data_section}. - -See also @var{USE_SELECT_SECTION_FOR_FUNCTIONS}. -@end deftypefn @defmac USE_SELECT_SECTION_FOR_FUNCTIONS Define this macro if you wish TARGET_ASM_SELECT_SECTION to be called @@ -6970,122 +5224,30 @@ it is unlikely to be called. @end defmac @hook TARGET_ASM_UNIQUE_SECTION -Build up a unique section name, expressed as a @code{STRING_CST} node, -and assign it to @samp{DECL_SECTION_NAME (@var{decl})}. -As with @code{TARGET_ASM_SELECT_SECTION}, @var{reloc} indicates whether -the initial value of @var{exp} requires link-time relocations. - -The default version of this function appends the symbol name to the -ELF section name that would normally be used for the symbol. For -example, the function @code{foo} would be placed in @code{.text.foo}. -Whatever the actual target object format, this is often good enough. -@end deftypefn @hook TARGET_ASM_FUNCTION_RODATA_SECTION -Return the readonly data section associated with -@samp{DECL_SECTION_NAME (@var{decl})}. -The default version of this function selects @code{.gnu.linkonce.r.name} if -the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name} -if function is in @code{.text.name}, and the normal readonly-data section -otherwise. -@end deftypefn @hook TARGET_ASM_MERGEABLE_RODATA_PREFIX @hook TARGET_ASM_TM_CLONE_TABLE_SECTION @hook TARGET_ASM_SELECT_RTX_SECTION -Return the section into which a constant @var{x}, of mode @var{mode}, -should be placed. You can assume that @var{x} is some kind of -constant in RTL@. The argument @var{mode} is redundant except in the -case of a @code{const_int} rtx. @var{align} is the constant alignment -in bits. - -The default version of this function takes care of putting symbolic -constants in @code{flag_pic} mode in @code{data_section} and everything -else in @code{readonly_data_section}. -@end deftypefn @hook TARGET_MANGLE_DECL_ASSEMBLER_NAME -Define this hook if you need to postprocess the assembler name generated -by target-independent code. The @var{id} provided to this hook will be -the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C, -or the mangled name of the @var{decl} in C++). The return value of the -hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on -your target system. The default implementation of this hook just -returns the @var{id} provided. -@end deftypefn @hook TARGET_ENCODE_SECTION_INFO -Define this hook if references to a symbol or a constant must be -treated differently depending on something about the variable or -function named by the symbol (such as what section it is in). - -The hook is executed immediately after rtl has been created for -@var{decl}, which may be a variable or function declaration or -an entry in the constant pool. In either case, @var{rtl} is the -rtl in question. Do @emph{not} use @code{DECL_RTL (@var{decl})} -in this hook; that field may not have been initialized yet. - -In the case of a constant, it is safe to assume that the rtl is -a @code{mem} whose address is a @code{symbol_ref}. Most decls -will also have this form, but that is not guaranteed. Global -register variables, for instance, will have a @code{reg} for their -rtl. (Normally the right thing to do with such unusual rtl is -leave it alone.) - -The @var{new_decl_p} argument will be true if this is the first time -that @code{TARGET_ENCODE_SECTION_INFO} has been invoked on this decl. It will -be false for subsequent invocations, which will happen for duplicate -declarations. Whether or not anything must be done for the duplicate -declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}. -@var{new_decl_p} is always true when the hook is called for a constant. - -@cindex @code{SYMBOL_REF_FLAG}, in @code{TARGET_ENCODE_SECTION_INFO} -The usual thing for this hook to do is to record flags in the -@code{symbol_ref}, using @code{SYMBOL_REF_FLAG} or @code{SYMBOL_REF_FLAGS}. -Historically, the name string was modified if it was necessary to -encode more than one bit of information, but this practice is now -discouraged; use @code{SYMBOL_REF_FLAGS}. - -The default definition of this hook, @code{default_encode_section_info} -in @file{varasm.c}, sets a number of commonly-useful bits in -@code{SYMBOL_REF_FLAGS}. Check whether the default does what you need -before overriding it. -@end deftypefn @hook TARGET_STRIP_NAME_ENCODING -Decode @var{name} and return the real name part, sans -the characters that @code{TARGET_ENCODE_SECTION_INFO} -may have added. -@end deftypefn @hook TARGET_IN_SMALL_DATA_P -Returns true if @var{exp} should be placed into a ``small data'' section. -The default version of this hook always returns false. -@end deftypefn @hook TARGET_HAVE_SRODATA_SECTION -Contains the value true if the target places read-only -``small data'' into a separate section. The default value is false. -@end deftypevr @hook TARGET_PROFILE_BEFORE_PROLOGUE @hook TARGET_BINDS_LOCAL_P -Returns true if @var{exp} names an object for which name resolution -rules must resolve to the current ``module'' (dynamic shared library -or executable image). - -The default version of this hook implements the name resolution rules -for ELF, which has a looser model of global name binding than other -currently supported object file formats. -@end deftypefn @hook TARGET_HAVE_TLS -Contains the value true if the target supports thread-local storage. -The default value is false. -@end deftypevr @node PIC @@ -7166,39 +5328,12 @@ This describes the overall framework of an assembly file. @findex default_file_start @hook TARGET_ASM_FILE_START -Output to @code{asm_out_file} any text which the assembler expects to -find at the beginning of a file. The default behavior is controlled -by two flags, documented below. Unless your target's assembler is -quite unusual, if you override the default, you should call -@code{default_file_start} at some point in your target hook. This -lets other target files rely on these variables. -@end deftypefn @hook TARGET_ASM_FILE_START_APP_OFF -If this flag is true, the text of the macro @code{ASM_APP_OFF} will be -printed as the very first line in the assembly file, unless -@option{-fverbose-asm} is in effect. (If that macro has been defined -to the empty string, this variable has no effect.) With the normal -definition of @code{ASM_APP_OFF}, the effect is to notify the GNU -assembler that it need not bother stripping comments or extra -whitespace from its input. This allows it to work a bit faster. - -The default is false. You should not set it to true unless you have -verified that your port does not generate any extra whitespace or -comments that will cause GAS to issue errors in NO_APP mode. -@end deftypevr @hook TARGET_ASM_FILE_START_FILE_DIRECTIVE -If this flag is true, @code{output_file_directive} will be called -for the primary source file, immediately after printing -@code{ASM_APP_OFF} (if that is enabled). Most ELF assemblers expect -this to be done. The default is false. -@end deftypevr @hook TARGET_ASM_FILE_END -Output to @code{asm_out_file} any text which the assembler expects -to find at the end of a file. The default is to output nothing. -@end deftypefn @deftypefun void file_end_indicate_exec_stack () Some systems use a common convention, the @samp{.note.GNU-stack} @@ -7210,24 +5345,10 @@ this function. @end deftypefun @hook TARGET_ASM_LTO_START -Output to @code{asm_out_file} any text which the assembler expects -to find at the start of an LTO section. The default is to output -nothing. -@end deftypefn @hook TARGET_ASM_LTO_END -Output to @code{asm_out_file} any text which the assembler expects -to find at the end of an LTO section. The default is to output -nothing. -@end deftypefn @hook TARGET_ASM_CODE_END -Output to @code{asm_out_file} any text which is needed before emitting -unwind info and debug info at the end of a file. Some targets emit -here PIC setup thunks that cannot be emitted at the end of file, -because they couldn't have unwind info then. The default is to output -nothing. -@end deftypefn @defmac ASM_COMMENT_START A C string constant describing how to begin a comment in the target @@ -7272,22 +5393,8 @@ of the filename using this macro. @end defmac @hook TARGET_ASM_NAMED_SECTION -Output assembly directives to switch to section @var{name}. The section -should have attributes as specified by @var{flags}, which is a bit mask -of the @code{SECTION_*} flags defined in @file{output.h}. If @var{decl} -is non-NULL, it is the @code{VAR_DECL} or @code{FUNCTION_DECL} with which -this section is associated. -@end deftypefn @hook TARGET_ASM_FUNCTION_SECTION -Return preferred text (sub)section for function @var{decl}. -Main purpose of this function is to separate cold, normal and hot -functions. @var{startup} is true when function is known to be used only -at startup (from static constructors or it is @code{main()}). -@var{exit} is true when function is known to be used only at exit -(from static destructors). -Return NULL if function should go to default text section. -@end deftypefn @hook TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS @@ -7298,74 +5405,12 @@ It must not be modified by command-line option processing. @anchor{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS} @hook TARGET_HAVE_SWITCHABLE_BSS_SECTIONS -This flag is true if we can create zeroed data by switching to a BSS -section and then using @code{ASM_OUTPUT_SKIP} to allocate the space. -This is true on most ELF targets. -@end deftypevr @hook TARGET_SECTION_TYPE_FLAGS -Choose a set of section attributes for use by @code{TARGET_ASM_NAMED_SECTION} -based on a variable or function decl, a section name, and whether or not the -declaration's initializer may contain runtime relocations. @var{decl} may be -null, in which case read-write data should be assumed. - -The default version of this function handles choosing code vs data, -read-only vs read-write data, and @code{flag_pic}. You should only -need to override this if your target has special flags that might be -set via @code{__attribute__}. -@end deftypefn @hook TARGET_ASM_RECORD_GCC_SWITCHES -Provides the target with the ability to record the gcc command line -switches that have been passed to the compiler, and options that are -enabled. The @var{type} argument specifies what is being recorded. -It can take the following values: - -@table @gcctabopt -@item SWITCH_TYPE_PASSED -@var{text} is a command line switch that has been set by the user. - -@item SWITCH_TYPE_ENABLED -@var{text} is an option which has been enabled. This might be as a -direct result of a command line switch, or because it is enabled by -default or because it has been enabled as a side effect of a different -command line switch. For example, the @option{-O2} switch enables -various different individual optimization passes. - -@item SWITCH_TYPE_DESCRIPTIVE -@var{text} is either NULL or some descriptive text which should be -ignored. If @var{text} is NULL then it is being used to warn the -target hook that either recording is starting or ending. The first -time @var{type} is SWITCH_TYPE_DESCRIPTIVE and @var{text} is NULL, the -warning is for start up and the second time the warning is for -wind down. This feature is to allow the target hook to make any -necessary preparations before it starts to record switches and to -perform any necessary tidying up after it has finished recording -switches. - -@item SWITCH_TYPE_LINE_START -This option can be ignored by this target hook. - -@item SWITCH_TYPE_LINE_END -This option can be ignored by this target hook. -@end table - -The hook's return value must be zero. Other return values may be -supported in the future. - -By default this hook is set to NULL, but an example implementation is -provided for ELF based targets. Called @var{elf_record_gcc_switches}, -it records the switches as ASCII text inside a new, string mergeable -section in the assembler output file. The name of the new section is -provided by the @code{TARGET_ASM_RECORD_GCC_SWITCHES_SECTION} target -hook. -@end deftypefn @hook TARGET_ASM_RECORD_GCC_SWITCHES_SECTION -This is the name of the section that will be created by the example -ELF implementation of the @code{TARGET_ASM_RECORD_GCC_SWITCHES} target -hook. -@end deftypevr @need 2000 @node Data Output @@ -7373,49 +5418,10 @@ hook. @hook TARGET_ASM_BYTE_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_HI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_SI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_DI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_TI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_HI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_SI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_DI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_TI_OP -These hooks specify assembly directives for creating certain kinds -of integer object. The @code{TARGET_ASM_BYTE_OP} directive creates a -byte-sized object, the @code{TARGET_ASM_ALIGNED_HI_OP} one creates an -aligned two-byte object, and so on. Any of the hooks may be -@code{NULL}, indicating that no suitable directive is available. - -The compiler will print these strings at the start of a new line, -followed immediately by the object's initial value. In most cases, -the string should contain a tab, a pseudo-op, and then another tab. -@end deftypevr @hook TARGET_ASM_INTEGER -The @code{assemble_integer} function uses this hook to output an -integer object. @var{x} is the object's value, @var{size} is its size -in bytes and @var{aligned_p} indicates whether it is aligned. The -function should return @code{true} if it was able to output the -object. If it returns false, @code{assemble_integer} will try to -split the object into smaller parts. - -The default implementation of this hook will use the -@code{TARGET_ASM_BYTE_OP} family of strings, returning @code{false} -when the relevant string is @code{NULL}. -@end deftypefn @hook TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA -A target hook to recognize @var{rtx} patterns that @code{output_addr_const} -can't deal with, and output assembly code to @var{file} corresponding to -the pattern @var{x}. This may be used to allow machine-dependent -@code{UNSPEC}s to appear within constants. - -If target hook fails to recognize a pattern, it must return @code{false}, -so that a standard error message is printed. If it prints an error message -itself, by calling, for example, @code{output_operand_lossage}, it may just -return @code{true}. -@end deftypefn @defmac ASM_OUTPUT_ASCII (@var{stream}, @var{ptr}, @var{len}) A C statement to output to the stdio stream @var{stream} an assembler @@ -7505,10 +5511,6 @@ the character @samp{;} is treated as a logical line separator. @end defmac @hook TARGET_ASM_OPEN_PAREN -These target hooks are C string constants, describing the syntax in the -assembler for grouping arithmetic expressions. If not overridden, they -default to normal parentheses, which is correct for most assemblers. -@end deftypevr These macros are provided by @file{real.h} for writing the definitions of @code{ASM_OUTPUT_DOUBLE} and the like: @@ -7798,18 +5800,6 @@ You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} and/or @end defmac @hook TARGET_ASM_DECLARE_CONSTANT_NAME -A target hook to output to the stdio stream @var{file} any text necessary -for declaring the name @var{name} of a constant which is being defined. This -target hook is responsible for outputting the label definition (perhaps using -@code{assemble_label}). The argument @var{exp} is the value of the constant, -and @var{size} is the size of the constant in bytes. The @var{name} -will be an internal label. - -The default version of this target hook, define the @var{name} in the -usual manner as a label (by means of @code{assemble_label}). - -You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook. -@end deftypefn @defmac ASM_DECLARE_REGISTER_GLOBAL (@var{stream}, @var{decl}, @var{regno}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7835,21 +5825,8 @@ You may wish to use @code{ASM_OUTPUT_SIZE_DIRECTIVE} and/or @end defmac @hook TARGET_ASM_GLOBALIZE_LABEL -This target hook is a function to output to the stdio stream -@var{stream} some commands that will make the label @var{name} global; -that is, available for reference from other files. - -The default implementation relies on a proper definition of -@code{GLOBAL_ASM_OP}. -@end deftypefn @hook TARGET_ASM_GLOBALIZE_DECL_NAME -This target hook is a function to output to the stdio stream -@var{stream} some commands that will make the name associated with @var{decl} -global; that is, available for reference from other files. - -The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook. -@end deftypefn @defmac ASM_WEAKEN_LABEL (@var{stream}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7921,10 +5898,6 @@ be emitted as one-only. @end defmac @hook TARGET_ASM_ASSEMBLE_VISIBILITY -This target hook is a function to output to @var{asm_out_file} some -commands that will make the symbol(s) associated with @var{decl} have -hidden, protected or internal visibility as specified by @var{visibility}. -@end deftypefn @defmac TARGET_WEAK_NOT_IN_ARCHIVE_TOC A C expression that evaluates to true if the target's linker expects @@ -7957,16 +5930,8 @@ The GNU assembler and most Unix assemblers don't require anything. @end defmac @hook TARGET_ASM_EXTERNAL_LIBCALL -This target hook is a function to output to @var{asm_out_file} an assembler -pseudo-op to declare a library function name external. The name of the -library function is given by @var{symref}, which is a @code{symbol_ref}. -@end deftypefn @hook TARGET_ASM_MARK_DECL_PRESERVED -This target hook is a function to output to @var{asm_out_file} an assembler -directive to annotate @var{symbol} as used. The Darwin target uses the -.no_dead_code_strip directive. -@end deftypefn @defmac ASM_OUTPUT_LABELREF (@var{stream}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7997,21 +5962,6 @@ being taken. @end defmac @hook TARGET_ASM_INTERNAL_LABEL -A function to output to the stdio stream @var{stream} a label whose -name is made from the string @var{prefix} and the number @var{labelno}. - -It is absolutely essential that these labels be distinct from the labels -used for user-level functions and variables. Otherwise, certain programs -will have name conflicts with internal labels. - -It is desirable to exclude internal labels from the symbol table of the -object file. Most assemblers have a naming convention for labels that -should be excluded; on many systems, the letter @samp{L} at the -beginning of a label has this effect. You should find out what -convention your system uses, and follow it. - -The default version of this function utilizes @code{ASM_GENERATE_INTERNAL_LABEL}. -@end deftypefn @defmac ASM_OUTPUT_DEBUG_LABEL (@var{stream}, @var{prefix}, @var{num}) A C statement to output to the stdio stream @var{stream} a debug info @@ -8322,30 +6272,10 @@ encountering an @code{init_priority} attribute. @end defmac @hook TARGET_HAVE_CTORS_DTORS -This value is true if the target supports some ``native'' method of -collecting constructors and destructors to be run at startup and exit. -It is false if we must use @command{collect2}. -@end deftypevr @hook TARGET_ASM_CONSTRUCTOR -If defined, a function that outputs assembler code to arrange to call -the function referenced by @var{symbol} at initialization time. - -Assume that @var{symbol} is a @code{SYMBOL_REF} for a function taking -no arguments and with no return value. If the target supports initialization -priorities, @var{priority} is a value between 0 and @code{MAX_INIT_PRIORITY}; -otherwise it must be @code{DEFAULT_INIT_PRIORITY}. - -If this macro is not defined by the target, a suitable default will -be chosen if (1) the target supports arbitrary section names, (2) the -target defines @code{CTORS_SECTION_ASM_OP}, or (3) @code{USE_COLLECT2} -is not defined. -@end deftypefn @hook TARGET_ASM_DESTRUCTOR -This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination -functions rather than initialization functions. -@end deftypefn If @code{TARGET_HAVE_CTORS_DTORS} is true, the initialization routine generated for the generated object file will have static linkage. @@ -8492,17 +6422,6 @@ If this macro is not defined, it is equivalent to a null statement. @end defmac @hook TARGET_ASM_FINAL_POSTSCAN_INSN -If defined, this target hook is a function which is executed just after the -output of assembler code for @var{insn}, to change the mode of the assembler -if necessary. - -Here the argument @var{opvec} is the vector containing the operands -extracted from @var{insn}, and @var{noperands} is the number of -elements of the vector which contain meaningful data for this insn. -The contents of this vector are what was used to convert the insn -template into assembler code, so you can change the assembler mode -by checking the contents of the vector. -@end deftypefn @defmac PRINT_OPERAND (@var{stream}, @var{x}, @var{code}) A C compound statement to output to stdio stream @var{stream} the @@ -8712,32 +6631,12 @@ the jump-table. @end defmac @hook TARGET_ASM_EMIT_UNWIND_LABEL -This target hook emits a label at the beginning of each FDE@. It -should be defined on targets where FDEs need special labels, and it -should write the appropriate label, for the FDE associated with the -function declaration @var{decl}, to the stdio stream @var{stream}. -The third argument, @var{for_eh}, is a boolean: true if this is for an -exception table. The fourth argument, @var{empty}, is a boolean: -true if this is a placeholder label for an omitted FDE@. - -The default is that FDEs are not given nonlocal labels. -@end deftypefn @hook TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL -This target hook emits a label at the beginning of the exception table. -It should be defined on targets where it is desirable for the table -to be broken up according to function. - -The default is that no label is emitted. -@end deftypefn @hook TARGET_ASM_EMIT_EXCEPT_PERSONALITY @hook TARGET_ASM_UNWIND_EMIT -This target hook emits assembly directives required to unwind the -given instruction. This is only used when @code{TARGET_EXCEPT_UNWIND_INFO} -returns @code{UI_TARGET}. -@end deftypefn @hook TARGET_ASM_UNWIND_EMIT_BEFORE_INSN @@ -8845,43 +6744,14 @@ the target supports DWARF 2 frame unwind information. @end defmac @hook TARGET_TERMINATE_DW2_EH_FRAME_INFO -Contains the value true if the target should add a zero word onto the -end of a Dwarf-2 frame info section when used for exception handling. -Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and -true otherwise. -@end deftypevr @hook TARGET_DWARF_REGISTER_SPAN -Given a register, this hook should return a parallel of registers to -represent where to find the register pieces. Define this hook if the -register and its mode are represented in Dwarf in non-contiguous -locations, or if the register should be represented in more than one -register in Dwarf. Otherwise, this hook should return @code{NULL_RTX}. -If not defined, the default is to return @code{NULL_RTX}. -@end deftypefn @hook TARGET_INIT_DWARF_REG_SIZES_EXTRA -If some registers are represented in Dwarf-2 unwind information in -multiple pieces, define this hook to fill in information about the -sizes of those pieces in the table used by the unwinder at runtime. -It will be called by @code{expand_builtin_init_dwarf_reg_sizes} after -filling in a single size corresponding to each hard register; -@var{address} is the address of the table. -@end deftypefn @hook TARGET_ASM_TTYPE -This hook is used to output a reference from a frame unwinding table to -the type_info object identified by @var{sym}. It should return @code{true} -if the reference was output. Returning @code{false} will cause the -reference to be output using the normal Dwarf2 routines. -@end deftypefn @hook TARGET_ARM_EABI_UNWINDER -This flag should be set to @code{true} on targets that use an ARM EABI -based unwinding library, and @code{false} on other targets. This effects -the format of unwinding tables, and how the unwinder in entered after -running a cleanup. The default is @code{false}. -@end deftypevr @node Alignment Output @subsection Assembler Commands for Alignment @@ -8904,10 +6774,6 @@ selection in @var{align_jumps} in a @code{JUMP_ALIGN} implementation. @end defmac @hook TARGET_ASM_JUMP_ALIGN_MAX_SKIP -The maximum number of bytes to skip before @var{label} when applying -@code{JUMP_ALIGN}. This works only if -@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined. -@end deftypefn @defmac LABEL_ALIGN_AFTER_BARRIER (@var{label}) The alignment (log base 2) to put in front of @var{label}, which follows @@ -8919,10 +6785,6 @@ define the macro. @end defmac @hook TARGET_ASM_LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP -The maximum number of bytes to skip before @var{label} when applying -@code{LABEL_ALIGN_AFTER_BARRIER}. This works only if -@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined. -@end deftypefn @defmac LOOP_ALIGN (@var{label}) The alignment (log base 2) to put in front of @var{label} that heads @@ -8939,10 +6801,6 @@ selection in @code{align_loops} in a @code{LOOP_ALIGN} implementation. @end defmac @hook TARGET_ASM_LOOP_ALIGN_MAX_SKIP -The maximum number of bytes to skip when applying @code{LOOP_ALIGN} to -@var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} is -defined. -@end deftypefn @defmac LABEL_ALIGN (@var{label}) The alignment (log base 2) to put in front of @var{label}. @@ -8956,10 +6814,6 @@ selection in @code{align_labels} in a @code{LABEL_ALIGN} implementation. @end defmac @hook TARGET_ASM_LABEL_ALIGN_MAX_SKIP -The maximum number of bytes to skip when applying @code{LABEL_ALIGN} -to @var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} -is defined. -@end deftypefn @defmac ASM_OUTPUT_SKIP (@var{stream}, @var{nbytes}) A C statement to output to the stdio stream @var{stream} an assembler @@ -9302,10 +7156,6 @@ Define this macro if GCC should produce dwarf version 2 format debugging output in response to the @option{-g} option. @hook TARGET_DWARF_CALLING_CONVENTION -Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to -be emitted for each function. Instead of an integer return the enum -value for the @code{DW_CC_} tag. -@end deftypefn To support optional call frame debugging information, you must also define @code{INCOMING_RETURN_ADDR_RTX} and either set @@ -9323,17 +7173,6 @@ how you define @code{DWARF2_FRAME_INFO}. @end defmac @hook TARGET_DEBUG_UNWIND_INFO -This hook defines the mechanism that will be used for describing frame -unwind information to the debugger. Normally the hook will return -@code{UI_DWARF2} if DWARF 2 debug information is enabled, and -return @code{UI_NONE} otherwise. - -A target may return @code{UI_DWARF2} even when DWARF 2 debug information -is disabled in order to always output DWARF 2 frame information. - -A target may return @code{UI_TARGET} if it has ABI specified unwind tables. -This will suppress generation of the normal debug frame unwind information. -@end deftypefn @defmac DWARF2_ASM_LINE_DEBUG_INFO Define this macro to be a nonzero value if the assembler can generate Dwarf 2 @@ -9379,9 +7218,6 @@ is referenced by a function. @end defmac @hook TARGET_ASM_OUTPUT_DWARF_DTPREL -If defined, this target hook is a function which outputs a DTP-relative -reference to the given TLS symbol of the specified size. -@end deftypefn @defmac PUT_SDB_@dots{} Define these macros to override the assembler syntax for the special @@ -9633,64 +7469,16 @@ These are described using the following target hooks; they also need to be documented in @file{extend.texi}. @hook TARGET_ATTRIBUTE_TABLE -If defined, this target hook points to an array of @samp{struct -attribute_spec} (defined in @file{tree.h}) specifying the machine -specific attributes for this target and some of the restrictions on the -entities to which these attributes are applied and the arguments they -take. -@end deftypevr @hook TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P -If defined, this target hook is a function which returns true if the -machine-specific attribute named @var{name} expects an identifier -given as its first argument to be passed on as a plain identifier, not -subjected to name lookup. If this is not defined, the default is -false for all machine-specific attributes. -@end deftypefn @hook TARGET_COMP_TYPE_ATTRIBUTES -If defined, this target hook is a function which returns zero if the attributes on -@var{type1} and @var{type2} are incompatible, one if they are compatible, -and two if they are nearly compatible (which causes a warning to be -generated). If this is not defined, machine-specific attributes are -supposed always to be compatible. -@end deftypefn @hook TARGET_SET_DEFAULT_TYPE_ATTRIBUTES -If defined, this target hook is a function which assigns default attributes to -the newly defined @var{type}. -@end deftypefn @hook TARGET_MERGE_TYPE_ATTRIBUTES -Define this target hook if the merging of type attributes needs special -handling. If defined, the result is a list of the combined -@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed -that @code{comptypes} has already been called and returned 1. This -function may call @code{merge_attributes} to handle machine-independent -merging. -@end deftypefn @hook TARGET_MERGE_DECL_ATTRIBUTES -Define this target hook if the merging of decl attributes needs special -handling. If defined, the result is a list of the combined -@code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}. -@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of -when this is needed are when one attribute overrides another, or when an -attribute is nullified by a subsequent definition. This function may -call @code{merge_attributes} to handle machine-independent merging. - -@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES -If the only target-specific handling you require is @samp{dllimport} -for Microsoft Windows targets, you should define the macro -@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES} to @code{1}. The compiler -will then define a function called -@code{merge_dllimport_decl_attributes} which can then be defined as -the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also -add @code{handle_dll_attribute} in the attribute table for your port -to perform initial processing of the @samp{dllimport} and -@samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and -@file{i386/i386.c}, for example. -@end deftypefn @hook TARGET_VALID_DLLIMPORT_ATTRIBUTE_P @@ -9704,92 +7492,24 @@ on this implementation detail. @end defmac @hook TARGET_INSERT_ATTRIBUTES -Define this target hook if you want to be able to add attributes to a decl -when it is being created. This is normally useful for back ends which -wish to implement a pragma by using the attributes which correspond to -the pragma's effect. The @var{node} argument is the decl which is being -created. The @var{attr_ptr} argument is a pointer to the attribute list -for this decl. The list itself should not be modified, since it may be -shared with other decls, but attributes may be chained on the head of -the list and @code{*@var{attr_ptr}} modified to point to the new -attributes, or a copy of the list may be made if further changes are -needed. -@end deftypefn @hook TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P -@cindex inlining -This target hook returns @code{true} if it is ok to inline @var{fndecl} -into the current function, despite its having target-specific -attributes, @code{false} otherwise. By default, if a function has a -target specific attribute attached to it, it will not be inlined. -@end deftypefn @hook TARGET_OPTION_VALID_ATTRIBUTE_P -This hook is called to parse @code{attribute(target("..."))}, which -allows setting target-specific options on individual functions. -These function-specific options may differ -from the options specified on the command line. The hook should return -@code{true} if the options are valid. - -The hook should set the @code{DECL_FUNCTION_SPECIFIC_TARGET} field in -the function declaration to hold a pointer to a target-specific -@code{struct cl_target_option} structure. -@end deftypefn @hook TARGET_OPTION_SAVE -This hook is called to save any additional target-specific information -in the @code{struct cl_target_option} structure for function-specific -options. -@xref{Option file format}. -@end deftypefn @hook TARGET_OPTION_RESTORE -This hook is called to restore any additional target-specific -information in the @code{struct cl_target_option} structure for -function-specific options. -@end deftypefn @hook TARGET_OPTION_PRINT -This hook is called to print any additional target-specific -information in the @code{struct cl_target_option} structure for -function-specific options. -@end deftypefn @hook TARGET_OPTION_PRAGMA_PARSE -This target hook parses the options for @code{#pragma GCC target}, which -sets the target-specific options for functions that occur later in the -input stream. The options accepted should be the same as those handled by the -@code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook. -@end deftypefn @hook TARGET_OPTION_OVERRIDE -Sometimes certain combinations of command options do not make sense on -a particular target machine. You can override the hook -@code{TARGET_OPTION_OVERRIDE} to take account of this. This hooks is called -once just after all the command options have been parsed. - -Don't use this hook to turn on various extra optimizations for -@option{-O}. That is what @code{TARGET_OPTION_OPTIMIZATION} is for. - -If you need to do something whenever the optimization level is -changed via the optimize attribute or pragma, see -@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE} -@end deftypefn @hook TARGET_OPTION_FUNCTION_VERSIONS -This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are -versions of the same function. @var{DECL1} and @var{DECL2} are function -versions if and only if they have the same function signature and -different target specific attributes, that is, they are compiled for -different target machines. -@end deftypefn @hook TARGET_CAN_INLINE_P -This target hook returns @code{false} if the @var{caller} function -cannot inline @var{callee}, based on target specific information. By -default, inlining is not allowed if the callee function has function -specific target options and the caller does not use the same options. -@end deftypefn @node Emulated TLS @section Emulating TLS @@ -9808,66 +7528,24 @@ which, when given the address of the control object, will return the address of the current thread's instance of the TLS object. @hook TARGET_EMUTLS_GET_ADDRESS -Contains the name of the helper function that uses a TLS control -object to locate a TLS instance. The default causes libgcc's -emulated TLS helper function to be used. -@end deftypevr @hook TARGET_EMUTLS_REGISTER_COMMON -Contains the name of the helper function that should be used at -program startup to register TLS objects that are implicitly -initialized to zero. If this is @code{NULL}, all TLS objects will -have explicit initializers. The default causes libgcc's emulated TLS -registration function to be used. -@end deftypevr @hook TARGET_EMUTLS_VAR_SECTION -Contains the name of the section in which TLS control variables should -be placed. The default of @code{NULL} allows these to be placed in -any section. -@end deftypevr @hook TARGET_EMUTLS_TMPL_SECTION -Contains the name of the section in which TLS initializers should be -placed. The default of @code{NULL} allows these to be placed in any -section. -@end deftypevr @hook TARGET_EMUTLS_VAR_PREFIX -Contains the prefix to be prepended to TLS control variable names. -The default of @code{NULL} uses a target-specific prefix. -@end deftypevr @hook TARGET_EMUTLS_TMPL_PREFIX -Contains the prefix to be prepended to TLS initializer objects. The -default of @code{NULL} uses a target-specific prefix. -@end deftypevr @hook TARGET_EMUTLS_VAR_FIELDS -Specifies a function that generates the FIELD_DECLs for a TLS control -object type. @var{type} is the RECORD_TYPE the fields are for and -@var{name} should be filled with the structure tag, if the default of -@code{__emutls_object} is unsuitable. The default creates a type suitable -for libgcc's emulated TLS function. -@end deftypefn @hook TARGET_EMUTLS_VAR_INIT -Specifies a function that generates the CONSTRUCTOR to initialize a -TLS control object. @var{var} is the TLS control object, @var{decl} -is the TLS object and @var{tmpl_addr} is the address of the -initializer. The default initializes libgcc's emulated TLS control object. -@end deftypefn @hook TARGET_EMUTLS_VAR_ALIGN_FIXED -Specifies whether the alignment of TLS control variable objects is -fixed and should not be increased as some backends may do to optimize -single objects. The default is false. -@end deftypevr @hook TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS -Specifies whether a DWARF @code{DW_OP_form_tls_address} location descriptor -may be used to describe emulated TLS control objects. -@end deftypevr @node MIPS Coprocessors @section Defining coprocessor specifics for MIPS targets. @@ -9905,33 +7583,10 @@ you may want to override in subtargets; it is described below. @cindex parameters, precompiled headers @hook TARGET_GET_PCH_VALIDITY -This hook returns a pointer to the data needed by -@code{TARGET_PCH_VALID_P} and sets -@samp{*@var{sz}} to the size of the data in bytes. -@end deftypefn @hook TARGET_PCH_VALID_P -This hook checks whether the options used to create a PCH file are -compatible with the current settings. It returns @code{NULL} -if so and a suitable error message if not. Error messages will -be presented to the user and must be localized using @samp{_(@var{msg})}. - -@var{data} is the data that was returned by @code{TARGET_GET_PCH_VALIDITY} -when the PCH file was created and @var{sz} is the size of that data in bytes. -It's safe to assume that the data was created by the same version of the -compiler, so no format checking is needed. - -The default definition of @code{default_pch_valid_p} should be -suitable for most targets. -@end deftypefn @hook TARGET_CHECK_PCH_TARGET_FLAGS -If this hook is nonnull, the default implementation of -@code{TARGET_PCH_VALID_P} will use it to check for compatible values -of @code{target_flags}. @var{pch_flags} specifies the value that -@code{target_flags} had when the PCH file was created. The return -value is the same as for @code{TARGET_PCH_VALID_P}. -@end deftypefn @hook TARGET_PREPARE_PCH_SAVE @@ -9940,84 +7595,28 @@ value is the same as for @code{TARGET_PCH_VALID_P}. @cindex parameters, c++ abi @hook TARGET_CXX_GUARD_TYPE -Define this hook to override the integer type used for guard variables. -These are used to implement one-time construction of static objects. The -default is long_long_integer_type_node. -@end deftypefn @hook TARGET_CXX_GUARD_MASK_BIT -This hook determines how guard variables are used. It should return -@code{false} (the default) if the first byte should be used. A return value of -@code{true} indicates that only the least significant bit should be used. -@end deftypefn @hook TARGET_CXX_GET_COOKIE_SIZE -This hook returns the size of the cookie to use when allocating an array -whose elements have the indicated @var{type}. Assumes that it is already -known that a cookie is needed. The default is -@code{max(sizeof (size_t), alignof(type))}, as defined in section 2.7 of the -IA64/Generic C++ ABI@. -@end deftypefn @hook TARGET_CXX_COOKIE_HAS_SIZE -This hook should return @code{true} if the element size should be stored in -array cookies. The default is to return @code{false}. -@end deftypefn @hook TARGET_CXX_IMPORT_EXPORT_CLASS -If defined by a backend this hook allows the decision made to export -class @var{type} to be overruled. Upon entry @var{import_export} -will contain 1 if the class is going to be exported, @minus{}1 if it is going -to be imported and 0 otherwise. This function should return the -modified value and perform any other actions necessary to support the -backend's targeted operating system. -@end deftypefn @hook TARGET_CXX_CDTOR_RETURNS_THIS -This hook should return @code{true} if constructors and destructors return -the address of the object created/destroyed. The default is to return -@code{false}. -@end deftypefn @hook TARGET_CXX_KEY_METHOD_MAY_BE_INLINE -This hook returns true if the key method for a class (i.e., the method -which, if defined in the current translation unit, causes the virtual -table to be emitted) may be an inline function. Under the standard -Itanium C++ ABI the key method may be an inline function so long as -the function is not declared inline in the class definition. Under -some variants of the ABI, an inline function can never be the key -method. The default is to return @code{true}. -@end deftypefn @hook TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY @hook TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT -This hook returns true (the default) if virtual tables and other -similar implicit class data objects are always COMDAT if they have -external linkage. If this hook returns false, then class data for -classes whose virtual table will be emitted in only one translation -unit will not be COMDAT. -@end deftypefn @hook TARGET_CXX_LIBRARY_RTTI_COMDAT -This hook returns true (the default) if the RTTI information for -the basic types which is defined in the C++ runtime should always -be COMDAT, false if it should not be COMDAT. -@end deftypefn @hook TARGET_CXX_USE_AEABI_ATEXIT -This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI) -should be used to register static destructors when @option{-fuse-cxa-atexit} -is in effect. The default is to return false to use @code{__cxa_atexit}. -@end deftypefn @hook TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT -This hook returns true if the target @code{atexit} function can be used -in the same manner as @code{__cxa_atexit} to register C++ static -destructors. This requires that @code{atexit}-registered functions in -shared libraries are run in the correct order when the libraries are -unloaded. The default is to return false. -@end deftypefn @hook TARGET_CXX_ADJUST_CLASS_AT_DEFINITION @@ -10062,62 +7661,18 @@ c_register_addr_space ("__ea", ADDR_SPACE_EA); @end smallexample @hook TARGET_ADDR_SPACE_POINTER_MODE -Define this to return the machine mode to use for pointers to -@var{address_space} if the target supports named address spaces. -The default version of this hook returns @code{ptr_mode} for the -generic address space only. -@end deftypefn @hook TARGET_ADDR_SPACE_ADDRESS_MODE -Define this to return the machine mode to use for addresses in -@var{address_space} if the target supports named address spaces. -The default version of this hook returns @code{Pmode} for the -generic address space only. -@end deftypefn @hook TARGET_ADDR_SPACE_VALID_POINTER_MODE -Define this to return nonzero if the port can handle pointers -with machine mode @var{mode} to address space @var{as}. This target -hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook, -except that it includes explicit named address space support. The default -version of this hook returns true for the modes returned by either the -@code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE} -target hooks for the given address space. -@end deftypefn @hook TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P -Define this to return true if @var{exp} is a valid address for mode -@var{mode} in the named address space @var{as}. The @var{strict} -parameter says whether strict addressing is in effect after reload has -finished. This target hook is the same as the -@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes -explicit named address space support. -@end deftypefn @hook TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS -Define this to modify an invalid address @var{x} to be a valid address -with mode @var{mode} in the named address space @var{as}. This target -hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook, -except that it includes explicit named address space support. -@end deftypefn @hook TARGET_ADDR_SPACE_SUBSET_P -Define this to return whether the @var{subset} named address space is -contained within the @var{superset} named address space. Pointers to -a named address space that is a subset of another named address space -will be converted automatically without a cast if used together in -arithmetic operations. Pointers to a superset address space can be -converted to pointers to a subset address space via explicit casts. -@end deftypefn @hook TARGET_ADDR_SPACE_CONVERT -Define this to convert the pointer expression represented by the RTL -@var{op} with type @var{from_type} that points to a named address -space to a new pointer expression with type @var{to_type} that points -to a different named address space. When this hook it called, it is -guaranteed that one of the two address spaces is a subset of the other, -as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook. -@end deftypefn @node Misc @section Miscellaneous Parameters @@ -10168,11 +7723,6 @@ is in effect. @end defmac @hook TARGET_CASE_VALUES_THRESHOLD -This function return the smallest number of different values for which it -is best to use a jump-table instead of a tree of conditional branches. -The default is four for machines with a @code{casesi} instruction and -five otherwise. This is best for most machines. -@end deftypefn @defmac WORD_REGISTER_OPERATIONS Define this macro if operations between registers with integral mode @@ -10213,13 +7763,6 @@ extends. @end defmac @hook TARGET_MIN_DIVISIONS_FOR_RECIP_MUL -When @option{-ffast-math} is in effect, GCC tries to optimize -divisions by the same divisor, by turning them into multiplications by -the reciprocal. This target hook specifies the minimum number of divisions -that should be there for GCC to perform the optimization for a variable -of mode @var{mode}. The default implementation returns 3 if the machine -has an instruction for the division, and 2 if it does not. -@end deftypefn @defmac MOVE_MAX The maximum number of bytes that a single instruction can move quickly @@ -10261,28 +7804,6 @@ You need not define this macro if it would always have the value of zero. @anchor{TARGET_SHIFT_TRUNCATION_MASK} @hook TARGET_SHIFT_TRUNCATION_MASK -This function describes how the standard shift patterns for @var{mode} -deal with shifts by negative amounts or by more than the width of the mode. -@xref{shift patterns}. - -On many machines, the shift patterns will apply a mask @var{m} to the -shift count, meaning that a fixed-width shift of @var{x} by @var{y} is -equivalent to an arbitrary-width shift of @var{x} by @var{y & m}. If -this is true for mode @var{mode}, the function should return @var{m}, -otherwise it should return 0. A return value of 0 indicates that no -particular behavior is guaranteed. - -Note that, unlike @code{SHIFT_COUNT_TRUNCATED}, this function does -@emph{not} apply to general shift rtxes; it applies only to instructions -that are generated by the named shift patterns. - -The default implementation of this function returns -@code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED} -and 0 otherwise. This definition is always safe, but if -@code{SHIFT_COUNT_TRUNCATED} is false, and some shift patterns -nevertheless truncate the shift count, you may get better code -by overriding it. -@end deftypefn @defmac TRULY_NOOP_TRUNCATION (@var{outprec}, @var{inprec}) A C expression which is nonzero if on this machine it is safe to @@ -10301,32 +7822,6 @@ such cases may improve things. @end defmac @hook TARGET_MODE_REP_EXTENDED -The representation of an integral mode can be such that the values -are always extended to a wider integral mode. Return -@code{SIGN_EXTEND} if values of @var{mode} are represented in -sign-extended form to @var{rep_mode}. Return @code{UNKNOWN} -otherwise. (Currently, none of the targets use zero-extended -representation this way so unlike @code{LOAD_EXTEND_OP}, -@code{TARGET_MODE_REP_EXTENDED} is expected to return either -@code{SIGN_EXTEND} or @code{UNKNOWN}. Also no target extends -@var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next -widest integral mode and currently we take advantage of this fact.) - -Similarly to @code{LOAD_EXTEND_OP} you may return a non-@code{UNKNOWN} -value even if the extension is not performed on certain hard registers -as long as for the @code{REGNO_REG_CLASS} of these hard registers -@code{CANNOT_CHANGE_MODE_CLASS} returns nonzero. - -Note that @code{TARGET_MODE_REP_EXTENDED} and @code{LOAD_EXTEND_OP} -describe two related properties. If you define -@code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want -to define @code{LOAD_EXTEND_OP (mode)} to return the same type of -extension. - -In order to enforce the representation of @code{mode}, -@code{TRULY_NOOP_TRUNCATION} should return false when truncating to -@code{mode}. -@end deftypefn @defmac STORE_FLAG_VALUE A C expression describing the value returned by a comparison operator @@ -10629,15 +8124,6 @@ You need not define this macro if it would always evaluate to zero. @end defmac @hook TARGET_MD_ASM_CLOBBERS -This target hook should add to @var{clobbers} @code{STRING_CST} trees for -any hard regs the port wishes to automatically clobber for an asm. -It should return the result of the last @code{tree_cons} used to add a -clobber. The @var{outputs}, @var{inputs} and @var{clobber} lists are the -corresponding parameters to the asm and may be inspected to avoid -clobbering a register that is an input or output of the asm. You can use -@code{tree_overlaps_hard_reg_set}, declared in @file{tree.h}, to test -for overlap with regards to asm-declared registers. -@end deftypefn @defmac MATH_LIBRARY Define this macro as a C string constant for the linker argument to link @@ -10718,119 +8204,27 @@ to by @var{ce_info}. @end defmac @hook TARGET_MACHINE_DEPENDENT_REORG -If non-null, this hook performs a target-specific pass over the -instruction stream. The compiler will run it at all optimization levels, -just before the point at which it normally does delayed-branch scheduling. - -The exact purpose of the hook varies from target to target. Some use -it to do transformations that are necessary for correctness, such as -laying out in-function constant pools or avoiding hardware hazards. -Others use it as an opportunity to do some machine-dependent optimizations. - -You need not implement the hook if it has nothing to do. The default -definition is null. -@end deftypefn @hook TARGET_INIT_BUILTINS -Define this hook if you have any machine-specific built-in functions -that need to be defined. It should be a function that performs the -necessary setup. - -Machine specific built-in functions can be useful to expand special machine -instructions that would otherwise not normally be generated because -they have no equivalent in the source language (for example, SIMD vector -instructions or prefetch instructions). - -To create a built-in function, call the function -@code{lang_hooks.builtin_function} -which is defined by the language front end. You can use any type nodes set -up by @code{build_common_tree_nodes}; -only language front ends that use those two functions will call -@samp{TARGET_INIT_BUILTINS}. -@end deftypefn @hook TARGET_BUILTIN_DECL -Define this hook if you have any machine-specific built-in functions -that need to be defined. It should be a function that returns the -builtin function declaration for the builtin function code @var{code}. -If there is no such builtin and it cannot be initialized at this time -if @var{initialize_p} is true the function should return @code{NULL_TREE}. -If @var{code} is out of range the function should return -@code{error_mark_node}. -@end deftypefn @hook TARGET_EXPAND_BUILTIN -Expand a call to a machine specific built-in function that was set up by -@samp{TARGET_INIT_BUILTINS}. @var{exp} is the expression for the -function call; the result should go to @var{target} if that is -convenient, and have mode @var{mode} if that is convenient. -@var{subtarget} may be used as the target for computing one of -@var{exp}'s operands. @var{ignore} is nonzero if the value is to be -ignored. This function should return the result of the call to the -built-in function. -@end deftypefn - @hook TARGET_RESOLVE_OVERLOADED_BUILTIN -Select a replacement for a machine specific built-in function that -was set up by @samp{TARGET_INIT_BUILTINS}. This is done -@emph{before} regular type checking, and so allows the target to -implement a crude form of function overloading. @var{fndecl} is the -declaration of the built-in function. @var{arglist} is the list of -arguments passed to the built-in function. The result is a -complete expression that implements the operation, usually -another @code{CALL_EXPR}. -@var{arglist} really has type @samp{VEC(tree,gc)*} -@end deftypefn @hook TARGET_FOLD_BUILTIN -Fold a call to a machine specific built-in function that was set up by -@samp{TARGET_INIT_BUILTINS}. @var{fndecl} is the declaration of the -built-in function. @var{n_args} is the number of arguments passed to -the function; the arguments themselves are pointed to by @var{argp}. -The result is another tree, valid for both GIMPLE and GENERIC, -containing a simplified expression for the call's result. If -@var{ignore} is true the value will be ignored. -@end deftypefn @hook TARGET_GIMPLE_FOLD_BUILTIN @hook TARGET_COMPARE_VERSION_PRIORITY -This hook is used to compare the target attributes in two functions to -determine which function's features get higher priority. This is used -during function multi-versioning to figure out the order in which two -versions must be dispatched. A function version with a higher priority -is checked for dispatching earlier. @var{decl1} and @var{decl2} are - the two function decls that will be compared. -@end deftypefn @hook TARGET_GET_FUNCTION_VERSIONS_DISPATCHER -This hook is used to get the dispatcher function for a set of function -versions. The dispatcher function is called to invoke the right function -version at run-time. @var{decl} is one version from a set of semantically -identical versions. -@end deftypefn @hook TARGET_GENERATE_VERSION_DISPATCHER_BODY -This hook is used to generate the dispatcher logic to invoke the right -function version at run-time for a given set of function versions. -@var{arg} points to the callgraph node of the dispatcher function whose -body must be generated. -@end deftypefn @hook TARGET_INVALID_WITHIN_DOLOOP -Take an instruction in @var{insn} and return NULL if it is valid within a -low-overhead loop, otherwise return a string explaining why doloop -could not be applied. - -Many targets use special registers for low-overhead looping. For any -instruction that clobbers these this function should return a string indicating -the reason why the doloop could not be applied. -By default, the RTL loop optimizer does not use a present doloop pattern for -loops containing function calls or branch on table instructions. -@end deftypefn - @hook TARGET_LEGITIMATE_COMBINED_INSN @defmac MD_CAN_REDIRECT_BRANCH (@var{branch1}, @var{branch2}) @@ -10847,61 +8241,12 @@ may in turn cause a branch offset to overflow. @hook TARGET_CAN_FOLLOW_JUMP @hook TARGET_COMMUTATIVE_P -This target hook returns @code{true} if @var{x} is considered to be commutative. -Usually, this is just COMMUTATIVE_P (@var{x}), but the HP PA doesn't consider -PLUS to be commutative inside a MEM@. @var{outer_code} is the rtx code -of the enclosing rtl, if known, otherwise it is UNKNOWN. -@end deftypefn @hook TARGET_ALLOCATE_INITIAL_VALUE -When the initial value of a hard register has been copied in a pseudo -register, it is often not necessary to actually allocate another register -to this pseudo register, because the original hard register or a stack slot -it has been saved into can be used. @code{TARGET_ALLOCATE_INITIAL_VALUE} -is called at the start of register allocation once for each hard register -that had its initial value copied by using -@code{get_func_hard_reg_initial_val} or @code{get_hard_reg_initial_val}. -Possible values are @code{NULL_RTX}, if you don't want -to do any special allocation, a @code{REG} rtx---that would typically be -the hard register itself, if it is known not to be clobbered---or a -@code{MEM}. -If you are returning a @code{MEM}, this is only a hint for the allocator; -it might decide to use another register anyways. -You may use @code{current_function_is_leaf} or -@code{REG_N_SETS} in the hook to determine if the hard -register in question will not be clobbered. -The default value of this hook is @code{NULL}, which disables any special -allocation. -@end deftypefn - @hook TARGET_UNSPEC_MAY_TRAP_P -This target hook returns nonzero if @var{x}, an @code{unspec} or -@code{unspec_volatile} operation, might cause a trap. Targets can use -this hook to enhance precision of analysis for @code{unspec} and -@code{unspec_volatile} operations. You may call @code{may_trap_p_1} -to analyze inner elements of @var{x} in which case @var{flags} should be -passed along. -@end deftypefn @hook TARGET_SET_CURRENT_FUNCTION -The compiler invokes this hook whenever it changes its current function -context (@code{cfun}). You can define this function if -the back end needs to perform any initialization or reset actions on a -per-function basis. For example, it may be used to implement function -attributes that affect register usage or code generation patterns. -The argument @var{decl} is the declaration for the new function context, -and may be null to indicate that the compiler has left a function context -and is returning to processing at the top level. -The default hook function does nothing. - -GCC sets @code{cfun} to a dummy function context during initialization of -some parts of the back end. The hook function is not invoked in this -situation; you need not worry about the hook being invoked recursively, -or when the back end is in a partially-initialized state. -@code{cfun} might be @code{NULL} to indicate processing at top level, -outside of any function scope. -@end deftypefn @defmac TARGET_OBJECT_SUFFIX Define this macro to be a C string representing the suffix for object @@ -10941,56 +8286,14 @@ build_type_attribute_variant (@var{mdecl}, @end defmac @hook TARGET_CANNOT_MODIFY_JUMPS_P -This target hook returns @code{true} past the point in which new jump -instructions could be created. On machines that require a register for -every jump such as the SHmedia ISA of SH5, this point would typically be -reload, so this target hook should be defined to a function such as: - -@smallexample -static bool -cannot_modify_jumps_past_reload_p () -@{ - return (reload_completed || reload_in_progress); -@} -@end smallexample -@end deftypefn @hook TARGET_BRANCH_TARGET_REGISTER_CLASS -This target hook returns a register class for which branch target register -optimizations should be applied. All registers in this class should be -usable interchangeably. After reload, registers in this class will be -re-allocated and loads will be hoisted out of loops and be subjected -to inter-block scheduling. -@end deftypefn @hook TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED -Branch target register optimization will by default exclude callee-saved -registers -that are not already live during the current function; if this target hook -returns true, they will be included. The target code must than make sure -that all target registers in the class returned by -@samp{TARGET_BRANCH_TARGET_REGISTER_CLASS} that might need saving are -saved. @var{after_prologue_epilogue_gen} indicates if prologues and -epilogues have already been generated. Note, even if you only return -true when @var{after_prologue_epilogue_gen} is false, you still are likely -to have to make special provisions in @code{INITIAL_ELIMINATION_OFFSET} -to reserve space for caller-saved target registers. -@end deftypefn @hook TARGET_HAVE_CONDITIONAL_EXECUTION -This target hook returns true if the target supports conditional execution. -This target hook is required only when the target has several different -modes and they have different conditional execution capability, such as ARM. -@end deftypefn @hook TARGET_LOOP_UNROLL_ADJUST -This target hook returns a new value for the number of times @var{loop} -should be unrolled. The parameter @var{nunroll} is the number of times -the loop is to be unrolled. The parameter @var{loop} is a pointer to -the loop, which is going to be checked for unrolling. This target hook -is required only when the target has special constraints like maximum -number of memory accesses. -@end deftypefn @defmac POWI_MAX_MULTS If defined, this macro is interpreted as a signed integer C expression @@ -11062,72 +8365,22 @@ and scanf formatter settings. @end defmac @hook TARGET_RELAXED_ORDERING -If set to @code{true}, means that the target's memory model does not -guarantee that loads which do not depend on one another will access -main memory in the order of the instruction stream; if ordering is -important, an explicit memory barrier must be used. This is true of -many recent processors which implement a policy of ``relaxed,'' -``weak,'' or ``release'' memory consistency, such as Alpha, PowerPC, -and ia64. The default is @code{false}. -@end deftypevr @hook TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN -If defined, this macro returns the diagnostic message when it is -illegal to pass argument @var{val} to function @var{funcdecl} -with prototype @var{typelist}. -@end deftypefn @hook TARGET_INVALID_CONVERSION -If defined, this macro returns the diagnostic message when it is -invalid to convert from @var{fromtype} to @var{totype}, or @code{NULL} -if validity should be determined by the front end. -@end deftypefn @hook TARGET_INVALID_UNARY_OP -If defined, this macro returns the diagnostic message when it is -invalid to apply operation @var{op} (where unary plus is denoted by -@code{CONVERT_EXPR}) to an operand of type @var{type}, or @code{NULL} -if validity should be determined by the front end. -@end deftypefn @hook TARGET_INVALID_BINARY_OP -If defined, this macro returns the diagnostic message when it is -invalid to apply operation @var{op} to operands of types @var{type1} -and @var{type2}, or @code{NULL} if validity should be determined by -the front end. -@end deftypefn @hook TARGET_INVALID_PARAMETER_TYPE -If defined, this macro returns the diagnostic message when it is -invalid for functions to include parameters of type @var{type}, -or @code{NULL} if validity should be determined by -the front end. This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_INVALID_RETURN_TYPE -If defined, this macro returns the diagnostic message when it is -invalid for functions to have return type @var{type}, -or @code{NULL} if validity should be determined by -the front end. This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_PROMOTED_TYPE -If defined, this target hook returns the type to which values of -@var{type} should be promoted when they appear in expressions, -analogous to the integer promotions, or @code{NULL_TREE} to use the -front end's normal promotion rules. This hook is useful when there are -target-specific types with special promotion rules. -This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_CONVERT_TO_TYPE -If defined, this hook returns the result of converting @var{expr} to -@var{type}. It should return the converted expression, -or @code{NULL_TREE} to apply the front end's normal conversion rules. -This hook is useful when there are target-specific types with special -conversion rules. -This is currently used only by the C and C++ front ends. -@end deftypefn @defmac TARGET_USE_JCR_SECTION This macro determines whether to use the JCR section to register Java @@ -11148,52 +8401,16 @@ and the associated definitions of those functions. @end defmac @hook TARGET_UPDATE_STACK_BOUNDARY -Define this macro to update the current function stack boundary if -necessary. -@end deftypefn @hook TARGET_GET_DRAP_RTX -This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a -different argument pointer register is needed to access the function's -argument list due to stack realignment. Return @code{NULL} if no DRAP -is needed. -@end deftypefn @hook TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS -When optimization is disabled, this hook indicates whether or not -arguments should be allocated to stack slots. Normally, GCC allocates -stacks slots for arguments when not optimizing in order to make -debugging easier. However, when a function is declared with -@code{__attribute__((naked))}, there is no stack frame, and the compiler -cannot safely move arguments from the registers in which they are passed -to the stack. Therefore, this hook should return true in general, but -false for naked functions. The default implementation always returns true. -@end deftypefn @hook TARGET_CONST_ANCHOR -On some architectures it can take multiple instructions to synthesize -a constant. If there is another constant already in a register that -is close enough in value then it is preferable that the new constant -is computed from this register using immediate addition or -subtraction. We accomplish this through CSE. Besides the value of -the constant we also add a lower and an upper constant anchor to the -available expressions. These are then queried when encountering new -constants. The anchors are computed by rounding the constant up and -down to a multiple of the value of @code{TARGET_CONST_ANCHOR}. -@code{TARGET_CONST_ANCHOR} should be the maximum positive value -accepted by immediate-add plus one. We currently assume that the -value of @code{TARGET_CONST_ANCHOR} is a power of 2. For example, on -MIPS, where add-immediate takes a 16-bit signed value, -@code{TARGET_CONST_ANCHOR} is set to @samp{0x8000}. The default value -is zero, which disables this optimization. -@end deftypevr @hook TARGET_ASAN_SHADOW_OFFSET @hook TARGET_MEMMODEL_CHECK -Validate target specific memory model mask bits. When NULL no target specific -memory model bits are allowed. -@end deftypefn @hook TARGET_ATOMIC_TEST_AND_SET_TRUEVAL |