This is
/es/build/frv-050408/1/frv550-uclinux/X-tools-build/gcc/doc/gccint.info,
produced by makeinfo version 4.0 from
/es/build/frv-050408/1/frv550-uclinux/sources/tools-src/gcc/doc/gccint.texi.

Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.

   Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "Funding Free
Software", the Front-Cover texts being (a) (see below), and with the
Back-Cover Texts being (b) (see below).  A copy of the license is
included in the section entitled "GNU Free Documentation License".

   (a) The FSF's Front-Cover Text is:

   A GNU Manual

   (b) The FSF's Back-Cover Text is:

   You have freedom to copy and modify this GNU Manual, like GNU
software.  Copies published by the Free Software Foundation raise
funds for GNU development.
INFO-DIR-SECTION Programming
START-INFO-DIR-ENTRY
* gccint: (gccint).            Internals of the GNU Compiler Collection.
END-INFO-DIR-ENTRY
   This file documents the internals of the GNU compilers.

   Published by the Free Software Foundation
59 Temple Place - Suite 330
Boston, MA 02111-1307 USA

File: gccint.info,  Node: Function Entry,  Next: Profiling,  Prev: Caller Saves,  Up: Stack and Calling

Function Entry and Exit
-----------------------

   This section describes the macros that output function entry
("prologue") and exit ("epilogue") code.

 - Target Hook: void TARGET_ASM_FUNCTION_PROLOGUE (FILE *FILE,
          HOST_WIDE_INT SIZE)
     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 SIZE additional bytes
     of storage for the local variables.  SIZE is an integer.  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.

     To determine which registers to save, the macro can refer to the
     array `regs_ever_live': element R is nonzero if hard register R is
     used anywhere within the function.  This implies the function
     prologue should save register R, provided it is not one of the
     call-used registers.  (`TARGET_ASM_FUNCTION_EPILOGUE' must
     likewise use `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.

     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
     `frame_pointer_needed'.  The variable's value will be 1 at run
     time in a function that needs a frame pointer.  *Note
     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 `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.

 - Target Hook: void TARGET_ASM_FUNCTION_END_PROLOGUE (FILE *FILE)
     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.  *Note prologue instruction pattern::.

 - Target Hook: void TARGET_ASM_FUNCTION_BEGIN_EPILOGUE (FILE *FILE)
     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.  *Note epilogue instruction pattern::.

 - Target Hook: void TARGET_ASM_FUNCTION_EPILOGUE (FILE *FILE,
          HOST_WIDE_INT SIZE)
     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
     `TARGET_ASM_FUNCTION_PROLOGUE', and the registers to restore are
     determined from `regs_ever_live' and `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 `return' and do not define the macro
     `TARGET_ASM_FUNCTION_EPILOGUE' at all.

     Do not define a pattern named `return' if you want the
     `TARGET_ASM_FUNCTION_EPILOGUE' to be used.  If you want the target
     switches to control whether return instructions or epilogues are
     used, define a `return' pattern with a validity condition that
     tests the target switches appropriately.  If the `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
     `frame_pointer_needed'.  The variable's value will be 1 when
     compiling a function that needs a frame pointer.

     Normally, `TARGET_ASM_FUNCTION_PROLOGUE' and
     `TARGET_ASM_FUNCTION_EPILOGUE' must treat leaf functions specially.
     The C variable `current_function_is_leaf' is nonzero for such a
     function.  *Note 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 `-mrtd' pops arguments in functions that take a fixed
     number of arguments.

     Your definition of the macro `RETURN_POPS_ARGS' decides which
     functions pop their own arguments.  `TARGET_ASM_FUNCTION_EPILOGUE'
     needs to know what was decided.  The variable that is called
     `current_function_pops_args' is the number of bytes of its
     arguments that a function should pop.  *Note Scalar Return::.

   * A region of `current_function_pretend_args_size' bytes of
     uninitialized space just underneath the first argument arriving on
     the stack.  (This may not be at the very start of the allocated
     stack region if the calling sequence has pushed anything else
     since pushing the stack arguments.  But usually, on such machines,
     nothing else has been pushed yet, because the function prologue
     itself does all the pushing.)  This region is used on machines
     where an argument may be passed partly in registers and partly in
     memory, and, in some cases to support the features in `<stdarg.h>'.

   * An area of memory used to save certain registers used by the
     function.  The size of this area, which may also include space for
     such things as the return address and pointers to previous stack
     frames, is machine-specific and usually depends on which registers
     have been used in the function.  Machines with register windows
     often do not require a save area.

   * A region of at least SIZE bytes, possibly rounded up to an
     allocation boundary, to contain the local variables of the
     function.  On some machines, this region and the save area may
     occur in the opposite order, with the save area closer to the top
     of the stack.

   * Optionally, when `ACCUMULATE_OUTGOING_ARGS' is defined, a region of
     `current_function_outgoing_args_size' bytes to be used for outgoing
     argument lists of the function.  *Note Stack Arguments::.

   Normally, it is necessary for the macros
