CbC/CbC_gcc: gcc/doc/tm.texi comparison

comparison gcc/doc/tm.texi @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	3bfb6c00c1e0
children	b7f97abdc517

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 * Target Attributes::   Defining target-specific uses of @code{__attribute__}.
 * Emulated TLS::        Emulated TLS support.
 * MIPS Coprocessors::   MIPS coprocessor support and how to customize it.
 * PCH Target::          Validity checking for precompiled headers.
 * C++ ABI::             Controlling C++ ABI changes.
+* Named Address Spaces:: Adding support for named address spaces
 * Misc::                Everything else.
 @end menu
 @node Target Structure
 @section The Global @code{targetm} Variable
 @deftypevar {extern int} target_flags
 This variable is declared in @file{options.h}, which is included before
 any target-specific headers.
 @end deftypevar
-@deftypevar {Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
+@deftypevr {Target Hook} int TARGET_DEFAULT_TARGET_FLAGS
 This variable specifies the initial value of @code{target_flags}.
 Its default setting is 0.
-@end deftypevar
+@end deftypevr
 @cindex optional hardware or system features
 @cindex features, optional, in system conventions
 @deftypefn {Target Hook} bool TARGET_HANDLE_OPTION (size_t @var{code}, const char *@var{arg}, int @var{value})
 defined, is executed once just after all the command options have been
 parsed.
 Don't use this macro to turn on various extra optimizations for
 @option{-O}.  That is what @code{OPTIMIZATION_OPTIONS} is for.
-@end defmac
+If you need to do something whenever the optimization level is
+changed via the optimize attribute or pragma, see
+@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}
+@end defmac
+@deftypefn {Target Hook} void TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
+This target function is similar to the macro @code{OVERRIDE_OPTIONS}
+but is called when the optimize level is changed via an attribute or
+pragma or when it is reset at the end of the code affected by the
+attribute or pragma.  It is not called at the beginning of compilation
+when @code{OVERRIDE_OPTIONS} is called so if you want to perform these
+actions then, you should have @code{OVERRIDE_OPTIONS} call
+@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}.
+@end deftypefn
 @defmac C_COMMON_OVERRIDE_OPTIONS
 This is similar to @code{OVERRIDE_OPTIONS} but is only used in the C
 language frontends (C, Objective-C, C++, Objective-C++) and so can be
 used to alter option flag variables which only exist in those
 @var{unsignedp} according to which kind of extension is more efficient.
 Do not define this macro if it would never modify @var{m}.
 @end defmac
-@defmac PROMOTE_FUNCTION_MODE
+@deftypefn {Target Hook} enum machine_mode TARGET_PROMOTE_FUNCTION_MODE (tree @var{type}, enum machine_mode @var{mode}, int *@var{punsignedp}, tree @var{funtype}, int @var{for_return})
-Like @code{PROMOTE_MODE}, but is applied to outgoing function arguments or
+Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or
-function return values, as specified by @code{TARGET_PROMOTE_FUNCTION_ARGS}
+function return values.  The target hook should return the new mode
-and @code{TARGET_PROMOTE_FUNCTION_RETURN}, respectively.
+and possibly change @code{*@var{punsignedp}} if the promotion should
+change signedness.  This function is called only for scalar @emph{or
-The default is @code{PROMOTE_MODE}.
+pointer} types.
-@end defmac
+@var{for_return} allows to distinguish the promotion of arguments and
-@deftypefn {Target Hook} bool TARGET_PROMOTE_FUNCTION_ARGS (tree @var{fntype})
+return values.  If it is @code{1}, a return value is being promoted and
-This target hook should return @code{true} if the promotion described by
+@code{TARGET_FUNCTION_VALUE} must perform the same promotions done here.
-@code{PROMOTE_FUNCTION_MODE} should be done for outgoing function
+If it is @code{2}, the returned mode should be that of the register in
-arguments.
+which an incoming parameter is copied, or the outgoing result is computed;
-@end deftypefn
+then the hook should return the same mode as @code{promote_mode}, though
+the signedness may be different.
-@deftypefn {Target Hook} bool TARGET_PROMOTE_FUNCTION_RETURN (tree @var{fntype})
-This target hook should return @code{true} if the promotion described by
+The default is to not promote arguments and return values.  You can
-@code{PROMOTE_FUNCTION_MODE} should be done for the return value of
+also define the hook to @code{default_promote_function_mode_always_promote}
-functions.
+if you would like to apply the same rules given by @code{PROMOTE_MODE}.
-If this target hook returns @code{true}, @code{TARGET_FUNCTION_VALUE}
-must perform the same promotions done by @code{PROMOTE_FUNCTION_MODE}.
 @end deftypefn
 @defmac PARM_BOUNDARY
 Normal alignment required for function parameters on the stack, in
 bits.  All stack parameters receive at least this much alignment
 Defining this macro only affects the way @file{libgcc.a} emulates
 floating-point arithmetic.
 The default definition of this macro returns false for all sizes.
 @end defmac
-@deftypefn {Target Hook} bool TARGET_VECTOR_OPAQUE_P (tree @var{type})
-This target hook should return @code{true} a vector is opaque.  That
-is, if no cast is needed when copying a vector value of type
-@var{type} into another vector lvalue of the same size.  Vector opaque
-types cannot be initialized.  The default is that there are no such
-types.
-@end deftypefn
 @deftypefn {Target Hook} bool TARGET_MS_BITFIELD_LAYOUT_P (tree @var{record_type})
 This target hook returns @code{true} if bit-fields in the given
 @var{record_type} are to be laid out following the rules of Microsoft
 Visual C/C++, namely: (i) a bit-field won't share the same storage
 If you don't define this macro, the default is the first of
 @code{"unsigned int"}, @code{"long unsigned int"}, or @code{"long long
 unsigned int"} that has as much precision as @code{long long unsigned
 int}.
+@end defmac
+@defmac SIG_ATOMIC_TYPE
+@defmacx INT8_TYPE
+@defmacx INT16_TYPE
+@defmacx INT32_TYPE
+@defmacx INT64_TYPE
+@defmacx UINT8_TYPE
+@defmacx UINT16_TYPE
+@defmacx UINT32_TYPE
+@defmacx UINT64_TYPE
+@defmacx INT_LEAST8_TYPE
+@defmacx INT_LEAST16_TYPE
+@defmacx INT_LEAST32_TYPE
+@defmacx INT_LEAST64_TYPE
+@defmacx UINT_LEAST8_TYPE
+@defmacx UINT_LEAST16_TYPE
+@defmacx UINT_LEAST32_TYPE
+@defmacx UINT_LEAST64_TYPE
+@defmacx INT_FAST8_TYPE
+@defmacx INT_FAST16_TYPE
+@defmacx INT_FAST32_TYPE
+@defmacx INT_FAST64_TYPE
+@defmacx UINT_FAST8_TYPE
+@defmacx UINT_FAST16_TYPE
+@defmacx UINT_FAST32_TYPE
+@defmacx UINT_FAST64_TYPE
+@defmacx INTPTR_TYPE
+@defmacx UINTPTR_TYPE
+C expressions for the standard types @code{sig_atomic_t},
+@code{int8_t}, @code{int16_t}, @code{int32_t}, @code{int64_t},
+@code{uint8_t}, @code{uint16_t}, @code{uint32_t}, @code{uint64_t},
+@code{int_least8_t}, @code{int_least16_t}, @code{int_least32_t},
+@code{int_least64_t}, @code{uint_least8_t}, @code{uint_least16_t},
+@code{uint_least32_t}, @code{uint_least64_t}, @code{int_fast8_t},
+@code{int_fast16_t}, @code{int_fast32_t}, @code{int_fast64_t},
+@code{uint_fast8_t}, @code{uint_fast16_t}, @code{uint_fast32_t},
+@code{uint_fast64_t}, @code{intptr_t}, and @code{uintptr_t}.  See
+@code{SIZE_TYPE} above for more information.
+If any of these macros evaluates to a null pointer, the corresponding
+type is not supported; if GCC is configured to provide
+@code{<stdint.h>} in such a case, the header provided may not conform
+to C99, depending on the type in question.  The defaults for all of
+these macros are null pointers.
 @end defmac
 @defmac TARGET_PTRMEMFUNC_VBIT_LOCATION
 The C++ compiler represents a pointer-to-member-function with a struct
 that looks like:
 @defmac STACK_REGS
 Define this if the machine has any stack-like registers.
 @end defmac
+@defmac STACK_REG_COVER_CLASS
+This is a cover class containing the stack registers.  Define this if
+the machine has any stack-like registers.
+@end defmac
 @defmac FIRST_STACK_REG
 The number of the first stack-like register.  This one is the top
 of the stack.
 @end defmac
 added to another register (as well as added to a displacement).
 @end defmac
 @defmac REGNO_OK_FOR_BASE_P (@var{num})
 A C expression which is nonzero if register number @var{num} is
