Do not define this macro if it does not need to do anything.
+@findex CPLUSPLUS_CPP_SPEC
+@item CPLUSPLUS_CPP_SPEC
+This macro is just like @code{CPP_SPEC}, but is used for C++, rather
+than C. If you do not define this macro, then the value of
+@code{CPP_SPEC} (if any) will be used instead.
+
@findex NO_BUILTIN_SIZE_TYPE
@item NO_BUILTIN_SIZE_TYPE
If this macro is defined, the preprocessor will not define the builtin macro
Do not define this macro if it does not need to do anything.
+@findex THREAD_MODEL_SPEC
+@item THREAD_MODEL_SPEC
+GCC @code{-v} will print the thread model GCC was configured to use.
+However, this doesn't work on platforms that are multilibbed on thread
+models, such as AIX 4.3. On such platforms, define
+@code{THREAD_MODEL_SPEC} such that it evaluates to a string without
+blanks that names one of the recognized thread models. @code{%*}, the
+default value of this macro, will expand to the value of
+@code{thread_file} set in @file{config.gcc}.
+
@findex EXTRA_SPECS
@item EXTRA_SPECS
Define this macro to provide additional specifications to put in the
line for invoking the linker and there is no other way to accomplish
the effect you need.
+@findex LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
+@item LINK_ELIMINATE_DUPLICATE_LDIRECTORIES
+A nonzero value causes collect2 to remove duplicate -L<directory> search
+directories from linking commands. Do not give it a nonzero value if
+removing duplicate search directories changes the linker's semantics.
+
@findex MULTILIB_DEFAULTS
@item MULTILIB_DEFAULTS
Define this macro as a C expression for the initializer of an array of
@code{INIT_EXPANDERS}. This macro should be used to initialise some or
all of the function pointers @code{init_machine_status},
@code{free_machine_status} and @code{mark_machine_status}. These
-pointers are explained below.
+pointers are explained below.
One typical use of per-function, target specific data is to create an
RTX to hold the register containing the function's return address. This
function began the old per-function data had to be pushed onto a
stack, and when the processing was finished, it had to be popped off the
stack. GCC used to provide function pointers called
-@code{save_machine_status} and @code{restore_machine_status} to handle
+@code{save_machine_status} and @code{restore_machine_status} to handle
the saving and restoring of the target specific information. Since the
single data area approach is no longer used, these pointers are no
longer supported.
@findex DATA_ALIGNMENT
@item DATA_ALIGNMENT (@var{type}, @var{basic-align})
-If defined, a C expression to compute the alignment for a variables in
+If defined, a C expression to compute the alignment for a variable in
the static store. @var{type} is the data type, and @var{basic-align} is
the alignment that the object would ordinarily have. The value of this
macro is used instead of that alignment to align the object.
@findex LOCAL_ALIGNMENT
@item LOCAL_ALIGNMENT (@var{type}, @var{basic-align})
-If defined, a C expression to compute the alignment for a variables in
+If defined, a C expression to compute the alignment for a variable in
the local store. @var{type} is the data type, and @var{basic-align} is
the alignment that the object would ordinarily have. The value of this
macro is used instead of that alignment to align the object.
Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to
aligning a bitfield within the structure.
-@findex STRUCT_FORCE_BLK
-@item STRUCT_FORCE_BLK (@var{field})
-Return 1 if a structure containing @var{field} should be accessed using
+@findex MEMBER_TYPE_FORCES_BLK
+@item MEMBER_TYPE_FORCES_BLK (@var{field})
+Return 1 if a structure or array containing @var{field} should be accessed using
@code{BLKMODE}.
Normally, this is not needed. See the file @file{c4x.h} for an example
implementation by default. The ``thunk'' implementation is more efficient
(especially if you have provided an implementation of
@code{ASM_OUTPUT_MI_THUNK}, see @ref{Function Entry}), but is not binary
-compatible with code compiled using the traditional implementation.
+compatible with code compiled using the traditional implementation.
If you are writing a new port, define @code{DEFAULT_VTABLE_THUNKS} to 1.
If you do not define this macro, the default for @samp{-fvtable-thunk} is 0.
unsigned int"} that has as much precision as @code{long long unsigned
int}.
-@findex OBJC_INT_SELECTORS
-@item OBJC_INT_SELECTORS
-Define this macro if the type of Objective C selectors should be
-@code{int}.
-
-If this macro is not defined, then selectors should have the type
-@code{struct objc_selector *}.
-
@findex OBJC_SELECTORS_WITHOUT_LABELS
@item OBJC_SELECTORS_WITHOUT_LABELS
Define this macro if the compiler can group all the selectors together
On certain machines, it is important to have a separate label for each
selector because this enables the linker to eliminate duplicate selectors.
+@findex TARGET_PTRMEMFUNC_VBIT_LOCATION
+@item TARGET_PTRMEMFUNC_VBIT_LOCATION
+The C++ compiler represents a pointer-to-member-function with a struct
+that looks like:
+
+@example
+ struct @{
+ union @{
+ void (*fn)();
+ ptrdiff_t vtable_index;
+ @};
+ ptrdiff_t delta;
+ @};
+@end example
+
+@noindent
+The C++ compiler must use one bit to indicate whether the function that
+will be called through a pointer-to-member-function is virtual.
+Normally, we assume that the low-order bit of a function pointer must
+always be zero. Then, by ensuring that the vtable_index is odd, we can
+distinguish which variant of the union is in use. But, on some
+platforms function pointers can be odd, and so this doesn't work. In
+that case, we use the low-order bit of the @code{delta} field, and shift
+the remainder of the @code{delta} field to the left.
+
+GCC will automatically make the right selection about where to store
+this bit using the @code{FUNCTION_BOUNDARY} setting for your platform.
+However, some platforms such as ARM/Thumb have @code{FUNCTION_BOUNDARY}
+set such that functions always start at even addresses, but the lowest
+bit of pointers to functions indicate whether the function at that
+address is in ARM or Thumb mode. If this is the case of your
+architecture, you should define this macro to
+@code{ptrmemfunc_vbit_in_delta}.
+
+In general, you should not have to define this macro. On architectures
+in which function addresses are always even, according to
+@code{FUNCTION_BOUNDARY}, GCC will automatically define this macro to
+@code{ptrmemfunc_vbit_in_pfn}.
+
@findex TARGET_BELL
@item TARGET_BELL
A C constant expression for the integer value for escape sequence
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{REG_CLASS_CONTENTS} and @code{REGISTER_NAMES}, respectively,
@code{global_regs} has been cleared, and any @samp{-ffixed-@var{reg}},
@samp{-fcall-used-@var{reg}} and @samp{-fcall-saved-@var{reg}} command
options have been applied.
/ UNITS_PER_WORD)
@end smallexample
-@findex ALTER_HARD_SUBREG
-@item ALTER_HARD_SUBREG (@var{tgt_mode}, @var{word}, @var{src_mode}, @var{regno})
-A C expression that returns an adjusted hard register number for
-
-@smallexample
-(subreg:@var{tgt_mode} (reg:@var{src_mode} @var{regno}) @var{word})
-@end smallexample
-
-This may be needed if the target machine has mixed sized big-endian
-registers, like Sparc v9.
-
@findex HARD_REGNO_MODE_OK
@item HARD_REGNO_MODE_OK (@var{regno}, @var{mode})
A C expression that is nonzero if it is permissible to store a value
Define this macro if the compiler should avoid copies to/from @code{CCmode}
registers. You should only define this macro if support for copying to/from
@code{CCmode} is incomplete.
+
+@findex SUBREG_REGNO_OFFSET
+@item SUBREG_REGNO_OFFSET
+Define this macro if the compiler needs to handle subregs in a non-standard
+way. The macro returns the correct regno offset for mode @code{YMODE} given
+a subreg of type @code{XMODE}.
+This macro takes 4 parameters:
+@code{XREGNO} - A regno of an inner hard subreg_reg (or what will become one).
+@code{XMODE} - The mode of xregno.
+@code{OFFSET} - The byte offset.
+@code{YMODE} - The mode of a top level SUBREG (or what may become one).
+The default function can be found in rtlanal.c, function
+@code{subreg_regno_offset}. Normally this does not need to be defined.
@end table
@node Leaf Functions
@item ARG_POINTER_CFA_OFFSET (@var{fundecl})
A C expression whose value is an integer giving the offset, in bytes,
from the argument pointer to the canonical frame address (cfa). The
-final value should coincide with that calculated by
+final value should coincide with that calculated by
@code{INCOMING_FRAME_SP_OFFSET}. Which is unfortunately not usable
during virtual register instantiation.
want to support call frame debugging information like that provided by
DWARF 2.
+@findex EH_RETURN_DATA_REGNO
+@item EH_RETURN_DATA_REGNO (@var{N})
+A C expression whose value is the @var{N}th register number used for
+data by exception handlers, or @code{INVALID_REGNUM} if fewer than
+@var{N} registers are usable.
+
+The exception handling library routines communicate with the exception
+handlers via a set of agreed upon registers. Ideally these registers
+should be call-clobbered; it is possible to use call-saved registers,
+but may negatively impact code size. The target must support at least
+2 data registers, but should define 4 if there are enough free registers.
+
+You must define this macro if you want to support call frame exception
+handling like that provided by DWARF 2.
+
+@findex EH_RETURN_STACKADJ_RTX
+@item EH_RETURN_STACKADJ_RTX
+A C expression whose value is RTL representing a location in which
+to store a stack adjustment to be applied before function return.
+This is used to unwind the stack to an exception handler's call frame.
+It will be assigned zero on code paths that return normally.
+
+Typically this is a call-clobbered hard register that is otherwise
+untouched by the epilogue, but could also be a stack slot.
+
+You must define this macro if you want to support call frame exception
+handling like that provided by DWARF 2.
+
+@findex EH_RETURN_HANDLER_RTX
+@item EH_RETURN_HANDLER_RTX
+A C expression whose value is RTL representing a location in which
+to store the address of an exception handler to which we should
+return. It will not be assigned on code paths that return normally.
+
+Typically this is the location in the call frame at which the normal
+return address is stored. For targets that return by popping an
+address off the stack, this might be a memory address just below
+the @emph{target} call frame rather than inside the current call
+frame. @code{EH_RETURN_STACKADJ_RTX} will have already been assigned,
+so it may be used to calculate the location of the target call frame.
+
+Some targets have more complex requirements than storing to an
+address calculable during initial code generation. In that case
+the @code{eh_return} instruction pattern should be used instead.
+
+If you want to support call frame exception handling, you must
+define either this macro or the @code{eh_return} instruction pattern.
+
+@findex ASM_PREFERRED_EH_DATA_FORMAT
+@item ASM_PREFERRED_EH_DATA_FORMAT(@var{CODE}, @var{GLOBAL})
+This macro chooses the encoding of pointers embedded in the exception
+handling sections. If at all possible, this should be defined such
+that the exception handling section will not require dynamic relocations,
+and so may be read-only.
+
+@var{CODE} is 0 for data, 1 for code labels, 2 for function pointers.
+@var{GLOBAL} is true if the symbol may be affected by dynamic relocations.
+The macro should return a combination of the @code{DW_EH_PE_*} defines
+as found in @file{dwarf2.h}.
+
+If this macro is not defined, pointers will not be encoded but
+represented directly.
+
+@findex ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX
+@item ASM_MAYBE_OUTPUT_ENCODED_ADDR_RTX(@var{FILE}, @var{ENCODING}, @var{SIZE}, @var{ADDR}, @var{DONE})
+This macro allows the target to emit whatever special magic is required
+to represent the encoding chosen by @code{ASM_PREFERRED_EH_DATA_FORMAT}.
+Generic code takes care of pc-relative and indirect encodings; this must
+be defined if the target uses text-relative or data-relative encodings.
+
+This is a C statement that branches to @var{DONE} if the format was
+handled. @var{ENCODING} is the format chosen, @var{SIZE} is the number
+of bytes that the format occupies, @var{ADDR} is the @code{SYMBOL_REF}
+to be emitted.
+
@findex SMALL_STACK
@item SMALL_STACK
Define this macro if the stack size for the target is very small. This
@findex STACK_CHECK_BUILTIN
@item STACK_CHECK_BUILTIN
A nonzero value if stack checking is done by the configuration files in a
-machine-dependent manner. You should define this macro if stack checking
-is require by the ABI of your machine or if you would like to have to stack
+machine-dependent manner. You should define this macro if stack checking
+is require by the ABI of your machine or if you would like to have to stack
checking in some more efficient way than GCC's portable approach.
The default value of this macro is zero.
@findex STACK_CHECK_PROBE_LOAD
@item STACK_CHECK_PROBE_LOAD
-A integer which is nonzero if GCC should perform the stack probe
+A integer which is nonzero if GCC should perform the stack probe
as a load instruction and zero if GCC should use a store instruction.
The default is zero, which is the most efficient choice on most systems.
@item PUSH_ROUNDING (@var{npushed})
A C expression that is the number of bytes actually pushed onto the
stack when an instruction attempts to push @var{npushed} bytes.
-@findex PUSH_ROUNDING
-@item PUSH_ROUNDING (@var{npushed})
-A C expression that is the number of bytes actually pushed onto the
-stack when an instruction attempts to push @var{npushed} bytes.
On some machines, the definition
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}
+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.
@findex PAD_VARARGS_DOWN
@item PAD_VARARGS_DOWN
-If defined, a C expression which determines whether the default
-implementation of va_arg will attempt to pad down before reading the
+If defined, a C expression which determines whether the default
+implementation of va_arg will attempt to pad down before reading the
next argument, if that argument is smaller than its aligned space as
controlled by @code{PARM_BOUNDARY}. If this macro is not defined, all such
arguments are padded down if @code{BYTES_BIG_ENDIAN} is true.
@findex LOAD_ARGS_REVERSED
@item LOAD_ARGS_REVERSED
If defined, the order in which arguments are loaded into their
-respective argument registers is reversed so that the last
+respective argument registers is reversed so that the last
argument is loaded first. This macro only affects arguments
passed in registers.
@item DEFAULT_CALLER_SAVES
Define this macro if function calls on the target machine do not preserve
any registers; in other words, if @code{CALL_USED_REGISTERS} has 1
-for all registers. When defined, this macro enables @samp{-fcaller-saves}
+for all registers. When defined, this macro enables @samp{-fcaller-saves}
by default for all optimization levels. It has no effect for optimization
levels 2 and higher, where @samp{-fcaller-saves} is the default.
@samp{LP} followed by the number @var{labelno}, so you would generate
the name using @samp{LP%d} in a @code{fprintf}.
+@findex PROFILE_HOOK
+@item PROFILE_HOOK
+A C statement or compound statement to output to @var{file} some assembly
+code to call the profiling subroutine @code{mcount} even the target does
+not support profiling.
+
@findex NO_PROFILE_COUNTERS
@item NO_PROFILE_COUNTERS
Define this macro if the @code{mcount} subroutine on your system does
@findex FUNCTION_OK_FOR_SIBCALL
@item FUNCTION_OK_FOR_SIBCALL (@var{decl})
A C expression that evaluates to true if it is ok to perform a sibling
-call to @var{decl}.
+call to @var{decl}.
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. Use this macro to enforce these restrictions,
-as the @code{sibcall} md pattern can not fail, or fall over to a
+as the @code{sibcall} md pattern can not fail, or fall over to a
``normal'' call.
@end table
@findex TARGET_MEM_FUNCTIONS
@cindex @code{bcopy}, implicit usage
@cindex @code{memcpy}, implicit usage
+@cindex @code{memmove}, implicit usage
@cindex @code{bzero}, implicit usage
@cindex @code{memset}, implicit usage
@item TARGET_MEM_FUNCTIONS
Define this macro if GCC should generate calls to the ISO C
-(and System V) library functions @code{memcpy} and @code{memset}
-rather than the BSD functions @code{bcopy} and @code{bzero}.
+(and System V) library functions @code{memcpy}, @code{memmove} and
+@code{memset} rather than the BSD functions @code{bcopy} and @code{bzero}.
@findex LIBGCC_NEEDS_DOUBLE
@item LIBGCC_NEEDS_DOUBLE
-Define this macro if only @code{float} arguments cannot be passed to
-library routines (so they must be converted to @code{double}). This
-macro affects both how library calls are generated and how the library
-routines in @file{libgcc1.c} accept their arguments. It is useful on
+Define this macro if @code{float} arguments cannot be passed to library
+routines (so they must be converted to @code{double}). This macro
+affects both how library calls are generated and how the library
+routines in @file{libgcc.a} accept their arguments. It is useful on
machines where floating and fixed point arguments are passed
differently, such as the i860.
-@findex FLOAT_ARG_TYPE
-@item FLOAT_ARG_TYPE
-Define this macro to override the type used by the library routines to
-pick up arguments of type @code{float}. (By default, they use a union
-of @code{float} and @code{int}.)
-
-The obvious choice would be @code{float}---but that won't work with
-traditional C compilers that expect all arguments declared as @code{float}
-to arrive as @code{double}. To avoid this conversion, the library routines
-ask for the value as some other type and then treat it as a @code{float}.
-
-On some systems, no other type will work for this. For these systems,
-you must use @code{LIBGCC_NEEDS_DOUBLE} instead, to force conversion of
-the values @code{double} before they are passed.
-
-@findex FLOATIFY
-@item FLOATIFY (@var{passed-value})
-Define this macro to override the way library routines redesignate a
-@code{float} argument as a @code{float} instead of the type it was
-passed as. The default is an expression which takes the @code{float}
-field of the union.
-
-@findex FLOAT_VALUE_TYPE
-@item FLOAT_VALUE_TYPE
-Define this macro to override the type used by the library routines to
-return values that ought to have type @code{float}. (By default, they
-use @code{int}.)
-
-The obvious choice would be @code{float}---but that won't work with
-traditional C compilers gratuitously convert values declared as
-@code{float} into @code{double}.
-
-@findex INTIFY
-@item INTIFY (@var{float-value})
-Define this macro to override the way the value of a
-@code{float}-returning library routine should be packaged in order to
-return it. These functions are actually declared to return type
-@code{FLOAT_VALUE_TYPE} (normally @code{int}).
-
-These values can't be returned as type @code{float} because traditional
-C compilers would gratuitously convert the value to a @code{double}.
-
-A local variable named @code{intify} is always available when the macro
-@code{INTIFY} is used. It is a union of a @code{float} field named
-@code{f} and a field named @code{i} whose type is
-@code{FLOAT_VALUE_TYPE} or @code{int}.
-
-If you don't define this macro, the default definition works by copying
-the value through that union.
-
-@findex nongcc_SI_type
-@item nongcc_SI_type
-Define this macro as the name of the data type corresponding to
-@code{SImode} in the system's own C compiler.
-
-You need not define this macro if that type is @code{long int}, as it usually
-is.
-
-@findex nongcc_word_type
-@item nongcc_word_type
-Define this macro as the name of the data type corresponding to the
-word_mode in the system's own C compiler.
-
-You need not define this macro if that type is @code{long int}, as it usually
-is.
-
-@findex perform_@dots{}
-@item perform_@dots{}
-Define these macros to supply explicit C statements to carry out various
-arithmetic operations on types @code{float} and @code{double} in the
-library routines in @file{libgcc1.c}. See that file for a full list
-of these macros and their arguments.
-
-On most machines, you don't need to define any of these macros, because
-the C compiler that comes with the system takes care of doing them.
-
@findex NEXT_OBJC_RUNTIME
@item NEXT_OBJC_RUNTIME
Define this macro to generate code for Objective C message sending using
that needs reloading, with a valid memory address for an operand of mode
@var{mode}. @var{win} will be a C statement label elsewhere in the code.
It is not necessary to define this macro, but it might be useful for
-performance reasons.
+performance reasons.
For example, on the i386, it is sometimes possible to use a single
reload register instead of two by reloading a sum of two pseudo
@findex EXTRA_CC_MODES
@item EXTRA_CC_MODES
-A list of additional modes for condition code values in registers
+A list of additional modes for condition code values in registers
(@pxref{Jump Patterns}). This macro should expand to a sequence of
calls of the macro @code{CC} separated by white space. @code{CC} takes
two arguments. The first is the enumeration name of the mode, which
: reverse_condition_maybe_unordered (CODE))
@end smallexample
+@findex REVERSE_CONDEXEC_PREDICATES_P
+@item REVERSE_CONDEXEC_PREDICATES_P (@var{code1}, @var{code2})
+A C expression that returns true if the conditional execution predicate
+@var{code1} is the inverse of @var{code2} and vice versa. Define this to
+return 0 if the target has conditional execution predicates that cannot be
+reversed safely. If no expansion is specified, this macro is defined as
+follows:
+
+@smallexample
+#define REVERSE_CONDEXEC_PREDICATES_P (x, y) ((x) == reverse_condition (y))
+@end smallexample
+
@end table
@node Costs
value.
This macro is optional; do not define it if the default cost assumptions
-are adequate for the target machine.
+are adequate for the target machine.
@findex ADDRESS_COST
@item ADDRESS_COST (@var{address})
@findex JUMP_TABLES_IN_TEXT_SECTION
@item JUMP_TABLES_IN_TEXT_SECTION
-Define this macro to be an expression with a non-zero value if jump
+Define this macro to be an expression with a non-zero value if jump
tables (for @code{tablejump} insns) should be output in the text
section, along with the assembler instructions. Otherwise, the
readonly data section is used.
On systems that use SDB, it is necessary to output certain commands;
see @file{attasm.h}.
-@findex ASM_IDENTIFY_GCC
-@item ASM_IDENTIFY_GCC (@var{file})
-A C statement to output assembler commands which will identify
-the object file as having been compiled with GCC (or another
-GNU compiler).
-
-If you don't define this macro, the string @samp{gcc_compiled.:}
-is output. This string is calculated to define a symbol which,
-on BSD systems, will never be defined for any other reason.
-GDB checks for the presence of this symbol when reading the
-symbol table of an executable.
-
-On non-BSD systems, you must arrange communication with GDB in
-some other fashion. If GDB is not used on your system, you can
-define this macro with an empty body.
-
@findex ASM_COMMENT_START
@item ASM_COMMENT_START
A C string constant describing how to begin a comment in the target
sequence of single-byte constants. If this macro is not defined, the
default is @code{"\t.byte\t"}.
+@findex UNALIGNED_SHORT_ASM_OP
+@findex UNALIGNED_INT_ASM_OP
+@findex UNALIGNED_DOUBLE_INT_ASM_OP
+@item UNALIGNED_SHORT_ASM_OP
+@itemx UNALIGNED_INT_ASM_OP
+@itemx UNALIGNED_DOUBLE_INT_ASM_OP
+A C string constant, including spacing, giving the pseudo-op to use
+to assemble 16-, 32-, and 64-bit integers respectively @emph{without}
+adding implicit padding or alignment. These macros are required if
+DWARF 2 frame unwind is used. On ELF systems, these will default
+to @code{.2byte}, @code{.4byte}, and @code{.8byte}.@refill
+
@findex ASM_OUTPUT_ASCII
@item ASM_OUTPUT_ASCII (@var{stream}, @var{ptr}, @var{len})
A C statement to output to the stdio stream @var{stream} an assembler
@findex ASM_CLOSE_PAREN
@item ASM_OPEN_PAREN
@itemx ASM_CLOSE_PAREN
-These macros are defined as C string constant, describing the syntax
+These macros are defined as C string constants, describing the syntax
in the assembler for grouping arithmetic expressions. The following
definitions are correct for most assemblers:
On systems where the assembler can handle quoted names, you can use this
macro to provide more human-readable names.
+
+@findex ASM_DECLARE_UNRESOLVED_REFERENCE
+@item ASM_DECLARE_UNRESOLVED_REFERENCE (@var{stream}, @var{name})
+A C statement (sans semicolon) to output to the stdio stream
+@var{stream} commands to declare that the label @var{name} is an
+unresolved Objective-C class reference. This is only needed for targets
+whose linkers have special support for NeXT-style runtimes.
@end table
@node Initialization
the jump-table.
@end table
-@node Exception Region Output
+@node Exception Region Output
@subsection Assembler Commands for Exception Regions
@c prevent bad page break with this line
@findex LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
@item LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP
-The maximum number of bytes to skip when applying
+The maximum number of bytes to skip when applying
@code{LABEL_ALIGN_AFTER_BARRIER}. This works only if
@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined.
NUM_MODES_FOR_MODE_SWITCHING, to denote the mode that @var{entity} must
be switched into prior to the execution of INSN.
-@findex NORMAL_MODE
+@findex NORMAL_MODE
@item NORMAL_MODE (@var{entity})
If this macro is defined, it is evaluated for every @var{entity} that needs
mode switching. It should evaluate to an integer, which is a mode that
@item SPECIAL_MODE_PREDICATES
@findex SPECIAL_MODE_PREDICATES
Define this if you have special predicates that know special things
-about modes. Genrecog will warn about certain forms of
+about modes. Genrecog will warn about certain forms of
@code{match_operand} without a mode; if the operand predicate is
-listed in @code{SPECIAL_MODE_PREDICATES}, the warning will be
+listed in @code{SPECIAL_MODE_PREDICATES}, the warning will be
suppressed.
Here is an example from the IA-32 port (@code{ext_register_operand}
Optional: return the preferred mode for an @code{addr_diff_vec}
when the minimum and maximum offset are known. If you define this,
it enables extra code in branch shortening to deal with @code{addr_diff_vec}.
-To make this work, you also have to define INSN_ALIGN and
+To make this work, you also have to define INSN_ALIGN and
make the alignment for @code{addr_diff_vec} explicit.
The @var{body} argument is provided so that the offset_unsigned and scale
flags can be updated.
A C expression to cancel any machine dependent modifications in
converting code to conditional execution in the basic blocks
@code{TEST_BB}, @code{THEN_BB}, @code{ELSE_BB}, and @code{JOIN_BB}.
+
+@findex MD_INIT_BUILTINS
+@item MD_INIT_BUILTINS
+Define this macro if you have any machine-specific builtin functions that
+need to be defined. It should be a C expression that performs the
+necessary setup.
+
+Machine specific builtins 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 builtin function, call the function @code{builtin_function}
+which is defined by the language frontend. You can use any type nodes set
+up by @code{build_common_tree_nodes} and @code{build_common_tree_nodes_2};
+only language frontends that use these two functions will use
+@samp{MD_INIT_BUILTINS}.
+
+@findex MD_EXPAND_BUILTIN
+@item MD_EXPAND_BUILTIN(@var{exp}, @var{target}, @var{subtarget}, @var{mode}, @var{ignore})
+
+Expand a call to a machine specific builtin that was set up by
+@samp{MD_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 macro should return the result of the call to the builtin.
+
@end table
OSDN Git Service