`TARGET_ASM_FUNCTION_PROLOGUE' and `TARGET_ASM_FUNCTION_EPILOGUE' to
treat leaf functions specially.  The C variable
`current_function_is_leaf' is nonzero for such a function.

 - Macro: EXIT_IGNORE_STACK
     Define this macro as a C expression that is nonzero if the return
     instruction or the function epilogue ignores the value of the stack
     pointer; in other words, if it is safe to delete an instruction to
     adjust the stack pointer before a return from the function.

     Note that this macro's value is relevant only for functions for
     which frame pointers are maintained.  It is never safe to delete a
     final stack adjustment in a function that has no frame pointer,
     and the compiler knows this regardless of `EXIT_IGNORE_STACK'.

 - Macro: EPILOGUE_USES (REGNO)
     Define this macro as a C expression that is nonzero for registers
     that are used by the epilogue or the `return' pattern.  The stack
     and frame pointer registers are already be assumed to be used as
     needed.

 - Macro: EH_USES (REGNO)
     Define this macro as a C expression that is nonzero for registers
     that are used by the exception handling mechanism, and so should
     be considered live on entry to an exception edge.

 - Macro: DELAY_SLOTS_FOR_EPILOGUE
     Define this macro if the function epilogue contains delay slots to
     which instructions from the rest of the function can be "moved".
     The definition should be a C expression whose value is an integer
     representing the number of delay slots there.

 - Macro: ELIGIBLE_FOR_EPILOGUE_DELAY (INSN, N)
     A C expression that returns 1 if INSN can be placed in delay slot
     number N of the epilogue.

     The argument N is an integer which identifies the delay slot now
     being considered (since different slots may have different rules of
     eligibility).  It is never negative and is always less than the
     number of epilogue delay slots (what `DELAY_SLOTS_FOR_EPILOGUE'
     returns).  If you reject a particular insn for a given delay slot,
     in principle, it may be reconsidered for a subsequent delay slot.
     Also, other insns may (at least in principle) be considered for
     the so far unfilled delay slot.

     The insns accepted to fill the epilogue delay slots are put in an
     RTL list made with `insn_list' objects, stored in the variable
     `current_function_epilogue_delay_list'.  The insn for the first
     delay slot comes first in the list.  Your definition of the macro
     `TARGET_ASM_FUNCTION_EPILOGUE' should fill the delay slots by
     outputting the insns in this list, usually by calling
     `final_scan_insn'.

     You need not define this macro if you did not define
     `DELAY_SLOTS_FOR_EPILOGUE'.

 - Target Hook: void TARGET_ASM_OUTPUT_MI_THUNK (FILE *FILE, tree
          THUNK_FNDECL, HOST_WIDE_INT DELTA, tree FUNCTION)
     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 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 `this' pointer
     in C++.  This is the incoming argument _before_ the function
     prologue, e.g. `%o0' on a sparc.  The addition must preserve the
     values of all other incoming arguments.

     After the addition, emit code to jump to FUNCTION, which is a
     `FUNCTION_DECL'.  This is a direct pure jump, not a call, and does
     not touch the return address.  Hence returning from FUNCTION will
     return to whoever called the current `thunk'.

     The effect must be as if FUNCTION had been called directly with
     the adjusted first argument.  This macro is responsible for
     emitting all of the code for a thunk function;
     `TARGET_ASM_FUNCTION_PROLOGUE' and `TARGET_ASM_FUNCTION_EPILOGUE'
     are not invoked.

     The THUNK_FNDECL is redundant.  (DELTA and 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 FUNCTION instead of jumping to it.  The generic
     approach does not support varargs.

 - Target Hook: void TARGET_ASM_OUTPUT_MI_VCALL_THUNK (FILE *FILE, tree
          THUNK_FNDECL, HOST_WIDE_INT DELTA, int VCALL_OFFSET, tree
          FUNCTION)
     A function like `TARGET_ASM_OUTPUT_MI_THUNK', except that if
     VCALL_OFFSET is nonzero, an additional adjustment should be made
     after adding `delta'.  In particular, if P is the adjusted
     pointer, the following adjustment should be made:

          p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]

     If this function is defined, it will always be used in place of
     `TARGET_ASM_OUTPUT_MI_THUNK'.


File: gccint.info,  Node: Profiling,  Next: Tail Calls,  Prev: Function Entry,  Up: Stack and Calling

Generating Code for Profiling
-----------------------------

   These macros will help you generate code for profiling.

 - Macro: FUNCTION_PROFILER (FILE, LABELNO)
     A C statement or compound statement to output to FILE some
     assembler code to call the profiling subroutine `mcount'.

     The details of how `mcount' expects to be called are determined by
     your operating system environment, not by GCC.  To figure them out,
     compile a small program for profiling using the system's installed
     C compiler and look at the assembler code that results.

     Older implementations of `mcount' expect the address of a counter
     variable to be loaded into some register.  The name of this
     variable is `LP' followed by the number LABELNO, so you would
     generate the name using `LP%d' in a `fprintf'.

 - Macro: PROFILE_HOOK
     A C statement or compound statement to output to FILE some assembly
     code to call the profiling subroutine `mcount' even the target does
     not support profiling.

 - Macro: NO_PROFILE_COUNTERS
     Define this macro if the `mcount' subroutine on your system does
     not need a counter variable allocated for each function.  This is
     true for almost all modern implementations.  If you define this
     macro, you must not use the LABELNO argument to
     `FUNCTION_PROFILER'.

 - Macro: PROFILE_BEFORE_PROLOGUE
     Define this macro if the code for function profiling should come
     before the function prologue.  Normally, the profiling code comes
     after.


File: gccint.info,  Node: Tail Calls,  Prev: Profiling,  Up: Stack and Calling

Permitting tail calls
---------------------

 - Target Hook: bool TARGET_FUNCTION_OK_FOR_SIBCALL (tree DECL, tree
          EXP)
     True if it is ok to do sibling call optimization for the specified
     call expression EXP.  DECL will be the called function, or `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 `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.


File: gccint.info,  Node: Varargs,  Next: Trampolines,  Prev: Stack and Calling,  Up: Target Macros

Implementing the Varargs Macros
===============================

   GCC comes with an implementation of `<varargs.h>' and `<stdarg.h>'