-suitable for use as a base register in operand addresses.  It may be
+suitable for use as a base register in operand addresses.
-either a suitable hard register or a pseudo register that has been
+Like @code{TARGET_LEGITIMATE_ADDRESS_P}, this macro should also
-allocated such a hard register.
+define a strict and a non-strict variant.  Both variants behave
+the same for hard register; for pseudos, the strict variant will
+pass only those that have been allocated to a valid hard registers,
+while the non-strict variant will pass all pseudos.
+@findex REG_OK_STRICT
+Compiler source files that want to use the strict variant of this and
+other macros define the macro @code{REG_OK_STRICT}.  You should use an
+@code{#ifdef REG_OK_STRICT} conditional to define the strict variant in
+that case and the non-strict variant otherwise.
 @end defmac
 @defmac REGNO_MODE_OK_FOR_BASE_P (@var{num}, @var{mode})
 A C expression that is just like @code{REGNO_OK_FOR_BASE_P}, except that
 that expression may examine the mode of the memory reference in
 you define this macro, the compiler will use it instead of
 @code{REGNO_OK_FOR_BASE_P}.  The mode may be @code{VOIDmode} for
 addresses that appear outside a @code{MEM}, i.e., as an
 @code{address_operand}.
+This macro also has strict and non-strict variants.
 @end defmac
 @defmac REGNO_MODE_OK_FOR_REG_BASE_P (@var{num}, @var{mode})
 A C expression which is nonzero if register number @var{num} is suitable for
 use as a base register in base plus index operand addresses, accessing
 define this macro if base plus index addresses have different requirements
 than other base register uses.
 Use of this macro is deprecated; please use the more general
 @code{REGNO_MODE_CODE_OK_FOR_BASE_P}.
+This macro also has strict and non-strict variants.
 @end defmac
 @defmac REGNO_MODE_CODE_OK_FOR_BASE_P (@var{num}, @var{mode}, @var{outer_code}, @var{index_code})
 A C expression that is just like @code{REGNO_MODE_OK_FOR_BASE_P}, except
 that that expression may examine the context in which the register
 address, @code{ADDRESS} for something that occurs in an
 @code{address_operand}).  @var{index_code} is the code of the
 corresponding index expression if @var{outer_code} is @code{PLUS};
 @code{SCRATCH} otherwise.  The mode may be @code{VOIDmode} for addresses
 that appear outside a @code{MEM}, i.e., as an @code{address_operand}.
+This macro also has strict and non-strict variants.
 @end defmac
 @defmac REGNO_OK_FOR_INDEX_P (@var{num})
 A C expression which is nonzero if register number @var{num} is
 suitable for use as an index register in operand addresses.  It 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.
+This macro also has strict and non-strict variants.
 @end defmac
 @defmac PREFERRED_RELOAD_CLASS (@var{x}, @var{class})
 A C expression that places additional restrictions on the register class
 to use when it is necessary to copy value @var{x} into a register in class
 Another kind of secondary reload is required on some machines which
 allow copying all registers to and from memory, but require a scratch
 register for stores to some memory locations (e.g., those with symbolic
 address on the RT, and those with certain symbolic address on the SPARC
 when compiling PIC)@.  Scratch registers need not have the same mode
-as the value being copied, and usually hold a different value that
+as the value being copied, and usually hold a different value than
 that being copied.  Special patterns in the md file are needed to
 describe how the copy is performed with the help of the scratch register;
 these patterns also describe the number, register class(es) and mode(s)
 of the scratch register(s).
 (@acronym{IRA}).  Cover classes are a set of non-intersecting register
 classes covering all hard registers used for register allocation
 purposes.  If a move between two registers in the same cover class is
 possible, it should be cheaper than a load or store of the registers.
 The array is terminated by a @code{LIM_REG_CLASSES} element.
+The order of cover classes in the array is important.  If two classes
+have the same cost of usage for a pseudo, the class occurred first in
+the array is chosen for the pseudo.
 This hook is called once at compiler startup, after the command-line
 options have been processed. It is then re-examined by every call to
 @code{target_reinit}.
 @code{EXTRA_CONSTRAINT} as representing a memory address of this type.
 If the letter @samp{Q} is marked as @code{EXTRA_MEMORY_CONSTRAINT},
 a @samp{Q} constraint can handle any memory operand, because the
 reload pass knows it can be reloaded by copying the memory address
 into a base register if required.  This is analogous to the way
-a @samp{o} constraint can handle any memory operand.
+an @samp{o} constraint can handle any memory operand.
 @end defmac
 @defmac EXTRA_ADDRESS_CONSTRAINT (@var{c}, @var{str})
 A C expression that defines the optional machine-dependent constraint
 letters, amongst those accepted by @code{EXTRA_CONSTRAINT} /
 from the argument pointer to the canonical frame address (cfa).  The
 final value should coincide with that calculated by
 @code{INCOMING_FRAME_SP_OFFSET}.  Which is unfortunately not usable
 during virtual register instantiation.
-The default value for this macro is @code{FIRST_PARM_OFFSET (fundecl)},
+The default value for this macro is
+@code{FIRST_PARM_OFFSET (fundecl) + crtl->args.pretend_args_size},
 which is correct for most machines; in general, the arguments are found
 immediately before the stack frame.  Note that this is not the case on
 some targets that save registers into the caller's frame, such as SPARC
 and rs6000, and so such targets need to define this macro.
 dynamically if their size exceeds @code{STACK_CHECK_MAX_VAR_SIZE} bytes.
 @defmac 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 do stack
+is required by the ABI of your machine or if you would like to do stack
 checking in some more efficient way than the generic approach.  The default
 value of this macro is zero.
 @end defmac
 @defmac STACK_CHECK_STATIC_BUILTIN
 in a machine-dependent manner.  You should define this macro if you would
 like to do static stack checking in some more efficient way than the generic
 approach.  The default value of this macro is zero.
 @end defmac
-@defmac STACK_CHECK_PROBE_INTERVAL
+@defmac STACK_CHECK_PROBE_INTERVAL_EXP
-An integer representing the interval at which GCC must generate stack
+An integer specifying the interval at which GCC must generate stack probe
-probe instructions.  You will normally define this macro to be no larger
+instructions, defined as 2 raised to this integer.  You will normally
-than the size of the ``guard pages'' at the end of a stack area.  The
+define this macro so that the interval be no larger than the size of
-default value of 4096 is suitable for most systems.
+the ``guard pages'' at the end of a stack area.  The default value
-@end defmac
+of 12 (4096-byte interval) is suitable for most systems.
+@end defmac
-@defmac STACK_CHECK_PROBE_LOAD
-An integer which is nonzero if GCC should perform the stack probe
+@defmac STACK_CHECK_MOVING_SP
-as a load instruction and zero if GCC should use a store instruction.
+An integer which is nonzero if GCC should move the stack pointer page by page
-The default is zero, which is the most efficient choice on most systems.
+when doing probes.  This can be necessary on systems where the stack pointer
+contains the bottom address of the memory area accessible to the executing
+thread at any point in time.  In this situation an alternate signal stack
+is required in order to be able to recover from a stack overflow.  The
+default value of this macro is zero.
 @end defmac
 @defmac STACK_CHECK_PROTECT
-The number of bytes of stack needed to recover from a stack overflow,
+The number of bytes of stack needed to recover from a stack overflow, for
-for languages where such a recovery is supported.  The default value of
+languages where such a recovery is supported.  The default value of 75 words
-75 words should be adequate for most machines.
+with the @code{setjmp}/@code{longjmp}-based exception handling mechanism and
+8192 bytes with other exception handling mechanisms should be adequate for
+most machines.
 @end defmac
 The following macros are relevant only if neither STACK_CHECK_BUILTIN
 nor STACK_CHECK_STATIC_BUILTIN is defined; you can omit them altogether
 in the opposite case.
 not be defined.
 The static chain register need not be a fixed register.
 If the static chain is passed in memory, these macros should not be
-defined; instead, the next two macros should be defined.
+defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used.
 @end defmac
-@defmac STATIC_CHAIN
+@deftypefn {Target Hook} rtx TARGET_STATIC_CHAIN (const_tree @var{fndecl}, bool @var{incoming_p})
-@defmacx STATIC_CHAIN_INCOMING
+This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for
-If the static chain is passed in memory, these macros provide rtx giving
+targets that may use different static chain locations for different
-@code{mem} expressions that denote where they are stored.
+nested functions.  This may be required if the target has function
-@code{STATIC_CHAIN} and @code{STATIC_CHAIN_INCOMING} give the locations
+attributes that affect the calling conventions of the function and
-as seen by the calling and called functions, respectively.  Often the former
+those calling conventions use different static chain locations.
-will be at an offset from the stack pointer and the latter at an offset from
-the frame pointer.
+The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.
+If the static chain is passed in memory, this hook should be used to
+provide rtx giving @code{mem} expressions that denote where they are stored.
+Often the @code{mem} expression as seen by the caller will be at an offset
+from the stack pointer and the @code{mem} expression as seen by the callee
+will be at an offset from the frame pointer.
 @findex stack_pointer_rtx
 @findex frame_pointer_rtx
 @findex arg_pointer_rtx
 The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and
