@c Copyright (C) 1988,1989,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,
-@c 2002, 2003 Free Software Foundation, Inc.
+@c 2002, 2003, 2004 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
passes the string @option{-lgcc} to the linker.
@end defmac
+@defmac REAL_LIBGCC_SPEC
+By default, if @code{ENABLE_SHARED_LIBGCC} is defined, the
+@code{LIBGCC_SPEC} is not directly used by the driver program but is
+instead modified to refer to different versions of @file{libgcc.a}
+depending on the values of the command line flags @code{-static},
+@code{-shared}, @code{-static-libgcc}, and @code{-shared-libgcc}. On
+targets where these modifications are inappropriate, define
+@code{REAL_LIBGCC_SPEC} instead. @code{REAL_LIBGCC_SPEC} tells the
+driver how to place a reference to @file{libgcc} on the link command
+line, but, unlike @code{LIBGCC_SPEC}, it is used unmodified.
+@end defmac
+
@defmac STARTFILE_SPEC
Another C string constant used much like @code{LINK_SPEC}. The
difference between the two is that @code{STARTFILE_SPEC} is used at
The @file{config/rs6000/rs6000.h} target file defines:
-@example
+@smallexample
#define EXTRA_SPECS \
@{ "cpp_sysv_default", CPP_SYSV_DEFAULT @},
#define CPP_SYS_DEFAULT ""
-@end example
+@end smallexample
The @file{config/rs6000/sysv.h} target file defines:
@smallexample
For example, here is the definition used for VAX/VMS:
-@example
+@smallexample
#define INCLUDE_DEFAULTS \
@{ \
@{ "GNU_GXX_INCLUDE:", "G++", 1, 1@}, \
@{ ".", 0, 0, 0@}, \
@{ 0, 0, 0, 0@} \
@}
-@end example
+@end smallexample
@end defmac
Here is the order of prefixes tried for exec files:
Do not define this macro if it would never modify @var{m}.
@end defmac
+@defmac PROMOTE_FUNCTION_MODE
+Like @code{PROMOTE_MODE}, but is applied to outgoing function arguments or
+function return values, as specified by @code{TARGET_PROMOTE_FUNCTION_ARGS}
+and @code{TARGET_PROMOTE_FUNCTION_RETURN}, respectively.
+
+The default is @code{PROMOTE_MODE}.
+@end defmac
+
@deftypefn {Target Hook} bool TARGET_PROMOTE_FUNCTION_ARGS (tree @var{fntype})
This target hook should return @code{true} if the promotion described by
-@code{PROMOTE_MODE} should also be done for outgoing function arguments.
+@code{PROMOTE_FUNCTION_MODE} should be done for outgoing function
+arguments.
@end deftypefn
@deftypefn {Target Hook} bool TARGET_PROMOTE_FUNCTION_RETURN (tree @var{fntype})
This target hook should return @code{true} if the promotion described by
-@code{PROMOTE_MODE} should also be done for the return value of
+@code{PROMOTE_FUNCTION_MODE} should be done for the return value of
functions.
If this target hook returns @code{true}, @code{FUNCTION_VALUE} must
-perform the same promotions done by @code{PROMOTE_MODE}.
+perform the same promotions done by @code{PROMOTE_FUNCTON_MODE}.
@end deftypefn
-@defmac PROMOTE_FOR_CALL_ONLY
-Define this macro if the promotion described by @code{PROMOTE_MODE}
-should @emph{only} be performed for outgoing function arguments or
-function return values, as specified by @code{TARGET_PROMOTE_FUNCTION_ARGS}
-and @code{TARGET_PROMOTE_FUNCTION_RETURN}, respectively.
-@end defmac
-
@defmac PARM_BOUNDARY
Normal alignment required for function parameters on the stack, in
bits. All stack parameters receive at least this much alignment
bit-fields as are used by another compiler, here is how to investigate
what the other compiler does. Compile and run this program:
-@example
+@smallexample
struct foo1
@{
char x;
sizeof (struct foo2));
exit (0);
@}
-@end example
+@end smallexample
If this prints 2 and 5, then the compiler's behavior is what you would
get from @code{PCC_BITFIELD_TYPE_MATTERS}.
to aligning a bit-field within the structure.
@end defmac
+@deftypefn {Target Hook} bool TARGET_ALIGN_ANON_BITFIELDS (void)
+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
+
@defmac MEMBER_TYPE_FORCES_BLK (@var{field}, @var{mode})
Return 1 if a structure or array containing @var{field} should be accessed using
@code{BLKMODE}.
may affect its placement.
@end deftypefn
+@deftypefn {Target Hook} {const char *} TARGET_MANGLE_FUNDAMENTAL_TYPE (tree @var{type})
+If your target defines any fundamental types, 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.
+
+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
value of @code{LONG_TYPE_SIZE}.
@end defmac
-@defmac MAX_LONG_TYPE_SIZE
-Maximum number for the size in bits of the type @code{long} on the
-target machine. If this is undefined, the default is
-@code{LONG_TYPE_SIZE}. Otherwise, it is the constant value that is the
-largest value that @code{LONG_TYPE_SIZE} can have at run-time. This is
-used in @code{cpp}.
-@end defmac
-
@defmac LONG_LONG_TYPE_SIZE
A C expression for the size in bits of the type @code{long long} on the
target machine. If you don't define this, the default is two
words.
@end defmac
-@defmac MAX_LONG_DOUBLE_TYPE_SIZE
-Maximum number for the size in bits of the type @code{long double} on the
-target machine. If this is undefined, the default is
-@code{LONG_DOUBLE_TYPE_SIZE}. Otherwise, it is the constant value that is
-the largest value that @code{LONG_DOUBLE_TYPE_SIZE} can have at run-time.
-This is used in @code{cpp}.
-@end defmac
-
@defmac TARGET_FLT_EVAL_METHOD
A C expression for the value for @code{FLT_EVAL_METHOD} in @file{float.h},
assuming, if applicable, that the floating-point control word is in its
and @option{-funsigned-char}.
@end defmac
-@defmac DEFAULT_SHORT_ENUMS
-A C expression to determine whether to give an @code{enum} type
-only as many bytes as it takes to represent the range of possible values
-of that type. A nonzero value means to do that; a zero value means all
+@deftypefn {Target Hook} bool TARGET_DEFAULT_SHORT_ENUMS (void)
+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}.
-If you don't define the macro, the default is 0.
-@end defmac
+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
@code{WCHAR_TYPE}.
@end defmac
-@defmac MAX_WCHAR_TYPE_SIZE
-Maximum number for the size in bits of the data type for wide
-characters. If this is undefined, the default is
-@code{WCHAR_TYPE_SIZE}. Otherwise, it is the constant value that is the
-largest value that @code{WCHAR_TYPE_SIZE} can have at run-time. This is
-used in @code{cpp}.
-@end defmac
-
-@defmac GCOV_TYPE_SIZE
-A C expression for the size in bits of the type used for gcov counters on the
-target machine. If you don't define this, the default is one
-@code{LONG_TYPE_SIZE} in case it is greater or equal to 64-bit and
-@code{LONG_LONG_TYPE_SIZE} otherwise. You may want to re-define the type to
-ensure atomicity for counters in multithreaded programs.
-@end defmac
-
@defmac WINT_TYPE
A C expression for a string describing the name of the data type to
use for wide characters passed to @code{printf} and returned from
The C++ compiler represents a pointer-to-member-function with a struct
that looks like:
-@example
+@smallexample
struct @{
union @{
void (*fn)();
@};
ptrdiff_t delta;
@};
-@end example
+@end smallexample
@noindent
The C++ compiler must use one bit to indicate whether the function that
@section Target Character Escape Sequences
@cindex escape sequences
-By default, GCC assumes that the C character escape sequences take on
-their ASCII values for the target. If this is not correct, you must
-explicitly define all of the macros below. All of them must evaluate
-to constants; they are used in @code{case} statements.
+By default, GCC assumes that the C character escape sequences and other
+characters take on their ASCII values for the target. If this is not
+correct, you must explicitly define all of the macros below. All of
+them must evaluate to constants; they are used in @code{case}
+statements.
@findex TARGET_BELL
+@findex TARGET_BS
@findex TARGET_CR
+@findex TARGET_DIGIT0
@findex TARGET_ESC
@findex TARGET_FF
@findex TARGET_NEWLINE
@multitable {@code{TARGET_NEWLINE}} {Escape} {ASCII character}
@item Macro @tab Escape @tab ASCII character
@item @code{TARGET_BELL} @tab @kbd{\a} @tab @code{07}, @code{BEL}
+@item @code{TARGET_BS} @tab @kbd{\b} @tab @code{08}, @code{BS}
@item @code{TARGET_CR} @tab @kbd{\r} @tab @code{0D}, @code{CR}
+@item @code{TARGET_DIGIT0} @tab @kbd{0} @tab @code{30}, @code{ZERO}
@item @code{TARGET_ESC} @tab @kbd{\e}, @kbd{\E} @tab @code{1B}, @code{ESC}
@item @code{TARGET_FF} @tab @kbd{\f} @tab @code{0C}, @code{FF}
@item @code{TARGET_NEWLINE} @tab @kbd{\n} @tab @code{0A}, @code{LF}
@end smallexample
@end defmac
+@defmac REGMODE_NATURAL_SIZE (@var{mode})
+Define this macro if the natural size of registers that hold values
+of mode @var{mode} is not the word size. It is a C expression that
+should give the natural size in bytes for the specified mode. It is
+used by the register allocator to try to optimize its results. This
+happens for example on SPARC 64-bit where the natural size of
+floating-point registers is still 32-bit.
+@end defmac
+
@defmac HARD_REGNO_MODE_OK (@var{regno}, @var{mode})
A C expression that is nonzero if it is permissible to store a value
of mode @var{mode} in hard register number @var{regno} (or in several
be used unless some pattern's constraint asks for one.
@end defmac
+@defmac HARD_REGNO_RENAME_OK (@var{from}, @var{to})
+A C expression that is nonzero if it is OK to rename a hard register
+@var{from} to another hard register @var{to}.
+
+One common use of this macro is to prevent renaming of a register to
+another register that is not saved by a prologue in an interrupt
+handler.
+
+The default is always nonzero.
+@end defmac
+
@defmac MODES_TIEABLE_P (@var{mode1}, @var{mode2})
A C expression that is nonzero if a value of mode
@var{mode1} is accessible in mode @var{mode2} without copying.
@defmac N_REG_CLASSES
The number of distinct register classes, defined as follows:
-@example
+@smallexample
#define N_REG_CLASSES (int) LIM_REG_CLASSES
-@end example
+@end smallexample
@end defmac
@defmac REG_CLASS_NAMES
another, smaller class. On many machines, the following definition is
safe:
-@example
+@smallexample
#define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS
-@end example
+@end smallexample
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
register. Therefore, @file{alpha.h} defines @code{CANNOT_CHANGE_MODE_CLASS}
as below:
-@example
+@smallexample
#define CANNOT_CHANGE_MODE_CLASS(FROM, TO, CLASS) \
(GET_MODE_SIZE (FROM) != GET_MODE_SIZE (TO) \
? reg_classes_intersect_p (FLOAT_REGS, (CLASS)) : 0)
-@end example
+@end smallexample
@end defmac
Three other special macros describe which operands fit which constraint
define this macro.
@end defmac
-@defmac BUILTIN_SETJMP_FRAME_VALUE
-If defined, a C expression that contains an rtx that is used to store
+@deftypefn {Target Hook} bool 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 macro is if
+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 defmac
+@end deftypefn
@defmac RETURN_ADDR_RTX (@var{count}, @var{frameaddr})
A C expression whose value is RTL representing the value of the return
be updated in @var{fs}.
@end defmac
+@defmac TARGET_USES_WEAK_UNWIND_INFO
+A C expression that evaluates to true if the target requires unwind
+info to be given comdat linkage. Define it to be @code{1} if comdat
+linkage is necessary. The default is @code{0}.
+@end defmac
+
@node Stack Checking
@subsection Specifying How Stack Checking is Done
See the PowerPC's SPE target for an example.
@end defmac
+@defmac DWARF_FRAME_REGNUM (@var{regno})
+
+Define this macro if the target's representation for dwarf registers
+used in .eh_frame or .debug_frame is different from that used in other
+debug info sections. Given a GCC hard register number, this macro
+should return the .eh_frame register number. The default is
+@code{DBX_REGISTER_NUMBER (@var{regno})}.
+
+@end defmac
+
+@defmac DWARF2_FRAME_REG_OUT (@var{regno}, @var{for_eh})
+
+Define this macro to map register numbers held in the call frame info
+that GCC has collected using @code{DWARF_FRAME_REGNUM} to those that
+should be output in .debug_frame (@code{@var{for_eh}} is zero) and
+.eh_frame (@code{@var{for_eh}} is nonzero). The default is to
+return @code{@var{regno}}.
+
+@end defmac
+
@node Elimination
@subsection Eliminating Frame Pointer and Arg Pointer
depending on whether or not the frame pointer has been eliminated.
In this case, you might specify:
-@example
+@smallexample
#define ELIMINABLE_REGS \
@{@{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM@}, \
@{ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM@}, \
@{FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM@}@}
-@end example
+@end smallexample
Note that the elimination of the argument pointer with the stack pointer is
specified first since that is the preferred elimination.
On some machines, the definition
-@example
+@smallexample
#define PUSH_ROUNDING(BYTES) (BYTES)
-@end example
+@end smallexample
@noindent
will suffice. But on other machines, instructions that appear
to push one byte actually push two bytes in an attempt to maintain
alignment. Then the definition should be
-@example
+@smallexample
#define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1)
-@end example
+@end smallexample
@end defmac
@findex current_function_outgoing_args_size
@c above is overfull. not sure what to do. --mew 5feb93 did
@c something, not sure if it looks good. --mew 10feb93
-@defmac MAYBE_REG_PARM_STACK_SPACE
-@defmacx FINAL_REG_PARM_STACK_SPACE (@var{const_size}, @var{var_size})
-Define these macros in addition to the one above if functions might
-allocate stack space for arguments even when their values are passed
-in registers. These should be used when the stack space allocated
-for arguments in registers is not a simple constant independent of the
-function declaration.
-
-The value of the first macro is the size, in bytes, of the area that
-we should initially assume would be reserved for arguments passed in registers.
-
-The value of the second macro is the actual size, in bytes, of the area
-that will be reserved for arguments passed in registers. This takes two
-arguments: an integer representing the number of bytes of fixed sized
-arguments on the stack, and a tree representing the number of bytes of
-variable sized arguments on the stack.
-
-When these macros are defined, @code{REG_PARM_STACK_SPACE} will only be
-called for libcall functions, the current function, or for a function
-being called when it is known that such stack space must be allocated.
-In each case this value can be easily computed.
-
-When deciding whether a called function needs such stack space, and how
-much space to reserve, GCC uses these two macros instead of
-@code{REG_PARM_STACK_SPACE}.
-@end defmac
-
@defmac OUTGOING_REG_PARM_STACK_SPACE
Define this if it is the responsibility of the caller to allocate the area
reserved for arguments passed in registers.
should not be empty, so use @code{int}.
@end defmac
-@defmac INIT_CUMULATIVE_ARGS (@var{cum}, @var{fntype}, @var{libname}, @var{fndecl})
+@defmac INIT_CUMULATIVE_ARGS (@var{cum}, @var{fntype}, @var{libname}, @var{fndecl}, @var{n_named_args})
A C statement (sans semicolon) for initializing the variable
@var{cum} for the state at the beginning of the argument list. The
variable has type @code{CUMULATIVE_ARGS}. The value of @var{fntype}
For direct calls that are not libcalls, @var{fndecl} contain the
declaration node of the function. @var{fndecl} is also set when
@code{INIT_CUMULATIVE_ARGS} is used to find arguments for the function
-being compiled.
+being compiled. @var{n_named_args} is set to the number of named
+arguments, including a structure return address if it is passed as a
+parameter, when making a call. When processing incoming arguments,
+@var{n_named_args} is set to -1.
When processing a call to a compiler support library function,
@var{libname} identifies which one. It is a @code{symbol_ref} rtx which
stack.
@end defmac
-@defmac SPLIT_COMPLEX_ARGS
+@deftypefn {Target Hook} bool TARGET_SPLIT_COMPLEX_ARG (tree @var{type})
+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.
-Define this macro to a nonzero value if complex function arguments
-should be split into their corresponding components. 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.
-@end defmac
+The default value of this hook is @code{NULL}, which is treated as always
+false.
+@end deftypefn
@node Scalar Return
@subsection How Scalar Function Values Are Returned
@code{FUNCTION_VALUE} is not used for return vales with aggregate data
types, because these are returned in another way. See
-@code{STRUCT_VALUE_REGNUM} and related macros, below.
+@code{TARGET_STRUCT_VALUE_RTX} and related macros, below.
@end defmac
@defmac FUNCTION_OUTGOING_VALUE (@var{valtype}, @var{func})
@code{FUNCTION_OUTGOING_VALUE} is not used for return vales with
aggregate data types, because these are returned in another way. See
-@code{STRUCT_VALUE_REGNUM} and related macros, below.
+@code{TARGET_STRUCT_VALUE_RTX} and related macros, below.
@end defmac
@defmac LIBCALL_VALUE (@var{mode})
recognized by this macro. So for most machines, this definition
suffices:
-@example
+@smallexample
#define FUNCTION_VALUE_REGNO_P(N) ((N) == 0)
-@end example
+@end smallexample
If the machine has register windows, so that the caller and the called
function use different registers for the return value, this macro
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.
+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
after adding @code{delta}. In particular, if @var{p} is the
adjusted pointer, the following adjustment should be made:
-@example
+@smallexample
p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]
-@end example
+@end smallexample
@noindent
If this function is defined, it will always be used in place of
Use this built-in function to save the argument registers in memory so
that the varargs mechanism can access them. Both ISO and traditional
versions of @code{va_start} must use @code{__builtin_saveregs}, unless
-you use @code{SETUP_INCOMING_VARARGS} (see below) instead.
+you use @code{TARGET_SETUP_INCOMING_VARARGS} (see below) instead.
On some machines, @code{__builtin_saveregs} is open-coded under the
-control of the macro @code{EXPAND_BUILTIN_SAVEREGS}. On other machines,
-it calls a routine written in assembler language, found in
-@file{libgcc2.c}.
+control of the target hook @code{TARGET_EXPAND_BUILTIN_SAVEREGS}. On
+other machines, it calls a routine written in assembler language,
+found in @file{libgcc2.c}.
Code generated for the call to @code{__builtin_saveregs} appears at the
beginning of the function, as opposed to where the call to
@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{SETUP_INCOMING_VARARGS} is used, @code{false} otherwise.
+@code{TARGET_SETUP_INCOMING_VARARGS} is used, @code{false} otherwise.
Otherwise, you should not define this hook.
@end deftypefn
@defmac DECLARE_LIBRARY_RENAMES
This macro, if defined, should expand to a piece of C code that will get
expanded when compiling functions for libgcc.a. It can be used to
-provide alternate names for gcc's internal library functions if there
+provide alternate names for GCC's internal library functions if there
are ABI-mandated names that the compiler should provide.
@end defmac
The default is to do nothing. Most ports don't need to define this hook.
@end deftypefn
-@defmac TARGET_FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
+@defmac FLOAT_LIB_COMPARE_RETURNS_BOOL (@var{mode}, @var{comparison})
This macro should return @code{true} if the library routine that
implements the floating point comparison operator @var{comparison} in
mode @var{mode} will return a boolean, and @var{false} if it will
memory address for an operand of mode @var{mode}. @var{win} will be a
C statement label elsewhere in the code; the macro definition may use
-@example
+@smallexample
GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{win});
-@end example
+@end smallexample
@noindent
to avoid further processing if the address has become legitimate.
It is not necessary for this macro to come up with a legitimate
address. The compiler has standard ways of doing so in all cases. In
-fact, it is safe for this macro to do nothing. But often a
+fact, it is safe to omit this macro. But often a
machine-dependent strategy can generate better code.
@end defmac
@end smallexample
@end defmac
+@deftypefn {Target Hook} bool TARGET_FIXED_CONDITION_CODE_REGS (unsigned int *, unsigned int *)
+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 the second argument should be set to
+@code{INVALID_REGNUM}.
+
+The default version of this hook returns false.
+@end deftypefn
+
+@deftypefn {Target Hook} enum machine_mode TARGET_CC_MODES_COMPATIBLE (enum machine_mode, enum machine_mode)
+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 Costs
@section Describing Relative Costs of Operations
@cindex costs of instructions
@option{-fsched-verbose-@var{n}}.
@end deftypefn
+@deftypefn {Target Hook} void TARGET_SCHED_INIT_GLOBAL (FILE *@var{file}, int @var{verbose}, int @var{old_max_uid})
+This hook is executed by the scheduler after function level initializations.
+@var{file} is either a null pointer, or a stdio stream to write any debug output to.
+@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.
+@var{old_max_uid} is the maximum insn uid when scheduling begins.
+@end deftypefn
+
+@deftypefn {Target Hook} void TARGET_SCHED_FINISH_GLOBAL (FILE *@var{file}, int @var{verbose})
+This is the cleanup hook corresponding to TARGET_SCHED_INIT_GLOBAL.
+@var{file} is either a null pointer, or a stdio stream to write any debug output to.
+@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.
+@end deftypefn
+
@deftypefn {Target Hook} int TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE (void)
This hook is called many times during insn scheduling. If the hook
returns nonzero, the automaton based pipeline description is used for
insns with indexes greater than given index.
@end deftypefn
-@deftypefn {Target Hook} bool IS_COSTLY_DEPENDENCE (rtx @var{insn1}, rtx @var{insn2}, rtx @var{dep_link}, int @var{dep_cost}, int @var{distance})
+@deftypefn {Target Hook} bool TARGET_SCHED_IS_COSTLY_DEPENDENCE (rtx @var{insn1}, rtx @var{insn2}, rtx @var{dep_link}, int @var{dep_cost}, int @var{distance})
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
+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 second parameter @var{insn2} is dependent
-upon the first parameter @var{insn1}. The dependence between @var{insn1}
-and @var{insn2} is represented by the third parameter @var{dep_link}. The
-fourth parameter @var{cost} is the cost of the dependence, and the fifth
-parameter @var{distance} is the distance in cycles between the two insns.
+to this hook are as follows: The second parameter @var{insn2} is dependent
+upon the first parameter @var{insn1}. The dependence between @var{insn1}
+and @var{insn2} is represented by the third parameter @var{dep_link}. The
+fourth parameter @var{cost} is the cost of the dependence, and the fifth
+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
+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
+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,
+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
Macros in the following table are generated by the program
@file{genattr} and can be useful for writing the hooks.
-@defmac TRADITIONAL_PIPELINE_INTERFACE
-The macro definition is generated if there is a traditional pipeline
-description in @file{.md} file. You should also remember that to
-simplify the insn scheduler sources an empty traditional pipeline
-description interface is generated even if there is no a traditional
-pipeline description in the @file{.md} file. The macro can be used to
-distinguish the two types of the traditional interface.
-@end defmac
-
-@defmac DFA_PIPELINE_INTERFACE
-The macro definition is generated if there is an automaton pipeline
-description in @file{.md} file. You should also remember that to
-simplify the insn scheduler sources an empty automaton pipeline
-description interface is generated even if there is no an automaton
-pipeline description in the @file{.md} file. The macro can be used to
-distinguish the two types of the automaton interface.
-@end defmac
-
@defmac MAX_DFA_ISSUE_RATE
The macro definition is generated in the automaton based pipeline
description interface. Its value is calculated from the automaton
in the text section.
@end defmac
-@defmac SHARED_SECTION_ASM_OP
-If defined, a C expression whose value is a string, including spacing,
-containing the assembler operation to identify the following data as
-shared data. If not defined, @code{DATA_SECTION_ASM_OP} will be used.
-@end defmac
-
@defmac BSS_SECTION_ASM_OP
If defined, a C expression whose value is a string, including spacing,
containing the assembler operation to identify the following data as
responsible for outputting the label definition at the proper place.
Here is how to do this:
-@example
+@smallexample
@code{(*targetm.asm_out.internal_label)} (@var{file}, "LC", @var{labelno});
-@end example
+@end smallexample
When you output a pool entry specially, you should end with a
@code{goto} to the label @var{jumpto}. This will prevent the same pool
hidden, protected or internal visibility as specified by @var{visibility}.
@end deftypefn
+@defmac TARGET_EXPLICIT_INSTANTIATIONS_ONE_ONLY
+A C expression that evaluates to true if the target's linker expects
+explicit template specializations, as well as implicit, to be given
+linkonce semantics. The default is @code{1}. The C++ ABI requires
+this macro to be nonzero. Define this macro for targets where full
+C++ ABI compliance is impossible and where explicit and implicit
+template specialization must be treated differently.
+@end defmac
+
+@defmac TARGET_SUPPORTS_HIDDEN
+A C expression that evaluates to true if the target supports hidden
+visibility. By default this expression is true if and only if
+@code{HAS_GAS_HIDDEN} is defined. Set this macro if the
+@code{HAS_GAS_HIDDEN} macro gives the wrong answer for this
+target. (For example, if the target's mechanism for supporting
+hidden visibility is not the same as GAS's.)
+@end defmac
+
@defmac ASM_OUTPUT_EXTERNAL (@var{stream}, @var{decl}, @var{name})
A C statement (sans semicolon) to output to the stdio stream
@var{stream} any text necessary for declaring the name of an external
parts of @file{crtstuff.c} are compiled into that section. The
program is linked by the @command{gcc} driver like this:
-@example
+@smallexample
ld -o @var{output_file} crti.o crtbegin.o @dots{} -lgcc crtend.o crtn.o
-@end example
+@end smallexample
The prologue of a function (@code{__init}) appears in the @code{.init}
section of @file{crti.o}; the epilogue appears in @file{crtn.o}. Likewise
@code{(*targetm.asm_out.internal_label)}, and they must be printed in the same
way here. For example,
-@example
+@smallexample
fprintf (@var{stream}, "\t.word L%d-L%d\n",
@var{value}, @var{rel})
-@end example
+@end smallexample
You must provide this macro on machines where the addresses in a
dispatch table are relative to the table's own address. If defined, GCC
definition is output using @code{(*targetm.asm_out.internal_label)}.
For example,
-@example
+@smallexample
fprintf (@var{stream}, "\t.word L%d\n", @var{value})
-@end example
+@end smallexample
@end defmac
@defmac ASM_OUTPUT_CASE_LABEL (@var{stream}, @var{prefix}, @var{num}, @var{table})
the jump-table.
@end defmac
+@deftypefn {Target Hook} void TARGET_ASM_EMIT_UNWIND_LABEL (@var{stream}, @var{decl}, @var{empty})
+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{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
+
@node Exception Region Output
@subsection Assembler Commands for Exception Regions
the function.
@end defmac
-@defmac DBX_OUTPUT_STANDARD_TYPES (@var{syms})
-Define this macro if you need to control the order of output of the
-standard data types at the beginning of compilation. The argument
-@var{syms} is a @code{tree} which is a chain of all the predefined
-global symbols, including names of data types.
-
-Normally, DBX output starts with definitions of the types for integers
-and characters, followed by all the other predefined types of the
-particular language in no particular order.
-
-On some machines, it is necessary to output different particular types
-first. To do this, define @code{DBX_OUTPUT_STANDARD_TYPES} to output
-those symbols in the necessary order. Any predefined types that you
-don't explicitly output will be output afterward in no particular order.
-
-Be careful not to define this macro so that it works only for C@. There
-are no global variables to access most of the built-in types, because
-another language may have another set of types. The way to output a
-particular type is to look through @var{syms} to see if you can find it.
-Here is an example:
-
-@smallexample
-@{
- tree decl;
- for (decl = syms; decl; decl = TREE_CHAIN (decl))
- if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
- "long int"))
- dbxout_symbol (decl);
- @dots{}
-@}
-@end smallexample
-
-@noindent
-This does nothing if the expected type does not exist.
-
-See the function @code{init_decl_processing} in @file{c-decl.c} to find
-the names to use for all the built-in C types.
-
-Here is another way of finding a particular type:
-
-@c this is still overfull. --mew 10feb93
-@smallexample
-@{
- tree decl;
- for (decl = syms; decl; decl = TREE_CHAIN (decl))
- if (TREE_CODE (decl) == TYPE_DECL
- && (TREE_CODE (TREE_TYPE (decl))
- == INTEGER_CST)
- && TYPE_PRECISION (TREE_TYPE (decl)) == 16
- && TYPE_UNSIGNED (TREE_TYPE (decl)))
-@group
- /* @r{This must be @code{unsigned short}.} */
- dbxout_symbol (decl);
- @dots{}
-@}
-@end group
-@end smallexample
-@end defmac
-
@defmac NO_DBX_FUNCTION_END
Some stabs encapsulation formats (in particular ECOFF), cannot handle the
@code{.stabs "",N_FUN,,0,0,Lscope-function-1} gdb dbx extension construct.
@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES
If the only target-specific handling you require is @samp{dllimport} for
-Windows targets, you should define the macro
+Microsoft Windows targets, you should define the macro
@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES}. This links in a function
called @code{merge_dllimport_decl_attributes} which can then be defined
as the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. This is done
@cindex MIPS coprocessor-definition macros
The MIPS specification allows MIPS implementations to have as many as 4
-coprocessors, each with as many as 32 private registers. gcc supports
+coprocessors, each with as many as 32 private registers. GCC supports
accessing these registers and transferring values between the registers
and memory using asm-ized variables. For example:
is no need for extensive validity checking). It returns @code{NULL} if
it is safe to load a PCH file with this data, or a suitable error message
if not. The error message will be presented to the user, so it should
-be localised.
+be localized.
@end deftypefn
@node Misc
declaration will be generated in @file{insn-codes.h}.
@end defmac
+@defmac HAS_LONG_COND_BRANCH
+Define this boolean macro to indicate whether or not your architecture
+has conditional branches that can span all of memory. It is used in
+conjunction with an optimization that partitions hot and cold basic
+blocks into separate sections of the executable. If this macro is
+set to false, gcc will convert any conditional branches that attempt
+to cross between sections into unconditional branches or indirect jumps.
+@end defmac
+
+@defmac HAS_LONG_UNCOND_BRANCH
+Define this boolean macro to indicate whether or not your architecture
+has unconditional branches that can span all of memory. It is used in
+conjunction with an optimization that partitions hot and cold basic
+blocks into separate sections of the executable. If this macro is
+set to false, gcc will convert any unconditional branches that attempt
+to cross between sections into indirect jumps.
+@end defmac
+
@defmac SPECIAL_MODE_PREDICATES
Define this if you have special predicates that know special things
about modes. Genrecog will warn about certain forms of
@defmac CASE_VECTOR_PC_RELATIVE
Define this macro to be a C expression to indicate when jump-tables
-should contain relative addresses. If jump-tables never contain
-relative addresses, then you need not define this macro.
+should contain relative addresses. You need not define this macro if
+jump-tables never contain relative addresses, or jump-tables should
+contain relative addresses only when @option{-fPIC} or @option{-fPIC}
+is in effect.
@end defmac
@defmac CASE_DROPS_THROUGH
Most RISC machines have this property and most CISC machines do not.
@end defmac
-@defmac LOAD_EXTEND_OP (@var{mode})
+@defmac LOAD_EXTEND_OP (@var{mem_mode})
Define this macro to be a C expression indicating when insns that read
-memory in @var{mode}, an integral mode narrower than a word, set the
-bits outside of @var{mode} to be either the sign-extension or the
+memory in @var{mem_mode}, an integral mode narrower than a word, set the
+bits outside of @var{mem_mode} to be either the sign-extension or the
zero-extension of the data read. Return @code{SIGN_EXTEND} for values
-of @var{mode} for which the
+of @var{mem_mode} for which the
insn sign-extends, @code{ZERO_EXTEND} for which it zero-extends, and
@code{NIL} for other modes.
-This macro is not called with @var{mode} non-integral or with a width
+This macro is not called with @var{mem_mode} non-integral or with a width
greater than or equal to @code{BITS_PER_WORD}, so you may return any
value in this case. Do not define this macro if it would always return
@code{NIL}. On machines where this macro is defined, you will normally
define it as the constant @code{SIGN_EXTEND} or @code{ZERO_EXTEND}.
+
+You may return a non-@code{NIL} value even if for some hard registers
+the sign extension is not performed, if for the @code{REGNO_REG_CLASS}
+of these hard registers @code{CANNOT_CHANGE_MODE_CLASS} returns nonzero
+when the @var{from} mode is @var{mem_mode} and the @var{to} mode is any
+integral mode larger than this but not larger than @code{word_mode}.
+
+You must return @code{NIL} if for some hard registers that allow this
+mode, @code{CANNOT_CHANGE_MODE_CLASS} says that they cannot change to
+@code{word_mode}, but that they can change to another integral mode that
+is larger then @var{mem_mode} but still smaller than @code{word_mode}.
@end defmac
@defmac SHORT_IMMEDIATES_SIGN_EXTEND
should be @code{QImode}.
@end defmac
-@defmac INTEGRATE_THRESHOLD (@var{decl})
-A C expression for the maximum number of instructions above which the
-function @var{decl} should not be inlined. @var{decl} is a
-@code{FUNCTION_DECL} node.
-
-The default definition of this macro is 64 plus 8 times the number of
-arguments that the function accepts. Some people think a larger
-threshold should be used on RISC machines.
-@end defmac
-
@defmac STDC_0_IN_SYSTEM_HEADERS
In normal operation, the preprocessor expands @code{__STDC__} to the
constant 1, to signify that GCC conforms to ISO Standard C@. On some
symbols must be explicitly imported from shared libraries (DLLs).
@end defmac
-@defmac MD_ASM_CLOBBERS (@var{clobbers})
-A C statement that adds to @var{clobbers} @code{STRING_CST} trees for
+@deftypefn {Target Hook} tree TARGET_MD_ASM_CLOBBERS (tree @var{clobbers})
+This target hook should add to @var{clobbers} @code{STRING_CST} trees for
any hard regs the port wishes to automatically clobber for all asms.
-@end defmac
+It should return the result of the last @code{tree_cons} used to add a
+clobber.
+@end deftypefn
@defmac MATH_LIBRARY
Define this macro as a C string constant for the linker argument to link
Define this macro to a C expression representing a variant of the
method call @var{mdecl}, if Java Native Interface (JNI) methods
must be invoked differently from other methods on your target.
-For example, on 32-bit Windows, JNI methods must be invoked using
+For example, on 32-bit Microsoft Windows, JNI methods must be invoked using
the @code{stdcall} calling convention and this macro is then
defined as this expression:
system library's @code{pow}, @code{powf} or @code{powl} routines.
The default value places no upper bound on the multiplication count.
@end defmac
+
+@deftypefn Macro void TARGET_EXTRA_INCLUDES (int @var{stdinc})
+This target hook should register any extra include files for the
+target. The parameter @var{stdinc} indicates if normal include files
+are present.
+@end deftypefn
+
+@deftypefn Macro void TARGET_OPTF (char *@var{path})
+This target hook should register special include paths for the target.
+The parameter @var{path} is the include to register. On Darwin
+systems, this is used for Framework includes, which have semantics
+that are different from @option{-I}.
+@end deftypefn
+
+@deftypefn {Target Hook} bool TARGET_USE_LOCAL_THUNK_ALIAS_P (tree @var{fndecl})
+This target hook returns @code{true} if it is safe to use a local alias
+for a virtual function @var{fndecl} when constructing thunks,
+@code{false} otherwise. By default, the hook returns @code{true} for all
+functions, if a target supports aliases (ie. defines
+@code{ASM_OUTPUT_DEF}), @code{false} otherwise,
+@end deftypefn
OSDN Git Service