that work without change on machines that pass arguments on the stack.
Other machines require their own implementations of varargs, and the
two machine independent header files must have conditionals to include
it.

   ISO `<stdarg.h>' differs from traditional `<varargs.h>' mainly in
the calling convention for `va_start'.  The traditional implementation
takes just one argument, which is the variable in which to store the
argument pointer.  The ISO implementation of `va_start' takes an
additional second argument.  The user is supposed to write the last
named argument of the function here.

   However, `va_start' should not use this argument.  The way to find
the end of the named arguments is with the built-in functions described
below.

 - Macro: __builtin_saveregs ()
     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 `va_start' must use
     `__builtin_saveregs', unless you use `SETUP_INCOMING_VARARGS' (see
     below) instead.

     On some machines, `__builtin_saveregs' is open-coded under the
     control of the macro `EXPAND_BUILTIN_SAVEREGS'.  On other machines,
     it calls a routine written in assembler language, found in
     `libgcc2.c'.

     Code generated for the call to `__builtin_saveregs' appears at the
     beginning of the function, as opposed to where the call to
     `__builtin_saveregs' is written, regardless of what the code is.
     This is because the registers must be saved before the function
     starts to use them for its own purposes.

 - Macro: __builtin_args_info (CATEGORY)
     Use this built-in function to find the first anonymous arguments in
     registers.

     In general, a machine may have several categories of registers
     used for arguments, each for a particular category of data types.
     (For example, on some machines, floating-point registers are used
     for floating-point arguments while other arguments are passed in
     the general registers.)  To make non-varargs functions use the
     proper calling convention, you have defined the `CUMULATIVE_ARGS'
     data type to record how many registers in each category have been
     used so far

     `__builtin_args_info' accesses the same data structure of type
     `CUMULATIVE_ARGS' after the ordinary argument layout is finished
     with it, with CATEGORY specifying which word to access.  Thus, the
     value indicates the first unused register in a given category.

     Normally, you would use `__builtin_args_info' in the implementation
     of `va_start', accessing each category just once and storing the
     value in the `va_list' object.  This is because `va_list' will
     have to update the values, and there is no way to alter the values
     accessed by `__builtin_args_info'.

 - Macro: __builtin_next_arg (LASTARG)
     This is the equivalent of `__builtin_args_info', for stack
     arguments.  It returns the address of the first anonymous stack
     argument, as type `void *'.  If `ARGS_GROW_DOWNWARD', it returns
     the address of the location above the first anonymous stack
     argument.  Use it in `va_start' to initialize the pointer for
     fetching arguments from the stack.  Also use it in `va_start' to
     verify that the second parameter LASTARG is the last named argument
     of the current function.

 - Macro: __builtin_classify_type (OBJECT)
     Since each machine has its own conventions for which data types are
     passed in which kind of register, your implementation of `va_arg'
     has to embody these conventions.  The easiest way to categorize the
     specified data type is to use `__builtin_classify_type' together
     with `sizeof' and `__alignof__'.

     `__builtin_classify_type' ignores the value of OBJECT, considering
     only its data type.  It returns an integer describing what kind of
     type that is--integer, floating, pointer, structure, and so on.

     The file `typeclass.h' defines an enumeration that you can use to
     interpret the values of `__builtin_classify_type'.

   These machine description macros help implement varargs:

 - Target Hook: rtx TARGET_EXPAND_BUILTIN_SAVEREGS (void)
     If defined, this hook produces the machine-specific code for a
     call to `__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 `__builtin_saveregs'.

 - Target Hook: void TARGET_SETUP_INCOMING_VARARGS (CUMULATIVE_ARGS
          *ARGS_SO_FAR, enum machine_mode MODE, tree TYPE, int
          *PRETEND_ARGS_SIZE, int SECOND_TIME)
     This target hook offers an alternative to using
     `__builtin_saveregs' and defining the hook
     `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 ARGS_SO_FAR points to the `CUMULATIVE_ARGS' data
     structure, containing the values that are obtained after
     processing the named arguments.  The arguments MODE and 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 _not_ used for the named arguments, and
     second, store the size of the data thus pushed into the
     `int'-valued variable pointed to by 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,
     `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 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
     `TARGET_SETUP_INCOMING_VARARGS' should not generate any
     instructions in this case.

 - Target Hook: bool TARGET_STRICT_ARGUMENT_NAMING (CUMULATIVE_ARGS *CA)
     Define this hook to return `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 NAMED argument to `FUNCTION_ARG' is set
     for varargs and stdarg functions.  If this hook returns `true',
     the NAMED argument is always true for named arguments, and false
     for unnamed arguments.  If it returns `false', but
     `TARGET_PRETEND_OUTOGOING_VARARGS_NAMED' returns `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 zero.

 - Target Hook: bool TARGET_PRETEND_OUTGOING_VARARGS_NAMED
     If you need to conditionally change ABIs so that one works with
     `TARGET_SETUP_INCOMING_VARARGS', but the other works like neither
     `TARGET_SETUP_INCOMING_VARARGS' nor
     `TARGET_STRICT_ARGUMENT_NAMING' was defined, then define this hook
     to return `true' if `SETUP_INCOMING_VARARGS' is used, `false'
     otherwise.  Otherwise, you should not define this hook.


File: gccint.info,  Node: Trampolines,  Next: Library Calls,  Prev: Varargs,  Up: Target Macros

Trampolines for Nested Functions
================================

   A "trampoline" is a small piece of code that is created at run time
when the address of a nested function is taken.  It normally resides on
the stack, in the stack frame of the containing function.  These macros
tell GCC how to generate code to allocate and initialize a trampoline.

   The instructions in the trampoline must do two things: load a
constant address into the static chain register, and jump to the real
address of the nested function.  On CISC machines such as the m68k,
this requires two instructions, a move immediate and a jump.  Then the
two addresses exist in the trampoline as word-long immediate operands.
On RISC machines, it is often necessary to load each address into a
register in two parts.  Then pieces of each address form separate
immediate operands.

   The code generated to initialize the trampoline must store the
variable parts--the static chain value and the function address--into
the immediate operands of the instructions.  On a CISC machine, this is
simply a matter of copying each address to a memory reference at the
proper offset from the start of the trampoline.  On a RISC machine, it
may be necessary to take out pieces of the address and store them
separately.

 - Macro: TRAMPOLINE_TEMPLATE (FILE)
     A C statement to output, on the stream FILE, 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 macro, it means no template is needed
     for the target.  Do not define this macro 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.

 - Macro: TRAMPOLINE_SECTION
     The name of a subroutine to switch to the section in which the
     trampoline template is to be placed (*note Sections::).  The
     default is a value of `readonly_data_section', which places the
     trampoline in the section containing read-only data.

 - Macro: TRAMPOLINE_SIZE
     A C expression for the size in bytes of the trampoline, as an
     integer.

 - Macro: TRAMPOLINE_ALIGNMENT
     Alignment required for trampolines, in bits.

     If you don't define this macro, the value of `BIGGEST_ALIGNMENT'
     is used for aligning trampolines.

 - Macro: INITIALIZE_TRAMPOLINE (ADDR, FNADDR, STATIC_CHAIN)
     A C statement to initialize the variable parts of a trampoline.
     ADDR is an RTX for the address of the trampoline; FNADDR is an RTX
     for the address of the nested function; STATIC_CHAIN is an RTX for
     the static chain value that should be passed to the function when
     it is called.

 - Macro: TRAMPOLINE_ADJUST_ADDRESS (ADDR)
     A C statement that should perform any machine-specific adjustment
     in the address of the trampoline.  Its argument contains the
     address that was passed to `INITIALIZE_TRAMPOLINE'.  In case the
     address to be used for a function call should be different from
     the address in which the template was stored, the different
     address should be assigned to ADDR.  If this macro is not defined,
     ADDR will be used for function calls.

     If this macro is not defined, by default the trampoline is
     allocated as a stack slot.  This default is right for most
     machines.  The exceptions are machines where it is impossible to
     execute instructions in the stack area.  On such machines, you may
     have to implement a separate stack, using this macro in
     conjunction with `TARGET_ASM_FUNCTION_PROLOGUE' and
     `TARGET_ASM_FUNCTION_EPILOGUE'.

     FP points to a data structure, a `struct function', which
     describes the compilation status of the immediate containing
     function of the function which the trampoline is for.  The stack
     slot for the trampoline is in the stack frame of this containing
     function.  Other allocation strategies probably must do something
     analogous with this information.

   Implementing trampolines is difficult on many machines because they