-@code{arg_pointer_rtx} will have been initialized prior to the use of these
+@code{arg_pointer_rtx} will have been initialized and should be used
-macros and should be used to refer to those items.
+to refer to those items.
+@end deftypefn
-If the static chain is passed in a register, the two previous macros should
-be defined instead.
-@end defmac
 @defmac DWARF_FRAME_REGISTERS
 This macro specifies the maximum number of hard registers that can be
 saved in a call frame.  This is used to size data structures used in
 DWARF2 exception handling.
 @subsection Eliminating Frame Pointer and Arg Pointer
 @c prevent bad page break with this line
 This is about eliminating the frame pointer and arg pointer.
-@defmac FRAME_POINTER_REQUIRED
+@deftypefn {Target Hook} bool TARGET_FRAME_POINTER_REQUIRED (void)
-A C expression which is nonzero if a function must have and use a frame
+This target hook should return @code{true} if a function must have and use
-pointer.  This expression is evaluated  in the reload pass.  If its value is
+a frame pointer.  This target hook is called in the reload pass.  If its return
-nonzero the function will have a frame pointer.
+value is @code{true} the function will have a frame pointer.
-The expression can in principle examine the current function and decide
+This target hook can in principle examine the current function and decide
-according to the facts, but on most machines the constant 0 or the
+according to the facts, but on most machines the constant @code{false} or the
-constant 1 suffices.  Use 0 when the machine allows code to be generated
+constant @code{true} suffices.  Use @code{false} when the machine allows code
-with no frame pointer, and doing so saves some time or space.  Use 1
+to be generated with no frame pointer, and doing so saves some time or space.
-when there is no possible advantage to avoiding a frame pointer.
+Use @code{true} when there is no possible advantage to avoiding a frame
+pointer.
 In certain cases, the compiler does not know how to produce valid code
 without a frame pointer.  The compiler recognizes those cases and
 automatically gives the function a frame pointer regardless of what
-@code{FRAME_POINTER_REQUIRED} says.  You don't need to worry about
+@code{TARGET_FRAME_POINTER_REQUIRED} returns.  You don't need to worry about
 them.
 In a function that does not require a frame pointer, the frame pointer
 register can be allocated for ordinary usage, unless you mark it as a
 fixed register.  See @code{FIXED_REGISTERS} for more information.
-@end defmac
+Default return value is @code{false}.
+@end deftypefn
 @findex get_frame_size
 @defmac INITIAL_FRAME_POINTER_OFFSET (@var{depth-var})
 A C statement to store in the variable @var{depth-var} the difference
 between the frame pointer and the stack pointer values immediately after
 such as the result of @code{get_frame_size ()} and the tables of
 registers @code{regs_ever_live} and @code{call_used_regs}.
 If @code{ELIMINABLE_REGS} is defined, this macro will be not be used and
 need not be defined.  Otherwise, it must be defined even if
-@code{FRAME_POINTER_REQUIRED} is defined to always be true; in that
+@code{TARGET_FRAME_POINTER_REQUIRED} always returns true; in that
 case, you may set @var{depth-var} to anything.
 @end defmac
 @defmac ELIMINABLE_REGS
 If defined, this macro specifies a table of register pairs used to
 Note that the elimination of the argument pointer with the stack pointer is
 specified first since that is the preferred elimination.
 @end defmac
-@defmac CAN_ELIMINATE (@var{from-reg}, @var{to-reg})
+@deftypefn {Target Hook} bool TARGET_CAN_ELIMINATE (const int @var{from-reg}, const int @var{to-reg})
-A C expression that returns nonzero if the compiler is allowed to try
+This target hook should returns @code{true} if the compiler is allowed to
-to replace register number @var{from-reg} with register number
+try to replace register number @var{from-reg} with register number
-@var{to-reg}.  This macro need only be defined if @code{ELIMINABLE_REGS}
+@var{to-reg}.  This target hook need only be defined if @code{ELIMINABLE_REGS}
-is defined, and will usually be the constant 1, since most of the cases
+is defined, and will usually be @code{true}, since most of the cases
 preventing register elimination are things that the compiler already
 knows about.
-@end defmac
+Default return value is @code{true}.
+@end deftypefn
 @defmac INITIAL_ELIMINATION_OFFSET (@var{from-reg}, @var{to-reg}, @var{offset-var})
 This macro is similar to @code{INITIAL_FRAME_POINTER_OFFSET}.  It
 specifies the initial difference between the specified pair of
 registers.  This macro must be defined if @code{ELIMINABLE_REGS} is
 This macro need not do anything if the argument in question was passed
 on the stack.  The compiler knows how to track the amount of stack space
 used for arguments without any special help.
 @end defmac
 @defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type})
 If defined, a C expression that is the number of bytes to add to the
 offset of the argument passed in memory.  This is needed for the SPU,
 which passes @code{char} and @code{short} arguments in the preferred
 slot that is in the middle of the quad word instead of starting at the
 @deftypefn {Target Hook} rtx TARGET_FUNCTION_VALUE (tree @var{ret_type}, tree @var{fn_decl_or_type}, bool @var{outgoing})
 Define this to return an RTX representing the place where a function
 returns or receives a value of data type @var{ret_type}, a tree node
-node representing a data type.  @var{fn_decl_or_type} is a tree node
+representing a data type.  @var{fn_decl_or_type} is a tree node
 representing @code{FUNCTION_DECL} or @code{FUNCTION_TYPE} of a
 function being called.  If @var{outgoing} is false, the hook should
 compute the register in which the caller will see the return value.
 Otherwise, the hook should return an RTX representing the place where
 a function returns a value.
 support routine, used to perform arithmetic, whose name is known
 specially by the compiler and was not mentioned in the C code being
 compiled.
 @end defmac
+@deftypefn {Target Hook} rtx TARGET_LIBCALL_VALUE (enum machine_mode
+@var{mode}, const_rtx @var{fun})
+Define this hook if the back-end needs to know the name of the libcall
+function in order to determine where the result should be returned.
+The mode of the result is given by @var{mode} and the name of the called
+library function is given by @var{fun}.  The hook should return an RTX
+representing the place where the library function result will be returned.
+If this hook is not defined, then LIBCALL_VALUE will be used.
+@end deftypefn
 @defmac FUNCTION_VALUE_REGNO_P (@var{regno})
 A C expression that is nonzero if @var{regno} is the number of a hard
 register in which the values of called function may come back.
 A register whose use for returning values is limited to serving as the
 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.
-@defmac TRAMPOLINE_TEMPLATE (@var{file})
+@deftypefn {Target Hook} void TARGET_ASM_TRAMPOLINE_TEMPLATE (FILE *@var{f})
-A C statement to output, on the stream @var{file}, assembler code for a
+This hook is called by @code{assemble_trampoline_template} to output,
-block of data that contains the constant parts of a trampoline.  This
+on the stream @var{f}, assembler code for a block of data that contains
-code should not include a label---the label is taken care of
+the constant parts of a trampoline.  This code should not include a
-automatically.
+label---the label is taken care of automatically.
-If you do not define this macro, it means no template is needed
+If you do not define this hook, it means no template is needed
-for the target.  Do not define this macro on systems where the block move
+for the target.  Do not define this hook on systems where the block move
 code to copy the trampoline into place would be larger than the code
 to generate it on the spot.
-@end defmac
+@end deftypefn
 @defmac TRAMPOLINE_SECTION
 Return the section into which the trampoline template is to be placed
 (@pxref{Sections}).  The default value is @code{readonly_data_section}.
 @end defmac
 @end defmac
 @defmac TRAMPOLINE_ALIGNMENT
 Alignment required for trampolines, in bits.
-If you don't define this macro, the value of @code{BIGGEST_ALIGNMENT}
+If you don't define this macro, the value of @code{FUNCTION_ALIGNMENT}
 is used for aligning trampolines.
 @end defmac
-@defmac INITIALIZE_TRAMPOLINE (@var{addr}, @var{fnaddr}, @var{static_chain})
+@deftypefn {Target Hook} void TARGET_TRAMPOLINE_INIT (rtx @var{m_tramp}, tree @var{fndecl}, rtx @var{static_chain})
-A C statement to initialize the variable parts of a trampoline.
+This hook is called to initialize a trampoline.
-@var{addr} is an RTX for the address of the trampoline; @var{fnaddr} is
+@var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl}
-an RTX for the address of the nested function; @var{static_chain} is an
+is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an
 RTX for the static chain value that should be passed to the function
 when it is called.
-@end defmac
+If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the
-@defmac TRAMPOLINE_ADJUST_ADDRESS (@var{addr})
+first thing this hook should do is emit a block move into @var{m_tramp}
-A C statement that should perform any machine-specific adjustment in
+from the memory block returned by @code{assemble_trampoline_template}.
-the address of the trampoline.  Its argument contains the address that
+Note that the block move need only cover the constant parts of the
-was passed to @code{INITIALIZE_TRAMPOLINE}.  In case the address to be
+trampoline.  If the target isolates the variable parts of the trampoline
-used for a function call should be different from the address in which
+to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied.
-the template was stored, the different address should be assigned to
-@var{addr}.  If this macro is not defined, @var{addr} will be used for
+If the target requires any other actions, such as flushing caches or
-function calls.
+enabling stack execution, these actions should be performed after
+initializing the trampoline proper.
-@cindex @code{TARGET_ASM_FUNCTION_EPILOGUE} and trampolines
+@end deftypefn
-@cindex @code{TARGET_ASM_FUNCTION_PROLOGUE} and trampolines
-If this macro is not defined, by default the trampoline is allocated as
+@deftypefn {Target Hook} rtx TARGET_TRAMPOLINE_ADJUST_ADDRESS (rtx @var{addr})
-a stack slot.  This default is right for most machines.  The exceptions
+This hook should perform any machine-specific adjustment in
-are machines where it is impossible to execute instructions in the stack
+the address of the trampoline.  Its argument contains the address of the
-area.  On such machines, you may have to implement a separate stack,
+memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}.  In case
-using this macro in conjunction with @code{TARGET_ASM_FUNCTION_PROLOGUE}
+the address to be used for a function call should be different from the
-and @code{TARGET_ASM_FUNCTION_EPILOGUE}.
+address at which the template was stored, the different address should
+be returned; otherwise @var{addr} should be returned unchanged.
-@var{fp} points to a data structure, a @code{struct function}, which
+If this hook is not defined, @var{addr} will be used for function calls.
-describes the compilation status of the immediate containing function of
+@end deftypefn
-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.
-@end defmac
 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.
 Define this macro if certain operations must be performed before executing
 code located on the stack.  The macro should expand to a series of C
 file-scope constructs (e.g.@: functions) and provide a unique entry point
 named @code{__enable_execute_stack}.  The target is responsible for
 emitting calls to the entry point in the code, for example from the
-@code{INITIALIZE_TRAMPOLINE} macro.
+@code{TARGET_TRAMPOLINE_INIT} hook.
 @end defmac
 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
 post-address side-effect generation involving a register displacement.
 @end defmac
 @defmac CONSTANT_ADDRESS_P (@var{x})
 A C expression that is 1 if the RTX @var{x} is a constant which
-is a valid address.  On most machines, this can be defined as
+is a valid address.  On most machines the default definition of
-@code{CONSTANT_P (@var{x})}, but a few machines are more restrictive
+@code{(CONSTANT_P (@var{x}) && GET_CODE (@var{x}) != CONST_DOUBLE)}
-in which constant addresses are supported.
+is acceptable, but a few machines are more restrictive as to which
+constant addresses are supported.
 @end defmac
 @defmac CONSTANT_P (@var{x})
 @code{CONSTANT_P}, which is defined by target-independent code,
 accepts integer-values expressions whose values are not explicitly
 @end defmac
 @defmac 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 @code{GO_IF_LEGITIMATE_ADDRESS} would ever
+the maximum number that @code{TARGET_LEGITIMATE_ADDRESS_P} would ever
 accept.
 @end defmac
-@defmac GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})
+@deftypefn {Target Hook} TARGET_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode}, rtx @var{x}, bool @var{strict})
-A C compound statement with a conditional @code{goto @var{label};}
+A function that returns whether @var{x} (an RTX) is a legitimate memory
-executed if @var{x} (an RTX) is a legitimate memory address on the
+address on the target machine for a memory operand of mode @var{mode}.
-target machine for a memory operand of mode @var{mode}.
+Legitimate addresses are defined in two variants: a strict variant and a
-It usually pays to define several simpler macros to serve as
+non-strict one.  The @code{strict} parameter chooses which variant is
-subroutines for this one.  Otherwise it may be too complicated to
+desired by the caller.
-understand.
+The strict variant is used in the reload pass.  It must be defined so
-This macro must exist in two variants: a strict variant and a
+that any pseudo-register that has not been allocated a hard register is
-non-strict one.  The strict variant is used in the reload pass.  It
+considered a memory reference.  This is because in contexts where some
-must be defined so that any pseudo-register that has not been
+kind of register is required, a pseudo-register with no hard register
-allocated a hard register is considered a memory reference.  In
+must be rejected.  For non-hard registers, the strict variant should look
-contexts where some kind of register is required, a pseudo-register
+up the @code{reg_renumber} array; it should then proceed using the hard
-with no hard register must be rejected.
+register number in the array, or treat the pseudo as a memory reference
+if the array holds @code{-1}.
 The non-strict variant is used in other passes.  It must be defined to
 accept all pseudo-registers in every context where some kind of
 register is required.
-@findex REG_OK_STRICT
-Compiler source files that want to use the strict variant of this
-macro define the macro @code{REG_OK_STRICT}.  You should use an
-@code{#ifdef REG_OK_STRICT} conditional to define the strict variant
-in that case and the non-strict variant otherwise.
-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 @code{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 @code{symbol_ref}
 and an integer are stored inside a @code{const} RTX to mark them as
 constant.  Therefore, there is no need to recognize such sums
 specifically as legitimate addresses.  Normally you would simply
 target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information
 into the @code{symbol_ref}, and then check for it here.  When you see a
 @code{const}, you will have to look inside it to find the
 @code{symbol_ref} in order to determine the section.  @xref{Assembler
 Format}.
-@end defmac
+@cindex @code{GO_IF_LEGITIMATE_ADDRESS}
+Some ports are still using a deprecated legacy substitute for
+this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro.  This macro
+has this syntax:
+@example
+#define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})
+@end example
+@noindent
+and should @code{goto @var{label}} if the address @var{x} is a valid
+address on the target machine for a memory operand of mode @var{mode}.
+Whether the strict or non-strict variants are desired is defined by
+the @code{REG_OK_STRICT} macro introduced earlier in this section.
+Using the hook is usually simpler because it limits the number of
+files that are recompiled when changes are made.
+@end deftypefn
 @defmac TARGET_MEM_CONSTRAINT
 A single character to be used instead of the default @code{'m'}
 character for general memory addresses.  This defines the constraint
 letter which matches the memory addresses accepted by
-@code{GO_IF_LEGITIMATE_ADDRESS_P}.  Define this macro if you want to
+@code{TARGET_LEGITIMATE_ADDRESS_P}.  Define this macro if you want to
 support new address formats in your back end without changing the
 semantics of the @code{'m'} constraint.  This is necessary in order to
 preserve functionality of inline assembly constructs using the
 @code{'m'} constraint.
 @end defmac
 The typical use of this macro is to handle addresses containing
 a label_ref or symbol_ref within an UNSPEC@.
 @end defmac
-@defmac LEGITIMIZE_ADDRESS (@var{x}, @var{oldx}, @var{mode}, @var{win})
+@deftypefn {Target Hook} rtx TARGET_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode})
-A C compound statement that attempts to replace @var{x} with a valid
+This hook is given an invalid memory address @var{x} for an
-memory address for an operand of mode @var{mode}.  @var{win} will be a
+operand of mode @var{mode} and should try to return a valid memory
-C statement label elsewhere in the code; the macro definition may use
+address.
-@smallexample
-GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{win});
-@end smallexample
-@noindent
-to avoid further processing if the address has become legitimate.
 @findex break_out_memory_refs
 @var{x} will always be the result of a call to @code{break_out_memory_refs},
 and @var{oldx} will be the operand that was given to that function to produce
 @var{x}.
-The code generated by this macro should not alter the substructure of
+The code of the hook should not alter the substructure of
 @var{x}.  If it transforms @var{x} into a more legitimate form, it