have separate instruction and data caches.  Writing into a stack
location fails to clear the memory in the instruction cache, so when
the program jumps to that location, it executes the old contents.

   Here are two possible solutions.  One is to clear the relevant parts
of the instruction cache whenever a trampoline is set up.  The other is
to make all trampolines identical, by having them jump to a standard
subroutine.  The former technique makes trampoline execution faster; the
latter makes initialization faster.

   To clear the instruction cache when a trampoline is initialized,
define the following macro.

 - Macro: CLEAR_INSN_CACHE (BEG, END)
     If defined, expands to a C expression clearing the _instruction
     cache_ in the specified interval.  The definition of this macro
     would typically be a series of `asm' statements.  Both BEG and END
     are both pointer expressions.

   To use a standard subroutine, define the following macro.  In
addition, you must make sure that the instructions in a trampoline fill
an entire cache line with identical instructions, or else ensure that
the beginning of the trampoline code is always aligned at the same
point in its cache line.  Look in `m68k.h' as a guide.

 - Macro: TRANSFER_FROM_TRAMPOLINE
     Define this macro if trampolines need a special subroutine to do
     their work.  The macro should expand to a series of `asm'
     statements which will be compiled with GCC.  They go in a library
     function named `__transfer_from_trampoline'.

     If you need to avoid executing the ordinary prologue code of a
     compiled C function when you jump to the subroutine, you can do so
     by placing a special label of your own in the assembler code.  Use
     one `asm' statement to generate an assembler label, and another to
     make the label global.  Then trampolines can use that label to
     jump directly to your special assembler code.


File: gccint.info,  Node: Library Calls,  Next: Addressing Modes,  Prev: Trampolines,  Up: Target Macros

Implicit Calls to Library Routines
==================================

   Here is an explanation of implicit calls to library routines.

 - Macro: 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 are ABI-mandated names that the compiler should
     provide.

 - Target Hook: void TARGET_INIT_LIBFUNCS (void)
     This hook should declare additional library routines or rename
     existing ones, using the functions `set_optab_libfunc' and
     `init_one_libfunc' defined in `optabs.c'.  `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.

 - Macro: TARGET_FLOAT_LIB_COMPARE_RETURNS_BOOL (MODE, COMPARISON)
     This macro should return `true' if the library routine that
     implements the floating point comparison operator COMPARISON in
     mode MODE will return a boolean, and FALSE if it will return a
     tristate.

     GCC's own floating point libraries return tristates from the
     comparison operators, so the default returns false always.  Most
     ports don't need to define this macro.

 - Macro: US_SOFTWARE_GOFAST
     Define this macro if your system C library uses the US Software
     GOFAST library to provide floating point emulation.

     In addition to defining this macro, your architecture must set
     `TARGET_INIT_LIBFUNCS' to `gofast_maybe_init_libfuncs', or else
     call that function from its version of that hook.  It is defined
     in `config/gofast.h', which must be included by your
     architecture's `CPU.c' file.  See `sparc/sparc.c' for an example.

     If this macro is defined, the
     `TARGET_FLOAT_LIB_COMPARE_RETURNS_BOOL' target hook must return
     false for `SFmode' and `DFmode' comparisons.

 - Macro: TARGET_EDOM
     The value of `EDOM' on the target machine, as a C integer constant
     expression.  If you don't define this macro, GCC does not attempt
     to deposit the value of `EDOM' into `errno' directly.  Look in
     `/usr/include/errno.h' to find the value of `EDOM' on your system.

     If you do not define `TARGET_EDOM', then compiled code reports
     domain errors by calling the library function and letting it
     report the error.  If mathematical functions on your system use
     `matherr' when there is an error, then you should leave
     `TARGET_EDOM' undefined so that `matherr' is used normally.

 - Macro: GEN_ERRNO_RTX
     Define this macro as a C expression to create an rtl expression
     that refers to the global "variable" `errno'.  (On certain systems,
     `errno' may not actually be a variable.)  If you don't define this
     macro, a reasonable default is used.

 - Macro: TARGET_MEM_FUNCTIONS
     Define this macro if GCC should generate calls to the ISO C (and
     System V) library functions `memcpy', `memmove' and `memset'
     rather than the BSD functions `bcopy' and `bzero'.

 - Macro: TARGET_C99_FUNCTIONS
     When this macro is nonzero, GCC will implicitly optimize `sin'
     calls into `sinf' and similarly for other functions defined by C99
     standard.  The default is nonzero that should be proper value for
     most modern systems, however number of existing systems lacks
     support for these functions in the runtime so they needs this
     macro to be redefined to 0.

 - Macro: NEXT_OBJC_RUNTIME
     Define this macro to generate code for Objective-C message sending
     using the calling convention of the NeXT system.  This calling
     convention involves passing the object, the selector and the
     method arguments all at once to the method-lookup library function.

     The default calling convention passes just the object and the
     selector to the lookup function, which returns a pointer to the
     method.