-should assign @var{x} (which will always be a C variable) a new value.
+should return the new @var{x}.
-It is not necessary for this macro to come up with a legitimate
+It is not necessary for this hook to come up with a legitimate address.
-address.  The compiler has standard ways of doing so in all cases.  In
+The compiler has standard ways of doing so in all cases.  In fact, it
-fact, it is safe to omit this macro.  But often a
+is safe to omit this hook or make it return @var{x} if it cannot find
-machine-dependent strategy can generate better code.
+a valid way to legitimize the address.  But often a machine-dependent
-@end defmac
+strategy can generate better code.
+@end deftypefn
 @defmac LEGITIMIZE_RELOAD_ADDRESS (@var{x}, @var{mode}, @var{opnum}, @var{type}, @var{ind_levels}, @var{win})
 A C compound statement that attempts to replace @var{x}, which is an address
 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.
 @code{REALIGN_LOAD}. Therefore, the mask @var{m} returned by @var{f}
 should comply with the semantics expected by @code{REALIGN_LOAD}
 described above.
 If this hook is not defined, then @var{addr} will be used as
 the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low
-log2(@var{VS})-1 bits of @var{addr} will be considered.
+log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered.
 @end deftypefn
 @deftypefn {Target Hook} tree TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN (tree @var{x})
 This hook should return the DECL of a function @var{f} that implements
 widening multiplication of the even elements of two input vectors of type @var{x}.
 @code{NULL_TREE} if such a function is not available.  The return type of
 the vectorized function shall be of vector type @var{vec_type_out} and the
 argument types should be @var{vec_type_in}.
 @end deftypefn
+@deftypefn {Target Hook} bool TARGET_SUPPORT_VECTOR_MISALIGNMENT (enum machine_mode @var{mode}, tree @var{type}, int @var{misalignment}, bool @var{is_packed})
+This hook should return true if the target supports misaligned vector
+store/load of a specific factor denoted in the @var{misalignment}
+parameter.  The vector store/load should be of machine mode @var{mode} and
+the elements in the vectors should be of type @var{type}.  @var{is_packed}
+parameter is true if the memory access is defined in a packed struct.
+@end deftypefn
 @node Anchored Addresses
 @section Anchored Addresses
 @cindex anchored addresses
 @cindex @option{-fsection-anchors}
 The hooks below describe the target properties that GCC needs to know
 in order to make effective use of section anchors.  It won't use
 section anchors at all unless either @code{TARGET_MIN_ANCHOR_OFFSET}
 or @code{TARGET_MAX_ANCHOR_OFFSET} is set to a nonzero value.
-@deftypevar {Target Hook} HOST_WIDE_INT TARGET_MIN_ANCHOR_OFFSET
+@deftypevr {Target Hook} HOST_WIDE_INT TARGET_MIN_ANCHOR_OFFSET
 The minimum offset that should be applied to a section anchor.
 On most targets, it should be the smallest offset that can be
 applied to a base register while still giving a legitimate address
 for every mode.  The default value is 0.
-@end deftypevar
+@end deftypevr
-@deftypevar {Target Hook} HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET
+@deftypevr {Target Hook} HOST_WIDE_INT TARGET_MAX_ANCHOR_OFFSET
 Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive)
 offset that should be applied to section anchors.  The default
 value is 0.
-@end deftypevar
+@end deftypevr
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_ANCHOR (rtx @var{x})
 Write the assembly code to define section anchor @var{x}, which is a
 @code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true.
 The hook is called with the assembly output position set to the beginning
 @node Condition Code
 @section Condition Code Status
 @cindex condition code status
-@c prevent bad page break with this line
+The macros in this section can be split in two families, according to the
-This describes the condition code status.
+two ways of representing condition codes in GCC.
+The first representation is the so called @code{(cc0)} representation
+(@pxref{Jump Patterns}), where all instructions can have an implicit
+clobber of the condition codes.  The second is the condition code
+register representation, which provides better schedulability for
+architectures that do have a condition code register, but on which
+most instructions do not affect it.  The latter category includes
+most RISC machines.
+The implicit clobbering poses a strong restriction on the placement of
+the definition and use of the condition code, which need to be in adjacent
+insns for machines using @code{(cc0)}.  This can prevent important
+optimizations on some machines.  For example, on the IBM RS/6000, there
+is a delay for taken branches unless the condition code register is set
+three instructions earlier than the conditional branch.  The instruction
+scheduler cannot perform this optimization if it is not permitted to
+separate the definition and use of the condition code register.
+For this reason, it is possible and suggested to use a register to
+represent the condition code for new ports.  If there is a specific
+condition code register in the machine, use a hard register.  If the
+condition code or comparison result can be placed in any general register,
+or if there are multiple condition registers, use a pseudo register.
+Registers used to store the condition code value will usually have a mode
+that is in class @code{MODE_CC}.
+Alternatively, you can use @code{BImode} if the comparison operator is
+specified already in the compare instruction.  In this case, you are not
+interested in most macros in this section.
+@menu
+* CC0 Condition Codes::      Old style representation of condition codes.
+* MODE_CC Condition Codes::  Modern representation of condition codes.
+* Cond. Exec. Macros::       Macros to control conditional execution.
+@end menu
+@node CC0 Condition Codes
+@subsection Representation of condition codes using @code{(cc0)}
+@findex cc0
 @findex cc_status
 The file @file{conditions.h} defines a variable @code{cc_status} to
 describe how the condition code was computed (in case the interpretation of
 the condition code depends on the instruction that it was set by).  This
 that looks at an attribute (@pxref{Insn Attributes}) named, for example,
 @samp{cc}.  This avoids having detailed information about patterns in
 two places, the @file{md} file and in @code{NOTICE_UPDATE_CC}.
 @end defmac
+@node MODE_CC Condition Codes
+@subsection Representation of condition codes using registers
+@findex CCmode
+@findex MODE_CC
 @defmac SELECT_CC_MODE (@var{op}, @var{x}, @var{y})
-Returns a mode from class @code{MODE_CC} to be used when comparison
+On many machines, the condition code may be produced by other instructions
-operation code @var{op} is applied to rtx @var{x} and @var{y}.  For
+than compares, for example the branch can use directly the condition
-example, on the SPARC, @code{SELECT_CC_MODE} is defined as (see
+code set by a subtract instruction.  However, on some machines
-@pxref{Jump Patterns} for a description of the reason for this
+when the condition code is set this way some bits (such as the overflow
-definition)
+bit) are not set in the same way as a test instruction, so that a different
+branch instruction must be used for some conditional branches.  When
+this happens, use the machine mode of the condition code register to
+record different formats of the condition code register.  Modes can
+also be used to record which compare instruction (e.g. a signed or an
+unsigned comparison) produced the condition codes.
+If other modes than @code{CCmode} are required, add them to
+@file{@var{machine}-modes.def} and define @code{SELECT_CC_MODE} to choose
+a mode given an operand of a compare.  This is needed because the modes
+have to be chosen not only during RTL generation but also, for example,
+by instruction combination.  The result of @code{SELECT_CC_MODE} should
+be consistent with the mode used in the patterns; for example to support
+the case of the add on the SPARC discussed above, we have the pattern
+@smallexample
+(define_insn ""
+[(set (reg:CC_NOOV 0)
+(compare:CC_NOOV
+(plus:SI (match_operand:SI 0 "register_operand" "%r")
+(match_operand:SI 1 "arith_operand" "rI"))
+(const_int 0)))]
+""
+"@dots{}")
+@end smallexample
+@noindent
+together with a @code{SELECT_CC_MODE} that returns @code{CC_NOOVmode}
+for comparisons whose argument is a @code{plus}:
 @smallexample
 #define SELECT_CC_MODE(OP,X,Y) \
 (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT          \
 ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode)    \
 : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS    \
 || GET_CODE (X) == NEG) \
 ? CC_NOOVmode : CCmode))
 @end smallexample
+Another reason to use modes is to retain information on which operands
+were used by the comparison; see @code{REVERSIBLE_CC_MODE} later in
+this section.
 You should define this macro if and only if you define extra CC modes
 in @file{@var{machine}-modes.def}.
 @end defmac
 @defmac CANONICALIZE_COMPARISON (@var{code}, @var{op0}, @var{op1})
 @smallexample
 #define REVERSE_CONDITION(CODE, MODE) \
 ((MODE) != CCFPmode ? reverse_condition (CODE) \
 : reverse_condition_maybe_unordered (CODE))
-@end smallexample
-@end defmac
-@defmac REVERSE_CONDEXEC_PREDICATES_P (@var{op1}, @var{op2})
-A C expression that returns true if the conditional execution predicate
-@var{op1}, a comparison operation, is the inverse of @var{op2} and vice
-versa.  Define this to return 0 if the target has conditional execution
-predicates that cannot be reversed safely.  There is no need to validate
-that the arguments of op1 and op2 are the same, this is done separately.
-If no expansion is specified, this macro is defined as follows:
-@smallexample
-#define REVERSE_CONDEXEC_PREDICATES_P (x, y) \
-(GET_CODE ((x)) == reversed_comparison_code ((y), NULL))
 @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
 The default version of this hook checks whether the modes are the
 same.  If they are, it returns that mode.  If they are different, it
 returns @code{VOIDmode}.
 @end deftypefn