File: gccint.info,  Node: Addressing Modes,  Next: Condition Code,  Prev: Library Calls,  Up: Target Macros

Addressing Modes
================

   This is about addressing modes.

 - Macro: HAVE_PRE_INCREMENT
 - Macro: HAVE_PRE_DECREMENT
 - Macro: HAVE_POST_INCREMENT
 - Macro: HAVE_POST_DECREMENT
     A C expression that is nonzero if the machine supports
     pre-increment, pre-decrement, post-increment, or post-decrement
     addressing respectively.

 - Macro: HAVE_PRE_MODIFY_DISP
 - Macro: HAVE_POST_MODIFY_DISP
     A C expression that is nonzero if the machine supports pre- or
     post-address side-effect generation involving constants other than
     the size of the memory operand.

 - Macro: HAVE_PRE_MODIFY_REG
 - Macro: HAVE_POST_MODIFY_REG
     A C expression that is nonzero if the machine supports pre- or
     post-address side-effect generation involving a register
     displacement.

 - Macro: CONSTANT_ADDRESS_P (X)
     A C expression that is 1 if the RTX X is a constant which is a
     valid address.  On most machines, this can be defined as
     `CONSTANT_P (X)', but a few machines are more restrictive in which
     constant addresses are supported.

 - Macro: CONSTANT_P (X)
     `CONSTANT_P', which is defined by target-independent code, accepts
     integer-values expressions whose values are not explicitly known,
     such as `symbol_ref', `label_ref', and `high' expressions and
     `const' arithmetic expressions, in addition to `const_int' and
     `const_double' expressions.

 - Macro: MAX_REGS_PER_ADDRESS
     A number, the maximum number of registers that can appear in a
     valid memory address.  Note that it is up to you to specify a
     value equal to the maximum number that `GO_IF_LEGITIMATE_ADDRESS'
     would ever accept.

 - Macro: GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)
     A C compound statement with a conditional `goto LABEL;' executed
     if X (an RTX) is a legitimate memory address on the target machine
     for a memory operand of mode MODE.

     It usually pays to define several simpler macros to serve as
     subroutines for this one.  Otherwise it may be too complicated to
     understand.

     This macro must exist in two variants: a strict variant and a
     non-strict one.  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.  In
     contexts where some kind of register is required, a pseudo-register
     with no hard register must be rejected.

     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.

     Compiler source files that want to use the strict variant of this
     macro define the macro `REG_OK_STRICT'.  You should use an `#ifdef
     REG_OK_STRICT' conditional to define the strict variant in that
     case and the non-strict variant otherwise.

     Subroutines to check for acceptable registers for various purposes
     (one for base registers, one for index registers, and so on) are
     typically among the subroutines used to define
     `GO_IF_LEGITIMATE_ADDRESS'.  Then only these subroutine macros
     need have two variants; the higher levels of macros may be the
     same whether strict or not.

     Normally, constant addresses which are the sum of a `symbol_ref'
     and an integer are stored inside a `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 `const' as legitimate.

     Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle constant
     sums that are not marked with  `const'.  It assumes that a naked
     `plus' indicates indexing.  If so, then you _must_ reject such
     naked constant sums as illegitimate addresses, so that none of
     them will be given to `PRINT_OPERAND_ADDRESS'.

     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 `TARGET_ENCODE_SECTION_INFO' to store the
     information into the `symbol_ref', and then check for it here.
     When you see a `const', you will have to look inside it to find the
     `symbol_ref' in order to determine the section.  *Note Assembler
     Format::.

 - Macro: REG_OK_FOR_BASE_P (X)
     A C expression that is nonzero if X (assumed to be a `reg' RTX) is
     valid for use as a base register.  For hard registers, it should
     always accept those which the hardware permits and reject the
     others.  Whether the macro accepts or rejects pseudo registers
     must be controlled by `REG_OK_STRICT' as described above.  This
     usually requires two variant definitions, of which `REG_OK_STRICT'
     controls the one actually used.

 - Macro: REG_MODE_OK_FOR_BASE_P (X, MODE)
     A C expression that is just like `REG_OK_FOR_BASE_P', except that
     that expression may examine the mode of the memory reference in
     MODE.  You should define this macro if the mode of the memory
     reference affects whether a register may be used as a base
     register.  If you define this macro, the compiler will use it
     instead of `REG_OK_FOR_BASE_P'.

 - Macro: REG_OK_FOR_INDEX_P (X)
     A C expression that is nonzero if X (assumed to be a `reg' RTX) is
     valid for use as an index register.

     The difference between an index register and a base register is
     that the index register may be scaled.  If an address involves the
     sum of two registers, neither one of them scaled, then either one
     may be labeled the "base" and the other the "index"; but whichever
     labeling is used must fit the machine's constraints of which
     registers may serve in each capacity.  The compiler will try both
     labelings, looking for one that is valid, and will reload one or
     both registers only if neither labeling works.

 - Macro: FIND_BASE_TERM (X)
     A C expression to determine the base term of address X.  This
     macro is used in only one place: `find_base_term' in alias.c.

     It is always safe for this macro to not be defined.  It exists so
     that alias analysis can understand machine-dependent addresses.

     The typical use of this macro is to handle addresses containing a
     label_ref or symbol_ref within an UNSPEC.

 - Macro: LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)
     A C compound statement that attempts to replace X with a valid
     memory address for an operand of mode MODE.  WIN will be a C
     statement label elsewhere in the code; the macro definition may use

          GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);

     to avoid further processing if the address has become legitimate.

     X will always be the result of a call to `break_out_memory_refs',
     and OLDX will be the operand that was given to that function to
     produce X.

     The code generated by this macro should not alter the substructure
     of X.  If it transforms X into a more legitimate form, it should
     assign X (which will always be a C variable) a new value.

     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
     machine-dependent strategy can generate better code.

 - Macro: LEGITIMIZE_RELOAD_ADDRESS (X, MODE, OPNUM, TYPE, IND_LEVELS,
          WIN)
     A C compound statement that attempts to replace X, which is an
     address that needs reloading, with a valid memory address for an
     operand of mode MODE.  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.

     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
     registers into a register.  On the other hand, for number of RISC
     processors offsets are limited so that often an intermediate
     address needs to be generated in order to address a stack slot.
     By defining `LEGITIMIZE_RELOAD_ADDRESS' appropriately, the
     intermediate addresses generated for adjacent some stack slots can
     be made identical, and thus be shared.

     _Note_: This macro should be used with caution.  It is necessary
     to know something of how reload works in order to effectively use
     this, and it is quite easy to produce macros that build in too
     much knowledge of reload internals.

     _Note_: This macro must be able to reload an address created by a
     previous invocation of this macro.  If it fails to handle such
     addresses then the compiler may generate incorrect code or abort.

     The macro definition should use `push_reload' to indicate parts
     that need reloading; OPNUM, TYPE and IND_LEVELS are usually
     suitable to be passed unaltered to `push_reload'.

     The code generated by this macro must not alter the substructure of
     X.  If it transforms X into a more legitimate form, it should
     assign X (which will always be a C variable) a new value.  This
     also applies to parts that you change indirectly by calling
     `push_reload'.

     The macro definition may use `strict_memory_address_p' to test if
     the address has become legitimate.

     If you want to change only a part of X, one standard way of doing
     this is to use `copy_rtx'.  Note, however, that is unshares only a
     single level of rtl.  Thus, if the part to be changed is not at the
     top level, you'll need to replace first the top level.  It is not
     necessary for this macro to come up with a legitimate address;
     but often a machine-dependent strategy can generate better code.

 - Macro: GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)
     A C statement or compound statement with a conditional `goto
     LABEL;' executed if memory address X (an RTX) 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 ADDR is a valid address for the machine.

 - Macro: LEGITIMATE_CONSTANT_P (X)
     A C expression that is nonzero if X is a legitimate constant for
     an immediate operand on the target machine.  You can assume that X
     satisfies `CONSTANT_P', so you need not check this.  In fact, `1'
     is a suitable definition for this macro on machines where anything
     `CONSTANT_P' is valid.