+@node Cond. Exec. Macros
+@subsection Macros to control conditional execution
+@findex conditional execution
+@findex predication
+There is one macro that may need to be defined for targets
+supporting conditional execution, independent of how they
+represent conditional branches.
+@defmac REVERSE_CONDEXEC_PREDICATES_P (@var{op1}, @var{op2})
+A C expression that returns true if the conditional execution predicate
+@var{op1}, a comparison operation, is the inverse of @var{op2} and vice
+versa.  Define this to return 0 if the target has conditional execution
+predicates that cannot be reversed safely.  There is no need to validate
+that the arguments of op1 and op2 are the same, this is done separately.
+If no expansion is specified, this macro is defined as follows:
+@smallexample
+#define REVERSE_CONDEXEC_PREDICATES_P (x, y) \
+(GET_CODE ((x)) == reversed_comparison_code ((y), NULL))
+@end smallexample
+@end defmac
 @node Costs
 @section Describing Relative Costs of Operations
 @cindex costs of instructions
 @cindex relative costs
 @cindex speed of instructions
 If the value of this macro is always zero, it need not be defined.  If
 this macro is defined, it should produce a nonzero value when
 @code{STRICT_ALIGNMENT} is nonzero.
 @end defmac
-@defmac MOVE_RATIO
+@defmac MOVE_RATIO (@var{speed})
 The threshold of number of scalar memory-to-memory move insns, @emph{below}
 which a sequence of insns should be generated instead of a
 string move insn or a library call.  Increasing the value will always
 make code faster, but eventually incurs high cost in increased code size.
 Note that on machines where the corresponding move insn is a
 @code{define_expand} that emits a sequence of insns, this macro counts
 the number of such sequences.
+The parameter @var{speed} is true if the code is currently being
+optimized for speed rather than size.
 If you don't define this, a reasonable default is used.
 @end defmac
 @defmac MOVE_BY_PIECES_P (@var{size}, @var{alignment})
 @defmac MOVE_MAX_PIECES
 A C expression used by @code{move_by_pieces} to determine the largest unit
 a load or store used to copy memory is.  Defaults to @code{MOVE_MAX}.
 @end defmac
-@defmac CLEAR_RATIO
+@defmac CLEAR_RATIO (@var{speed})
 The threshold of number of scalar move insns, @emph{below} which a sequence
 of insns should be generated to clear memory instead of a string clear insn
 or a library call.  Increasing the value will always make code faster, but
 eventually incurs high cost in increased code size.
+The parameter @var{speed} is true if the code is currently being
+optimized for speed rather than size.
 If you don't define this, a reasonable default is used.
 @end defmac
 @defmac CLEAR_BY_PIECES_P (@var{size}, @var{alignment})
 to clear a chunk of memory, or whether some other block clear mechanism
 will be used.  Defaults to 1 if @code{move_by_pieces_ninsns} returns less
 than @code{CLEAR_RATIO}.
 @end defmac
-@defmac SET_RATIO
+@defmac SET_RATIO (@var{speed})
 The threshold of number of scalar move insns, @emph{below} which a sequence
 of insns should be generated to set memory to a constant value, instead of
 a block set insn or a library call.
 Increasing the value will always make code faster, but
 eventually incurs high cost in increased code size.
+The parameter @var{speed} is true if the code is currently being
+optimized for speed rather than size.
 If you don't define this, it defaults to the value of @code{MOVE_RATIO}.
 @end defmac
 @defmac SET_BY_PIECES_P (@var{size}, @var{alignment})
 than @code{SET_RATIO}.
 @end defmac
 @defmac STORE_BY_PIECES_P (@var{size}, @var{alignment})
 A C expression used to determine whether @code{store_by_pieces} will be
 used to set a chunk of memory to a constant string value, or whether some
 other mechanism will be used.  Used by @code{__builtin_strcpy} when
 called with a constant source string.
 Defaults to 1 if @code{move_by_pieces_ninsns} returns less
 than @code{MOVE_RATIO}.
 @end defmac
 Define this macro if a non-short-circuit operation produced by
 @samp{fold_range_test ()} is optimal.  This macro defaults to true if
 @code{BRANCH_COST} is greater than or equal to the value 2.
 @end defmac
-@deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, int @var{code}, int @var{outer_code}, int *@var{total})
+@deftypefn {Target Hook} bool TARGET_RTX_COSTS (rtx @var{x}, int @var{code}, int @var{outer_code}, int *@var{total}, bool @var{speed})
 This target hook describes the relative costs of RTL expressions.
 The cost may depend on the precise form of the expression, which is
 available for examination in @var{x}, and the rtx code of the expression
 in which it is contained, found in @var{outer_code}.  @var{code} is the
 for the cost of the expression.  The hook should modify this value as
 necessary.  Traditionally, the default costs are @code{COSTS_N_INSNS (5)}
 for multiplications, @code{COSTS_N_INSNS (7)} for division and modulus
 operations, and @code{COSTS_N_INSNS (1)} for all other operations.
-When optimizing for code size, i.e.@: when @code{optimize_size} is
+When optimizing for code size, i.e.@: when @code{speed} is
-nonzero, this target hook should be used to estimate the relative
+false, this target hook should be used to estimate the relative
 size cost of an expression, again relative to @code{COSTS_N_INSNS}.
 The hook returns true when all subexpressions of @var{x} have been
 processed, and false when @code{rtx_cost} should recurse.
 @end deftypefn
-@deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address})
+@deftypefn {Target Hook} int TARGET_ADDRESS_COST (rtx @var{address}, bool @var{speed})
 This hook computes the cost of an addressing mode that contains
 @var{address}.  If not defined, the cost is computed from
 the @var{address} expression and the @code{TARGET_RTX_COST} hook.
 For most CISC machines, the default cost is a good approximation of the
 debug output to.  @var{verbose} is the verbose level provided by
 @option{-fsched-verbose-@var{n}}.  @var{ready} is a pointer to the ready
 list of instructions that are ready to be scheduled.  @var{n_readyp} is
 a pointer to the number of elements in the ready list.  The scheduler
 reads the ready list in reverse order, starting with
-@var{ready}[@var{*n_readyp}-1] and going to @var{ready}[0].  @var{clock}
+@var{ready}[@var{*n_readyp} @minus{} 1] and going to @var{ready}[0].  @var{clock}
 is the timer tick of the scheduler.  You may modify the ready list and
 the number of ready insns.  The return value is the number of insns that
 can issue this cycle; normally this is just @code{issue_rate}.  See also
 @samp{TARGET_SCHED_REORDER2}.
 @end deftypefn
 This hook is called by the insn scheduler when @var{insn} has only
 speculative dependencies and therefore can be scheduled speculatively.
 The hook is used to check if the pattern of @var{insn} has a speculative
 version and, in case of successful check, to generate that speculative
 pattern.  The hook should return 1, if the instruction has a speculative form,
-or -1, if it doesn't.  @var{request} describes the type of requested
+or @minus{}1, if it doesn't.  @var{request} describes the type of requested
 speculation.  If the return value equals 1 then @var{new_pat} is assigned
 the generated speculative pattern.
 @end deftypefn
 @deftypefn {Target Hook} int TARGET_SCHED_NEEDS_BLOCK_P (rtx @var{insn})
 @deftypefn {Target Hook} bool TARGET_IN_SMALL_DATA_P (tree @var{exp})
 Returns true if @var{exp} should be placed into a ``small data'' section.
 The default version of this hook always returns false.
 @end deftypefn
-@deftypevar {Target Hook} bool TARGET_HAVE_SRODATA_SECTION
+@deftypevr {Target Hook} bool TARGET_HAVE_SRODATA_SECTION
 Contains the value true if the target places read-only
 ``small data'' into a separate section.  The default value is false.
-@end deftypevar
+@end deftypevr
 @deftypefn {Target Hook} bool TARGET_BINDS_LOCAL_P (tree @var{exp})
 Returns true if @var{exp} names an object for which name resolution
 rules must resolve to the current ``module'' (dynamic shared library
 or executable image).
 The default version of this hook implements the name resolution rules
 for ELF, which has a looser model of global name binding than other
 currently supported object file formats.
 @end deftypefn
-@deftypevar {Target Hook} bool TARGET_HAVE_TLS
+@deftypevr {Target Hook} bool TARGET_HAVE_TLS
 Contains the value true if the target supports thread-local storage.
 The default value is false.
-@end deftypevar
+@end deftypevr
 @node PIC
 @section Position Independent Code
 @cindex position independent code
 @cindex PIC
 This section describes macros that help implement generation of position
 independent code.  Simply defining these macros is not enough to
-generate valid PIC; you must also add support to the macros
+generate valid PIC; you must also add support to the hook
-@code{GO_IF_LEGITIMATE_ADDRESS} and @code{PRINT_OPERAND_ADDRESS}, as
+@code{TARGET_LEGITIMATE_ADDRESS_P} and to the macro
-well as @code{LEGITIMIZE_ADDRESS}.  You must modify the definition of
+@code{PRINT_OPERAND_ADDRESS}, as well as @code{LEGITIMIZE_ADDRESS}.  You
-@samp{movsi} to do something appropriate when the source operand
+must modify the definition of @samp{movsi} to do something appropriate
-contains a symbolic address.  You may also need to alter the handling of
+when the source operand contains a symbolic address.  You may also
-switch statements so that they use relative addresses.
+need to alter the handling of switch statements so that they use
-@c i rearranged the order of the macros above to try to force one of
+relative addresses.
+@c i rearranged the order of the macros above to try to force one of
 @c them to the next line, to eliminate an overfull hbox. --mew 10feb93
 @defmac PIC_OFFSET_TABLE_REGNUM
 The register number of the register used to address a table of static
 data addresses in memory.  In some cases this register is defined by a
 @defmac ASM_OUTPUT_COMMON (@var{stream}, @var{name}, @var{size}, @var{rounded})
 A C statement (sans semicolon) to output to the stdio stream
 @var{stream} the assembler definition of a common-label named
 @var{name} whose size is @var{size} bytes.  The variable @var{rounded}
-is the size rounded up to whatever alignment the caller wants.
+is the size rounded up to whatever alignment the caller wants.  It is
+possible that @var{size} may be zero, for instance if a struct with no
+other member than a zero-length array is defined.  In this case, the
+backend must output a symbol definition that allocates at least one
+byte, both so that the address of the resulting object does not compare
+equal to any other, and because some object formats cannot even express
+the concept of a zero-sized common symbol, as that is how they represent
+an ordinary undefined external.
 Use the expression @code{assemble_name (@var{stream}, @var{name})} to
 output the name itself; before and after that, output the additional
 assembler syntax for defining the name, and a newline.
 writing conditional output routines in those patterns.
 If this macro is not defined, it is equivalent to a null statement.
 @end defmac
+@deftypefn {Target Hook} void TARGET_ASM_FINAL_POSTSCAN_INSN (FILE *@var{FILE}, rtx @var{insn}, rtx *@var{opvec}, int @var{noperands})
+If defined, this target hook is a function which is executed just after the
+output of assembler code for @var{insn}, to change the mode of the assembler
+if necessary.
+Here the argument @var{opvec} is the vector containing the operands
+extracted from @var{insn}, and @var{noperands} is the number of
+elements of the vector which contain meaningful data for this insn.
+The contents of this vector are what was used to convert the insn
+template into assembler code, so you can change the assembler mode
+by checking the contents of the vector.
+@end deftypefn
 @defmac PRINT_OPERAND (@var{stream}, @var{x}, @var{code})
 A C compound statement to output to stdio stream @var{stream} the
 assembler syntax for an instruction operand @var{x}.  @var{x} is an
 RTL expression.
 @defmac TARGET_UNWIND_INFO
 Define this macro if your target has ABI specified unwind tables.  Usually
 these will be output by @code{TARGET_UNWIND_EMIT}.
 @end defmac
-@deftypevar {Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
+@deftypevr {Target Hook} bool TARGET_UNWIND_TABLES_DEFAULT
 This variable should be set to @code{true} if the target ABI requires unwinding
 tables even when exceptions are not used.
-@end deftypevar
+@end deftypevr
 @defmac MUST_USE_SJLJ_EXCEPTIONS
 This macro need only be defined if @code{DWARF2_UNWIND_INFO} is
 runtime-variable.  In that case, @file{except.h} cannot correctly
 determine the corresponding definition of @code{MUST_USE_SJLJ_EXCEPTIONS},
 alignment if @code{STACK_GROWS_DOWNWARD} is defined, and the positive
 minimum alignment otherwise.  @xref{SDB and DWARF}.  Only applicable if
 the target supports DWARF 2 frame unwind information.
 @end defmac
-@deftypevar {Target Hook} bool TARGET_TERMINATE_DW2_EH_FRAME_INFO
+@deftypevr {Target Hook} bool TARGET_TERMINATE_DW2_EH_FRAME_INFO
 Contains the value true if the target should add a zero word onto the
 end of a Dwarf-2 frame info section when used for exception handling.
 Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and
 true otherwise.
-@end deftypevar
+@end deftypevr
 @deftypefn {Target Hook} rtx TARGET_DWARF_REGISTER_SPAN (rtx @var{reg})
 Given a register, this hook should return a parallel of registers to
 represent where to find the register pieces.  Define this hook if the
 register and its mode are represented in Dwarf in non-contiguous
 @end defmac
 @defmac DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
 Define this macro @emph{instead of} defining
 @code{DBX_OUTPUT_MAIN_SOURCE_FILE_END}, if what needs to be output at
-the end of compilation is a @code{N_SO} stab with an empty string,
+the end of compilation is an @code{N_SO} stab with an empty string,
 whose value is the highest absolute text address in the file.
 @end defmac
 @need 2000
 @node SDB and DWARF
 @end defmac
 @defmac ASM_OUTPUT_DWARF_PCREL (@var{stream}, @var{size}, @var{label})
 A C statement to issue assembly directives that create a self-relative
 reference to the given @var{label}, using an integer of the given @var{size}.
+@end defmac
+@defmac ASM_OUTPUT_DWARF_TABLE_REF (@var{label})
+A C statement to issue assembly directives that create a reference to
+the DWARF table identifier @var{label} from the current section.  This
+is used on some systems to avoid garbage collecting a DWARF table which
+is referenced by a function.
 @end defmac
 @deftypefn {Target Hook} void TARGET_ASM_OUTPUT_DWARF_DTPREL (FILE *@var{FILE}, int @var{size}, rtx @var{x})
 If defined, this target hook is a function which outputs a DTP-relative
 reference to the given TLS symbol of the specified size.
 the list and @code{*@var{attr_ptr}} modified to point to the new
 attributes, or a copy of the list may be made if further changes are
 needed.
 @end deftypefn
-@deftypefn {Target Hook} bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (tree @var{fndecl})
+@deftypefn {Target Hook} bool TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P (const_tree @var{fndecl})
 @cindex inlining
 This target hook returns @code{true} if it is ok to inline @var{fndecl}
 into the current function, despite its having target-specific
 attributes, @code{false} otherwise.  By default, if a function has a
 target specific attribute attached to it, it will not be inlined.
 @var{type} is a C++ class (i.e., RECORD_TYPE or UNION_TYPE) that has just been
 defined.  Use this hook to make adjustments to the class (eg, tweak
 visibility or perform any other required target modifications).
 @end deftypefn
+@node Named Address Spaces
+@section Adding support for named address spaces
+@cindex named address spaces
+The draft technical report of the ISO/IEC JTC1 S22 WG14 N1275
+standards committee, @cite{Programming Languages - C - Extensions to
+support embedded processors}, specifies a syntax for embedded
+processors to specify alternate address spaces.  You can configure a
+GCC port to support section 5.1 of the draft report to add support for
+address spaces other than the default address space.  These address
+spaces are new keywords that are similar to the @code{volatile} and
+@code{const} type attributes.
+Pointers to named address spaces can a a different size than
+pointers to the generic address space.
+For example, the SPU port uses the @code{__ea} address space to refer
+to memory in the host processor, rather than memory local to the SPU
+processor.  Access to memory in the @code{__ea} address space involves
+issuing DMA operations to move data between the host processor and the
+local processor memory address space.  Pointers in the @code{__ea}
+address space are either 32 bits or 64 bits based on the
+@option{-mea32} or @option{-mea64} switches (native SPU pointers are
+always 32 bits).
+Internally, address spaces are represented as a small integer in the
+range 0 to 15 with address space 0 being reserved for the generic
+address space.
+@defmac TARGET_ADDR_SPACE_KEYWORDS
+A list of @code{ADDR_SPACE_KEYWORD} macros to define each named
+address keyword.  The @code{ADDR_SPACE_KEYWORD} macro takes two
+arguments, the keyword string and the number of the named address
+space.  For example, the SPU port uses the following to declare
+@code{__ea} as the keyword for named address space #1:
+@smallexample
+#define ADDR_SPACE_EA 1
+#define TARGET_ADDR_SPACE_KEYWORDS ADDR_SPACE_KEYWORD ("__ea", ADDR_SPACE_EA)
+@end smallexample
+@end defmac
+@deftypefn {Target Hook} {enum machine_mode} TARGET_ADDR_SPACE_POINTER_MODE (addr_space_t @var{address_space})
+Define this to return the machine mode to use for pointers to
+@var{address_space} if the target supports named address spaces.
+The default version of this hook returns @code{ptr_mode} for the
+generic address space only.
+@end deftypefn
+@deftypefn {Target Hook} {enum machine_mode} TARGET_ADDR_SPACE_ADDRESS_MODE (addr_space_t @var{address_space})
+Define this to return the machine mode to use for addresses in
+@var{address_space} if the target supports named address spaces.
+The default version of this hook returns @code{Pmode} for the
+generic address space only.
+@end deftypefn
+@deftypefn {Target Hook} bool TARGET_ADDR_SPACE_VALID_POINTER_MODE (enum machine_mode @var{mode}, addr_space_t @var{as})
+Define this to return nonzero if the port can handle pointers
+with machine mode @var{mode} to address space @var{as}.  This target
+hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,
+except that it includes explicit named address space support.  The default
+version of this hook returns true for the modes returned by either the
+@code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE}
+target hooks for the given address space.
+@end deftypefn
+@deftypefn {Target Hook} {bool} TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P (enum machine_mode @var{mode}, rtx @var{exp}, bool @var{strict}, addr_space_t @var{as})
+Define this to return true if @var{exp} is a valid address for mode
+@var{mode} in the named address space @var{as}.  The @var{strict}
+parameter says whether strict addressing is in effect after reload has
+finished.  This target hook is the same as the
+@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes
+explicit named address space support.
+@end deftypefn
+@deftypefn {Target Hook} {rtx} TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS (rtx @var{x}, rtx @var{oldx}, enum machine_mode @var{mode}, addr_space_t @var{as})
+Define this to modify an invalid address @var{x} to be a valid address
+with mode @var{mode} in the named address space @var{as}.  This target
+hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,
+except that it includes explicit named address space support.
+@end deftypefn
+@deftypefn {Target Hook} {bool} TARGET_ADDR_SPACE_SUBSET_P (addr_space_t @var{superset}, addr_space_t @var{subset})
+Define this to return whether the @var{subset} named address space is
+contained within the @var{superset} named address space.  Pointers to
+a named address space that is a subset of another named address space
+will be converted automatically without a cast if used together in
+arithmetic operations.  Pointers to a superset address space can be
+converted to pointers to a subset address space via explicit casts.
+@end deftypefn
+@deftypefn {Target Hook} {rtx} TARGET_ADDR_SPACE_CONVERT (rtx @var{op}, tree @var{from_type}, tree @var{to_type})
+Define this to convert the pointer expression represented by the RTL
+@var{op} with type @var{from_type} that points to a named address
+space to a new pointer expression with type @var{to_type} that points
+to a different named address space.  When this hook it called, it is
+guaranteed that one of the two address spaces is a subset of the other,
+as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.
+@end deftypefn
 @node Misc
 @section Miscellaneous Parameters
 @cindex parameters, miscellaneous
 @c prevent bad page break with this line
 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_VALUES_THRESHOLD
+@deftypefn {Target Hook} unsigned int TARGET_CASE_VALUES_THRESHOLD (void)
-Define this to be the smallest number of different values for which it
+This function return the smallest number of different values for which it
 is best to use a jump-table instead of a tree of conditional branches.
 The default is four for machines with a @code{casesi} instruction and
 five otherwise.  This is best for most machines.
-@end defmac
+@end deftypefn
 @defmac CASE_USE_BIT_TESTS
 Define this macro to be a C expression to indicate whether C switch
 statements may be implemented by a sequence of bit tests.  This is
 advantageous on processors that can efficiently implement left shift
 @code{lang_hooks.builtin_function}
 which is defined by the language front end.  You can use any type nodes set
 up by @code{build_common_tree_nodes} and @code{build_common_tree_nodes_2};
 only language front ends that use those two functions will call
 @samp{TARGET_INIT_BUILTINS}.
+@end deftypefn
+@deftypefn {Target Hook} tree TARGET_BUILTIN_FUNCTION (unsigned @var{code}, bool @var{initialize_p})
+Define this hook if you have any machine-specific built-in functions
+that need to be defined.  It should be a function that returns the
+builtin function declaration for the builtin function code @var{code}.
+If there is no such builtin and it cannot be initialized at this time
+if @var{initialize_p} is true the function should return @code{NULL_TREE}.
+If @var{code} is out of range the function should return
+@code{error_mark_node}.
 @end deftypefn
 @deftypefn {Target Hook} rtx TARGET_EXPAND_BUILTIN (tree @var{exp}, rtx @var{target}, rtx @var{subtarget}, enum machine_mode @var{mode}, int @var{ignore})
 Expand a call to a machine specific built-in function that was set up by
 true when @var{after_prologue_epilogue_gen} is false, you still are likely
 to have to make special provisions in @code{INITIAL_ELIMINATION_OFFSET}
 to reserve space for caller-saved target registers.
 @end deftypefn
+@deftypefn {Target Hook} bool TARGET_HAVE_CONDITIONAL_EXECUTION (void)
+This target hook returns true if the target supports conditional execution.
+This target hook is required only when the target has several different
+modes and they have different conditional execution capability, such as ARM.
+@end deftypefn
 @defmac POWI_MAX_MULTS
 If defined, this macro is interpreted as a signed integer C expression
 that specifies the maximum number of floating point multiplications
 that should be emitted when expanding exponentiation by an integer
 constant inline.  When this value is defined, exponentiation requiring
 @deftypefn {Target Hook} {const char *} TARGET_INVALID_BINARY_OP (int @var{op}, tree @var{type1}, tree @var{type2})
 If defined, this macro returns the diagnostic message when it is
 invalid to apply operation @var{op} to operands of types @var{type1}
 and @var{type2}, or @code{NULL} if validity should be determined by
 the front end.
+@end deftypefn
+@deftypefn {Target Hook} {const char *} TARGET_INVALID_PARAMETER_TYPE (tree @var{type})
+If defined, this macro returns the diagnostic message when it is
+invalid for functions to include parameters of type @var{type},
+or @code{NULL} if validity should be determined by
+the front end.  This is currently used only by the C and C++ front ends.
+@end deftypefn
+@deftypefn {Target Hook} {const char *} TARGET_INVALID_RETURN_TYPE (tree @var{type})
+If defined, this macro returns the diagnostic message when it is
+invalid for functions to have return type @var{type},
+or @code{NULL} if validity should be determined by
+the front end.  This is currently used only by the C and C++ front ends.
+@end deftypefn
+@deftypefn {Target Hook} {tree} TARGET_PROMOTED_TYPE (tree @var{type})
+If defined, this target hook returns the type to which values of
+@var{type} should be promoted when they appear in expressions,
+analogous to the integer promotions, or @code{NULL_TREE} to use the
+front end's normal promotion rules.  This hook is useful when there are
+target-specific types with special promotion rules.
+This is currently used only by the C and C++ front ends.
+@end deftypefn
+@deftypefn {Target Hook} {tree} TARGET_CONVERT_TO_TYPE (tree @var{type}, tree @var{expr})
+If defined, this hook returns the result of converting @var{expr} to
+@var{type}.  It should return the converted expression,
+or @code{NULL_TREE} to apply the front end's normal conversion rules.
+This hook is useful when there are target-specific types with special
+conversion rules.
+This is currently used only by the C and C++ front ends.
 @end deftypefn
 @defmac TARGET_USE_JCR_SECTION
 This macro determines whether to use the JCR section to register Java
 classes. By default, TARGET_USE_JCR_SECTION is defined to 1 if both
 @code{__attribute__((naked))}, there is no stack frame, and the compiler
 cannot safely move arguments from the registers in which they are passed
 to the stack.  Therefore, this hook should return true in general, but
 false for naked functions.  The default implementation always returns true.
 @end deftypefn
+@deftypevr {Target Hook} {unsigned HOST_WIDE_INT} TARGET_CONST_ANCHOR
+On some architectures it can take multiple instructions to synthesize
+a constant.  If there is another constant already in a register that
+is close enough in value then it is preferable that the new constant
+is computed from this register using immediate addition or
+subtraction.  We accomplish this through CSE.  Besides the value of
+the constant we also add a lower and an upper constant anchor to the
+available expressions.  These are then queried when encountering new
+constants.  The anchors are computed by rounding the constant up and
+down to a multiple of the value of @code{TARGET_CONST_ANCHOR}.
+@code{TARGET_CONST_ANCHOR} should be the maximum positive value
+accepted by immediate-add plus one.  We currently assume that the
+value of @code{TARGET_CONST_ANCHOR} is a power of 2.  For example, on
+MIPS, where add-immediate takes a 16-bit signed value,
+@code{TARGET_CONST_ANCHOR} is set to @samp{0x8000}.  The default value
+is zero, which disables this optimization.  @end deftypevr

Mercurial > hg > CbC > CbC_gcc

comparison gcc/doc/tm.texi @ 55:77e2b8dfacca gcc-4.4.5