--- gcc/gcc.info-24 2018/04/24 18:18:04 1.1 +++ gcc/gcc.info-24 2018/04/24 18:41:47 1.1.1.3 @@ -1,13 +1,13 @@ -This is Info file gcc.info, produced by Makeinfo-1.55 from the input -file gcc.texi. +This is Info file gcc.info, produced by Makeinfo version 1.67 from the +input file gcc.texi. This file documents the use and the internals of the GNU compiler. - Published by the Free Software Foundation 675 Massachusetts Avenue -Cambridge, MA 02139 USA + Published by the Free Software Foundation 59 Temple Place - Suite 330 +Boston, MA 02111-1307 USA - Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, -Inc. + Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software +Foundation, Inc. Permission is granted to make and distribute verbatim copies of this manual provided the copyright notice and this permission notice are @@ -30,1859 +30,823 @@ translations approved by the Free Softwa original English.  -File: gcc.info, Node: Index, Prev: Config, Up: Top +File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Debugging Info, Up: Target Macros -Index -***** +Cross Compilation and Floating Point +==================================== + + While all modern machines use 2's complement representation for +integers, there are a variety of representations for floating point +numbers. This means that in a cross-compiler the representation of +floating point numbers in the compiled program may be different from +that used in the machine doing the compilation. + + Because different representation systems may offer different amounts +of range and precision, the cross compiler cannot safely use the host +machine's floating point arithmetic. Therefore, floating point +constants must be represented in the target machine's format. This +means that the cross compiler cannot use `atof' to parse a floating +point constant; it must have its own special routine to use instead. +Also, constant folding must emulate the target machine's arithmetic (or +must not be done at all). + + The macros in the following table should be defined only if you are +cross compiling between different floating point formats. + + Otherwise, don't define them. Then default definitions will be set +up which use `double' as the data type, `==' to test for equality, etc. + + You don't need to worry about how many times you use an operand of +any of these macros. The compiler never uses operands which have side +effects. + +`REAL_VALUE_TYPE' + A macro for the C data type to be used to hold a floating point + value in the target machine's format. Typically this would be a + `struct' containing an array of `int'. + +`REAL_VALUES_EQUAL (X, Y)' + A macro for a C expression which compares for equality the two + values, X and Y, both of type `REAL_VALUE_TYPE'. + +`REAL_VALUES_LESS (X, Y)' + A macro for a C expression which tests whether X is less than Y, + both values being of type `REAL_VALUE_TYPE' and interpreted as + floating point numbers in the target machine's representation. + +`REAL_VALUE_LDEXP (X, SCALE)' + A macro for a C expression which performs the standard library + function `ldexp', but using the target machine's floating point + representation. Both X and the value of the expression have type + `REAL_VALUE_TYPE'. The second argument, SCALE, is an integer. + +`REAL_VALUE_FIX (X)' + A macro whose definition is a C expression to convert the + target-machine floating point value X to a signed integer. X has + type `REAL_VALUE_TYPE'. + +`REAL_VALUE_UNSIGNED_FIX (X)' + A macro whose definition is a C expression to convert the + target-machine floating point value X to an unsigned integer. X + has type `REAL_VALUE_TYPE'. + +`REAL_VALUE_RNDZINT (X)' + A macro whose definition is a C expression to round the + target-machine floating point value X towards zero to an integer + value (but still as a floating point number). X has type + `REAL_VALUE_TYPE', and so does the value. + +`REAL_VALUE_UNSIGNED_RNDZINT (X)' + A macro whose definition is a C expression to round the + target-machine floating point value X towards zero to an unsigned + integer value (but still represented as a floating point number). + X has type `REAL_VALUE_TYPE', and so does the value. + +`REAL_VALUE_ATOF (STRING, MODE)' + A macro for a C expression which converts STRING, an expression of + type `char *', into a floating point number in the target machine's + representation for mode MODE. The value has type + `REAL_VALUE_TYPE'. + +`REAL_INFINITY' + Define this macro if infinity is a possible floating point value, + and therefore division by 0 is legitimate. + +`REAL_VALUE_ISINF (X)' + A macro for a C expression which determines whether X, a floating + point value, is infinity. The value has type `int'. By default, + this is defined to call `isinf'. + +`REAL_VALUE_ISNAN (X)' + A macro for a C expression which determines whether X, a floating + point value, is a "nan" (not-a-number). The value has type `int'. + By default, this is defined to call `isnan'. + + Define the following additional macros if you want to make floating +point constant folding work while cross compiling. If you don't define +them, cross compilation is still possible, but constant folding will +not happen for floating point values. + +`REAL_ARITHMETIC (OUTPUT, CODE, X, Y)' + A macro for a C statement which calculates an arithmetic operation + of the two floating point values X and Y, both of type + `REAL_VALUE_TYPE' in the target machine's representation, to + produce a result of the same type and representation which is + stored in OUTPUT (which will be a variable). + + The operation to be performed is specified by CODE, a tree code + which will always be one of the following: `PLUS_EXPR', + `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'. + + The expansion of this macro is responsible for checking for + overflow. If overflow happens, the macro expansion should execute + the statement `return 0;', which indicates the inability to + perform the arithmetic operation requested. + +`REAL_VALUE_NEGATE (X)' + A macro for a C expression which returns the negative of the + floating point value X. Both X and the value of the expression + have type `REAL_VALUE_TYPE' and are in the target machine's + floating point representation. + + There is no way for this macro to report overflow, since overflow + can't happen in the negation operation. + +`REAL_VALUE_TRUNCATE (MODE, X)' + A macro for a C expression which converts the floating point value + X to mode MODE. + + Both X and the value of the expression are in the target machine's + floating point representation and have type `REAL_VALUE_TYPE'. + However, the value should have an appropriate bit pattern to be + output properly as a floating constant whose precision accords + with mode MODE. + + There is no way for this macro to report overflow. + +`REAL_VALUE_TO_INT (LOW, HIGH, X)' + A macro for a C expression which converts a floating point value X + into a double-precision integer which is then stored into LOW and + HIGH, two variables of type INT. + +`REAL_VALUE_FROM_INT (X, LOW, HIGH)' + A macro for a C expression which converts a double-precision + integer found in LOW and HIGH, two variables of type INT, into a + floating point value which is then stored into X. + + +File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros + +Miscellaneous Parameters +======================== + + Here are several miscellaneous parameters. + +`PREDICATE_CODES' + Define this if you have defined special-purpose predicates in the + file `MACHINE.c'. This macro is called within an initializer of an + array of structures. The first field in the structure is the name + of a predicate and the second field is an array of rtl codes. For + each predicate, list all rtl codes that can be in expressions + matched by the predicate. The list should have a trailing comma. + Here is an example of two entries in the list for a typical RISC + machine: + + #define PREDICATE_CODES \ + {"gen_reg_rtx_operand", {SUBREG, REG}}, \ + {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, + + Defining this macro does not affect the generated code (however, + incorrect definitions that omit an rtl code that may be matched by + the predicate can cause the compiler to malfunction). Instead, it + allows the table built by `genrecog' to be more compact and + efficient, thus speeding up the compiler. The most important + predicates to include in the list specified by this macro are + thoses used in the most insn patterns. + +`CASE_VECTOR_MODE' + An alias for a machine mode name. This is the machine mode that + elements of a jump-table should have. + +`CASE_VECTOR_PC_RELATIVE' + Define this macro if jump-tables should contain relative addresses. + +`CASE_DROPS_THROUGH' + Define this if control falls through a `case' insn when the index + value is out of range. This means the specified default-label is + actually ignored by the `case' insn proper. + +`CASE_VALUES_THRESHOLD' + Define this to be 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 + `casesi' instruction and five otherwise. This is best for most + machines. + +`WORD_REGISTER_OPERATIONS' + Define this macro if operations between registers with integral + mode smaller than a word are always performed on the entire + register. Most RISC machines have this property and most CISC + machines do not. + +`LOAD_EXTEND_OP (MODE)' + Define this macro to be a C expression indicating when insns that + read memory in MODE, an integral mode narrower than a word, set the + bits outside of MODE to be either the sign-extension or the + zero-extension of the data read. Return `SIGN_EXTEND' for values + of MODE for which the insn sign-extends, `ZERO_EXTEND' for which + it zero-extends, and `NIL' for other modes. + + This macro is not called with MODE non-integral or with a width + greater than or equal to `BITS_PER_WORD', so you may return any + value in this case. Do not define this macro if it would always + return `NIL'. On machines where this macro is defined, you will + normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'. + +`IMPLICIT_FIX_EXPR' + An alias for a tree code that should be used by default for + conversion of floating point values to fixed point. Normally, + `FIX_ROUND_EXPR' is used. + +`FIXUNS_TRUNC_LIKE_FIX_TRUNC' + Define this macro if the same instructions that convert a floating + point number to a signed fixed point number also convert validly + to an unsigned one. + +`EASY_DIV_EXPR' + An alias for a tree code that is the easiest kind of division to + compile code for in the general case. It may be `TRUNC_DIV_EXPR', + `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four + division operators differ in how they round the result to an + integer. `EASY_DIV_EXPR' is used when it is permissible to use + any of those kinds of division and the choice should be made on + the basis of efficiency. + +`MOVE_MAX' + The maximum number of bytes that a single instruction can move + quickly from memory to memory. + +`MAX_MOVE_MAX' + The maximum number of bytes that a single instruction can move + quickly from memory to memory. If this is undefined, the default + is `MOVE_MAX'. Otherwise, it is the constant value that is the + largest value that `MOVE_MAX' can have at run-time. + +`SHIFT_COUNT_TRUNCATED' + A C expression that is nonzero if on this machine the number of + bits actually used for the count of a shift operation is equal to + the number of bits needed to represent the size of the object + being shifted. When this macro is non-zero, the compiler will + assume that it is safe to omit a sign-extend, zero-extend, and + certain bitwise `and' instructions that truncates the count of a + shift operation. On machines that have instructions that act on + bitfields at variable positions, which may include `bit test' + instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables + deletion of truncations of the values that serve as arguments to + bitfield instructions. + + If both types of instructions truncate the count (for shifts) and + position (for bitfield operations), or if no variable-position + bitfield instructions exist, you should define this macro. + + However, on some machines, such as the 80386 and the 680x0, + truncation only applies to shift operations and not the (real or + pretended) bitfield operations. Define `SHIFT_COUNT_TRUNCATED' to + be zero on such machines. Instead, add patterns to the `md' file + that include the implied truncation of the shift instructions. + + You need not define this macro if it would always have the value + of zero. + +`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' + A C expression which is nonzero if on this machine it is safe to + "convert" an integer of INPREC bits to one of OUTPREC bits (where + OUTPREC is smaller than INPREC) by merely operating on it as if it + had only OUTPREC bits. + + On many machines, this expression can be 1. + + When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for + modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. + If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in + such cases may improve things. + +`STORE_FLAG_VALUE' + A C expression describing the value returned by a comparison + operator with an integral mode and stored by a store-flag + instruction (`sCOND') when the condition is true. This + description must apply to *all* the `sCOND' patterns and all the + comparison operators whose results have a `MODE_INT' mode. + + A value of 1 or -1 means that the instruction implementing the + comparison operator returns exactly 1 or -1 when the comparison is + true and 0 when the comparison is false. Otherwise, the value + indicates which bits of the result are guaranteed to be 1 when the + comparison is true. This value is interpreted in the mode of the + comparison operation, which is given by the mode of the first + operand in the `sCOND' pattern. Either the low bit or the sign + bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are + used by the compiler. + + If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will + generate code that depends only on the specified bits. It can also + replace comparison operators with equivalent operations if they + cause the required bits to be set, even if the remaining bits are + undefined. For example, on a machine whose comparison operators + return an `SImode' value and where `STORE_FLAG_VALUE' is defined as + `0x80000000', saying that just the sign bit is relevant, the + expression + + (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) + + can be converted to + + (ashift:SI X (const_int N)) + + where N is the appropriate shift count to move the bit being + tested into the sign bit. + + There is no way to describe a machine that always sets the + low-order bit for a true value, but does not guarantee the value + of any other bits, but we do not know of any machine that has such + an instruction. If you are trying to port GNU CC to such a + machine, include an instruction to perform a logical-and of the + result with 1 in the pattern for the comparison operators and let + us know (*note How to Report Bugs: Bug Reporting.). + + Often, a machine will have multiple instructions that obtain a + value from a comparison (or the condition codes). Here are rules + to guide the choice of value for `STORE_FLAG_VALUE', and hence the + instructions to be used: + + * Use the shortest sequence that yields a valid definition for + `STORE_FLAG_VALUE'. It is more efficient for the compiler to + "normalize" the value (convert it to, e.g., 1 or 0) than for + the comparison operators to do so because there may be + opportunities to combine the normalization with other + operations. + + * For equal-length sequences, use a value of 1 or -1, with -1 + being slightly preferred on machines with expensive jumps and + 1 preferred on other machines. + + * As a second choice, choose a value of `0x80000001' if + instructions exist that set both the sign and low-order bits + but do not define the others. + + * Otherwise, use a value of `0x80000000'. + + Many machines can produce both the value chosen for + `STORE_FLAG_VALUE' and its negation in the same number of + instructions. On those machines, you should also define a pattern + for those cases, e.g., one matching + + (set A (neg:M (ne:M B C))) + + Some machines can also perform `and' or `plus' operations on + condition code values with less instructions than the corresponding + `sCOND' insn followed by `and' or `plus'. On those machines, + define the appropriate patterns. Use the names `incscc' and + `decscc', respectively, for the the patterns which perform `plus' + or `minus' operations on condition code values. See `rs6000.md' + for some examples. The GNU Superoptizer can be used to find such + instruction sequences on other machines. + + You need not define `STORE_FLAG_VALUE' if the machine has no + store-flag instructions. + +`FLOAT_STORE_FLAG_VALUE' + A C expression that gives a non-zero floating point value that is + returned when comparison operators with floating-point results are + true. Define this macro on machine that have comparison + operations that return floating-point values. If there are no + such operations, do not define this macro. + +`Pmode' + An alias for the machine mode for pointers. On most machines, + define this to be the integer mode corresponding to the width of a + hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit + machines. On some machines you must define this to be one of the + partial integer modes, such as `PSImode'. + + The width of `Pmode' must be at least as large as the value of + `POINTER_SIZE'. If it is not equal, you must define the macro + `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to + `Pmode'. + +`FUNCTION_MODE' + An alias for the machine mode used for memory references to + functions being called, in `call' RTL expressions. On most + machines this should be `QImode'. + +`INTEGRATE_THRESHOLD (DECL)' + A C expression for the maximum number of instructions above which + the function DECL should not be inlined. DECL is a + `FUNCTION_DECL' node. + + The default definition of this macro is 64 plus 8 times the number + of arguments that the function accepts. Some people think a larger + threshold should be used on RISC machines. + +`SCCS_DIRECTIVE' + Define this if the preprocessor should ignore `#sccs' directives + and print no error message. + +`NO_IMPLICIT_EXTERN_C' + Define this macro if the system header files support C++ as well + as C. This macro inhibits the usual method of using system header + files in C++, which is to pretend that the file's contents are + enclosed in `extern "C" {...}'. + +`HANDLE_PRAGMA (STREAM)' + Define this macro if you want to implement any pragmas. If + defined, it should be a C statement to be executed when `#pragma' + is seen. The argument STREAM is the stdio input stream from which + the source text can be read. + + It is generally a bad idea to implement new uses of `#pragma'. The + only reason to define this macro is for compatibility with other + compilers that do support `#pragma' for the sake of any user + programs which already use it. + +`VALID_MACHINE_DECL_ATTRIBUTE (DECL, ATTRIBUTES, IDENTIFIER, ARGS)' + If defined, a C expression whose value is nonzero if IDENTIFIER + with arguments ARGS is a valid machine specific attribute for DECL. + The attributes in ATTRIBUTES have previously been assigned to DECL. + +`VALID_MACHINE_TYPE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER, ARGS)' + If defined, a C expression whose value is nonzero if IDENTIFIER + with arguments ARGS is a valid machine specific attribute for TYPE. + The attributes in ATTRIBUTES have previously been assigned to TYPE. + +`COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)' + If defined, a C expression whose value is zero if the attributes on + TYPE1 and TYPE2 are incompatible, one if they are compatible, and + two if they are nearly compatible (which causes a warning to be + generated). + +`SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)' + If defined, a C statement that assigns default attributes to newly + defined TYPE. + +`DOLLARS_IN_IDENTIFIERS' + Define this macro to control use of the character `$' in identifier + names. The value should be 0, 1, or 2. 0 means `$' is not allowed + by default; 1 means it is allowed by default if `-traditional' is + used; 2 means it is allowed by default provided `-ansi' is not + used. 1 is the default; there is no need to define this macro in + that case. + +`NO_DOLLAR_IN_LABEL' + Define this macro if the assembler does not accept the character + `$' in label names. By default constructors and destructors in + G++ have `$' in the identifiers. If this macro is defined, `.' is + used instead. + +`NO_DOT_IN_LABEL' + Define this macro if the assembler does not accept the character + `.' in label names. By default constructors and destructors in G++ + have names that use `.'. If this macro is defined, these names + are rewritten to avoid `.'. + +`DEFAULT_MAIN_RETURN' + Define this macro if the target system expects every program's + `main' function to return a standard "success" value by default + (if no other value is explicitly returned). + + The definition should be a C statement (sans semicolon) to + generate the appropriate rtl instructions. It is used only when + compiling the end of `main'. + +`HAVE_ATEXIT' + Define this if the target system supports the function `atexit' + from the ANSI C standard. If this is not defined, and + `INIT_SECTION_ASM_OP' is not defined, a default `exit' function + will be provided to support C++. + +`EXIT_BODY' + Define this if your `exit' function needs to do something besides + calling an external function `_cleanup' before terminating with + `_exit'. The `EXIT_BODY' macro is only needed if netiher + `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. + +`INSN_SETS_ARE_DELAYED (INSN)' + Define this macro as a C expression that is nonzero if it is safe + for the delay slot scheduler to place instructions in the delay + slot of INSN, even if they appear to use a resource set or + clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU + CC knows that every `call_insn' has this behavior. On machines + where some `insn' or `jump_insn' is really a function call and + hence has this behavior, you should define this macro. + + You need not define this macro if it would always return zero. + +`INSN_REFERENCES_ARE_DELAYED (INSN)' + Define this macro as a C expression that is nonzero if it is safe + for the delay slot scheduler to place instructions in the delay + slot of INSN, even if they appear to set or clobber a resource + referenced in INSN. INSN is always a `jump_insn' or an `insn'. + On machines where some `insn' or `jump_insn' is really a function + call and its operands are registers whose use is actually in the + subroutine it calls, you should define this macro. Doing so + allows the delay slot scheduler to move instructions which copy + arguments into the argument registers into the delay slot of INSN. + + You need not define this macro if it would always return zero. + +`MACHINE_DEPENDENT_REORG (INSN)' + In rare cases, correct code generation requires extra machine + dependent processing between the second jump optimization pass and + delayed branch scheduling. On those machines, define this macro + as a C statement to act on the code starting at INSN. + + +File: gcc.info, Node: Config, Next: Fragments, Prev: Target Macros, Up: Top + +The Configuration File +********************** + + The configuration file `xm-MACHINE.h' contains macro definitions +that describe the machine and system on which the compiler is running, +unlike the definitions in `MACHINE.h', which describe the machine for +which the compiler is producing output. Most of the values in +`xm-MACHINE.h' are actually the same on all machines that GNU CC runs +on, so large parts of all configuration files are identical. But there +are some macros that vary: + +`USG' + Define this macro if the host system is System V. + +`VMS' + Define this macro if the host system is VMS. + +`FATAL_EXIT_CODE' + A C expression for the status code to be returned when the compiler + exits after serious errors. + +`SUCCESS_EXIT_CODE' + A C expression for the status code to be returned when the compiler + exits without serious errors. + +`HOST_WORDS_BIG_ENDIAN' + Defined if the host machine stores words of multi-word values in + big-endian order. (GNU CC does not depend on the host byte + ordering within a word.) + +`HOST_FLOAT_WORDS_BIG_ENDIAN' + Define this macro to be 1 if the host machine stores `DFmode', + `XFmode' or `TFmode' floating point numbers in memory with the + word containing the sign bit at the lowest address; otherwise, + define it to be zero. + + This macro need not be defined if the ordering is the same as for + multi-word integers. + +`HOST_FLOAT_FORMAT' + A numeric code distinguishing the floating point format for the + host machine. See `TARGET_FLOAT_FORMAT' in *Note Storage Layout:: + for the alternatives and default. + +`HOST_BITS_PER_CHAR' + A C expression for the number of bits in `char' on the host + machine. + +`HOST_BITS_PER_SHORT' + A C expression for the number of bits in `short' on the host + machine. + +`HOST_BITS_PER_INT' + A C expression for the number of bits in `int' on the host machine. + +`HOST_BITS_PER_LONG' + A C expression for the number of bits in `long' on the host + machine. + +`ONLY_INT_FIELDS' + Define this macro to indicate that the host compiler only supports + `int' bit fields, rather than other integral types, including + `enum', as do most C compilers. + +`OBSTACK_CHUNK_SIZE' + A C expression for the size of ordinary obstack chunks. If you + don't define this, a usually-reasonable default is used. + +`OBSTACK_CHUNK_ALLOC' + The function used to allocate obstack chunks. If you don't define + this, `xmalloc' is used. + +`OBSTACK_CHUNK_FREE' + The function used to free obstack chunks. If you don't define + this, `free' is used. + +`USE_C_ALLOCA' + Define this macro to indicate that the compiler is running with the + `alloca' implemented in C. This version of `alloca' can be found + in the file `alloca.c'; to use it, you must also alter the + `Makefile' variable `ALLOCA'. (This is done automatically for the + systems on which we know it is needed.) + + If you do define this macro, you should probably do it as follows: + + #ifndef __GNUC__ + #define USE_C_ALLOCA + #else + #define alloca __builtin_alloca + #endif + + so that when the compiler is compiled with GNU CC it uses the more + efficient built-in `alloca' function. + +`FUNCTION_CONVERSION_BUG' + Define this macro to indicate that the host compiler does not + properly handle converting a function value to a + pointer-to-function when it is used in an expression. + +`HAVE_VPRINTF' + Define this if the library function `vprintf' is available on your + system. + +`MULTIBYTE_CHARS' + Define this macro to enable support for multibyte characters in the + input to GNU CC. This requires that the host system support the + ANSI C library functions for converting multibyte characters to + wide characters. + +`HAVE_PUTENV' + Define this if the library function `putenv' is available on your + system. + +`POSIX' + Define this if your system is POSIX.1 compliant. + +`NO_SYS_SIGLIST' + Define this if your system *does not* provide the variable + `sys_siglist'. + +`DONT_DECLARE_SYS_SIGLIST' + Define this if your system has the variable `sys_siglist', and + there is already a declaration of it in the system header files. + +`USE_PROTOTYPES' + Define this to be 1 if you know that the host compiler supports + prototypes, even if it doesn't define __STDC__, or define it to be + 0 if you do not want any prototypes used in compiling GNU CC. If + `USE_PROTOTYPES' is not defined, it will be determined + automatically whether your compiler supports prototypes by + checking if `__STDC__' is defined. + +`NO_MD_PROTOTYPES' + Define this if you wish suppression of prototypes generated from + the machine description file, but to use other prototypes within + GNU CC. If `USE_PROTOTYPES' is defined to be 0, or the host + compiler does not support prototypes, this macro has no effect. + +`MD_CALL_PROTOTYPES' + Define this if you wish to generate prototypes for the `gen_call' + or `gen_call_value' functions generated from the machine + description file. If `USE_PROTOTYPES' is defined to be 0, or the + host compiler does not support prototypes, or `NO_MD_PROTOTYPES' + is defined, this macro has no effect. As soon as all of the + machine descriptions are modified to have the appropriate number + of arguments, this macro will be removed. + + Some systems do provide this variable, but with a different name + such as `_sys_siglist'. On these systems, you can define + `sys_siglist' as a macro which expands into the name actually + provided. + +`NO_STAB_H' + Define this if your system does not have the include file + `stab.h'. If `USG' is defined, `NO_STAB_H' is assumed. + +`PATH_SEPARATOR' + Define this macro to be a C character constant representing the + character used to separate components in paths. The default value + is. the colon character + +`DIR_SEPARATOR' + If your system uses some character other than slash to separate + directory names within a file specification, define this macro to + be a C character constant specifying that character. When GNU CC + displays file names, the character you specify will be used. GNU + CC will test for both slash and the character you specify when + parsing filenames. + +`OBJECT_SUFFIX' + Define this macro to be a C string representing the suffix for + object files on your machine. If you do not define this macro, + GNU CC will use `.o' as the suffix for object files. + +`EXECUTABLE_SUFFIX' + Define this macro to be a C string representing the suffix for + executable files on your machine. If you do not define this + macro, GNU CC will use the null string as the suffix for object + files. + +`COLLECT_EXPORT_LIST' + If defined, `collect2' will scan the individual object files + specified on its command line and create an export list for the + linker. Define this macro for systems like AIX, where the linker + discards object files that are not referenced from `main' and uses + export lists. + + In addition, configuration files for system V define `bcopy', +`bzero' and `bcmp' as aliases. Some files define `alloca' as a macro +when compiled with GNU CC, in order to take advantage of the benefit of +GNU CC's built-in `alloca'. + + +File: gcc.info, Node: Fragments, Next: Index, Prev: Config, Up: Top + +Makefile Fragments +****************** + + When you configure GNU CC using the `configure' script (*note +Installation::.), it will construct the file `Makefile' from the +template file `Makefile.in'. When it does this, it will incorporate +makefile fragment files from the `config' directory, named `t-TARGET' +and `x-HOST'. If these files do not exist, it means nothing needs to +be added for a given target or host. * Menu: -* #pragma: Misc. -* $: Dollar Signs. -* ': Incompatibilities. -* (nil): RTL Objects. -* ?: Min and Max. -* ?: side effect: Conditionals. -* #pragma implementation, implied: C++ Interface. -* #pragma, reason for not using: Function Attributes. -* # in template: Output Template. -* * in template: Output Statement. -* -lgcc, use with -nostdlib: Link Options. -* -nostdlib and unresolved references: Link Options. -* ?: extensions: Conditionals. -* ?: extensions: Lvalues. -* absM2 instruction pattern: Standard Names. -* abs and attributes: Expressions. -* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry. -* addM3 instruction pattern: Standard Names. -* addr_diff_vec, length of: Insn Lengths. -* addr_vec, length of: Insn Lengths. -* aligned attribute: Variable Attributes. -* allocate_stack instruction pattern: Standard Names. -* alloca and SunOs: Installation. -* alloca vs variable-length arrays: Variable Length. -* alloca, for SunOs: Sun Install. -* alloca, for Unos: Configurations. -* andM3 instruction pattern: Standard Names. -* and and attributes: Expressions. -* and, canonicalization of: Insn Canonicalizations. -* ARG_POINTER_REGNUM and virtual registers: Regs and Memory. -* ashiftrt and attributes: Expressions. -* ashift and attributes: Expressions. -* ashlM3 instruction pattern: Standard Names. -* ashrM3 instruction pattern: Standard Names. -* asm_operands, RTL sharing: Sharing. -* asm_operands, usage: Assembler. -* asm expressions: Extended Asm. -* bCOND instruction pattern: Standard Names. -* bcopy, implicit usage: Library Calls. -* BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields. -* BLKmode, and function return values: Calls. -* bzero, implicit usage: Library Calls. -* call_insn and /u: Flags. -* call_pop instruction pattern: Standard Names. -* call_value_pop instruction pattern: Standard Names. -* call_value instruction pattern: Standard Names. -* call instruction pattern: Standard Names. -* call usage: Calls. -* casesi instruction pattern: Standard Names. -* cc0, RTL sharing: Sharing. -* cmpM instruction pattern: Standard Names. -* cmpstrM instruction pattern: Standard Names. -* code_label and /i: Flags. -* compare, canonicalization of: Insn Canonicalizations. -* cond and attributes: Expressions. -* const_double, RTL sharing: Sharing. -* const_int and attribute tests: Expressions. -* const_int and attributes: Expressions. -* const_int, RTL sharing: Sharing. -* const_string and attributes: Expressions. -* const applied to function: Function Attributes. -* const function attribute: Function Attributes. -* define_insn example: Example. -* divM3 instruction pattern: Standard Names. -* divmodM4 instruction pattern: Standard Names. -* div and attributes: Expressions. -* EDOM, implicit usage: Library Calls. -* ENCODE_SECTION_INFO and address validation: Addressing Modes. -* ENCODE_SECTION_INFO usage: Instruction Output. -* eq and attributes: Expressions. -* errno, implicit usage: Library Calls. -* extendMN instruction pattern: Standard Names. -* extv instruction pattern: Standard Names. -* extzv instruction pattern: Standard Names. -* ffsM2 instruction pattern: Standard Names. -* FIRST_PARM_OFFSET and virtual registers: Regs and Memory. -* fixMN2 instruction pattern: Standard Names. -* fixunsMN2 instruction pattern: Standard Names. -* fixuns_truncMN2 instruction pattern: Standard Names. -* fix_truncMN2 instruction pattern: Standard Names. -* floatMN2 instruction pattern: Standard Names. -* floatunsMN2 instruction pattern: Standard Names. -* float as function value type: Incompatibilities. -* format function attribute: Function Attributes. -* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory. -* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory. -* fscanf, and constant strings: Incompatibilities. -* ftruncM2 instruction pattern: Standard Names. -* FUNCTION_EPILOGUE and trampolines: Trampolines. -* FUNCTION_PROLOGUE and trampolines: Trampolines. -* g++ 1.XX: Invoking G++. -* g++ older version: Invoking G++. -* g++, separate compiler: Invoking G++. -* genflags, crash on Sun 4: Installation Problems. -* geu and attributes: Expressions. -* ge and attributes: Expressions. -* goto in C++: Destructors and Goto. -* gprof: Debugging Options. -* gtu and attributes: Expressions. -* gt and attributes: Expressions. -* HImode, in insn: Insns. -* if_then_else and attributes: Expressions. -* if_then_else usage: Side Effects. -* indirect_jump instruction pattern: Standard Names. -* inline automatic for C++ member fns: Inline. -* insn and /i: Flags. -* insn and /s: Flags. -* insn and /u: Flags. -* insv instruction pattern: Standard Names. -* integrated, in insn: Flags. -* integrated, in reg: Flags. -* in_struct, in code_label: Flags. -* in_struct, in insn: Flags. -* in_struct, in insn: Flags. -* in_struct, in label_ref: Flags. -* in_struct, in mem: Flags. -* in_struct, in reg: Flags. -* in_struct, in subreg: Flags. -* iorM3 instruction pattern: Standard Names. -* ior and attributes: Expressions. -* ior, canonicalization of: Insn Canonicalizations. -* label_ref and /s: Flags. -* label_ref, RTL sharing: Sharing. -* leu and attributes: Expressions. -* le and attributes: Expressions. -* load_multiple instruction pattern: Standard Names. -* long long data types: Long Long. -* longjmp and automatic variables: Interface. -* longjmp and automatic variables: C Dialect Options. -* longjmp incompatibilities: Incompatibilities. -* longjmp warnings: Warning Options. -* lshiftrt and attributes: Expressions. -* lshrM3 instruction pattern: Standard Names. -* lt and attributes: Expressions. -* main and the exit status: VMS Misc. -* match_dup and attributes: Insn Lengths. -* match_operand and attributes: Expressions. -* maxM3 instruction pattern: Standard Names. -* memcpy, implicit usage: Library Calls. -* memset, implicit usage: Library Calls. -* mem and /s: Flags. -* mem and /u: Flags. -* mem and /v: Flags. -* mem, RTL sharing: Sharing. -* minM3 instruction pattern: Standard Names. -* minus and attributes: Expressions. -* minus, canonicalization of: Insn Canonicalizations. -* mktemp, and constant strings: Incompatibilities. -* modM3 instruction pattern: Standard Names. -* mode attribute: Variable Attributes. -* mod and attributes: Expressions. -* movM instruction pattern: Standard Names. -* movstrM instruction pattern: Standard Names. -* movstrictM instruction pattern: Standard Names. -* mulM3 instruction pattern: Standard Names. -* mulhisi3 instruction pattern: Standard Names. -* mulqihi3 instruction pattern: Standard Names. -* mulsidi3 instruction pattern: Standard Names. -* mult and attributes: Expressions. -* mult, canonicalization of: Insn Canonicalizations. -* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments. -* negM2 instruction pattern: Standard Names. -* neg and attributes: Expressions. -* neg, canonicalization of: Insn Canonicalizations. -* ne and attributes: Expressions. -* nop instruction pattern: Standard Names. -* noreturn function attribute: Function Attributes. -* not and attributes: Expressions. -* not, canonicalization of: Insn Canonicalizations. -* one_cmplM2 instruction pattern: Standard Names. -* packed attribute: Variable Attributes. -* pc and attributes: Insn Lengths. -* pc, RTL sharing: Sharing. -* plus and attributes: Expressions. -* plus, canonicalization of: Insn Canonicalizations. -* prof: Debugging Options. -* PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout. -* QImode, in insn: Insns. -* qsort, and global register variables: Global Reg Vars. -* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments. -* reg and /i: Flags. -* reg and /s: Flags. -* reg and /u: Flags. -* reg and /v: Flags. -* reg, RTL sharing: Sharing. -* reload_in instruction pattern: Standard Names. -* reload_out instruction pattern: Standard Names. -* restore_stack_block instruction pattern: Standard Names. -* restore_stack_function instruction pattern: Standard Names. -* restore_stack_nonlocal instruction pattern: Standard Names. -* return instruction pattern: Standard Names. -* return, in C++ function header: Naming Results. -* rotlM3 instruction pattern: Standard Names. -* rotrM3 instruction pattern: Standard Names. -* sCOND instruction pattern: Standard Names. -* save_stack_block instruction pattern: Standard Names. -* save_stack_function instruction pattern: Standard Names. -* save_stack_nonlocal instruction pattern: Standard Names. -* scanf, and constant strings: Incompatibilities. -* scratch, RTL sharing: Sharing. -* section function attribute: Function Attributes. -* section variable attribute: Variable Attributes. -* setjmp incompatibilities: Incompatibilities. -* signature in C++, advantages: C++ Signatures. -* sign_extract, canonicalization of: Insn Canonicalizations. -* sqrtM2 instruction pattern: Standard Names. -* sscanf, and constant strings: Incompatibilities. -* STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory. -* STACK_POINTER_OFFSET and virtual registers: Regs and Memory. -* STACK_POINTER_REGNUM and virtual registers: Regs and Memory. -* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory. -* strlenM instruction pattern: Standard Names. -* subM3 instruction pattern: Standard Names. -* subreg and /s: Flags. -* subreg and /u: Flags. -* subreg, in strict_low_part: RTL Declarations. -* subreg, special reload handling: Regs and Memory. -* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections. -* symbol_ref and /u: Flags. -* symbol_ref and /v: Flags. -* symbol_ref, RTL sharing: Sharing. -* tablejump instruction pattern: Standard Names. -* tcov: Debugging Options. -* truncMN instruction pattern: Standard Names. -* tstM instruction pattern: Standard Names. -* udivM3 instruction pattern: Standard Names. -* udivmodM4 instruction pattern: Standard Names. -* umaxM3 instruction pattern: Standard Names. -* uminM3 instruction pattern: Standard Names. -* umodM3 instruction pattern: Standard Names. -* umulhisi3 instruction pattern: Standard Names. -* umulqihi3 instruction pattern: Standard Names. -* umulsidi3 instruction pattern: Standard Names. -* unchanging, in call_insn: Flags. -* unchanging, in insn: Flags. -* unchanging, in reg and mem: Flags. -* unchanging, in subreg: Flags. -* unchanging, in symbol_ref: Flags. -* untyped_call instruction pattern: Standard Names. -* untyped_return instruction pattern: Standard Names. -* used, in symbol_ref: Flags. -* volatile applied to function: Function Attributes. -* volatil, in insn: Flags. -* volatil, in mem: Flags. -* volatil, in reg: Flags. -* volatil, in symbol_ref: Flags. -* WORDS_BIG_ENDIAN, effect on subreg: Regs and Memory. -* xorM3 instruction pattern: Standard Names. -* xor, canonicalization of: Insn Canonicalizations. -* zero_extendMN instruction pattern: Standard Names. -* zero_extract, canonicalization of: Insn Canonicalizations. -* libgcc.a: Library Calls. -* stdarg.h and register arguments: Register Arguments. -* stdarg.h and RT PC: RT Options. -* tm.h macros: Target Macros. -* varargs.h and RT PC: RT Options. -* VAXCRTL: VMS Misc. -* xm-MACHINE.h: Config. -* ! in constraint: Multi-Alternative. -* # in constraint: Modifiers. -* % in constraint: Modifiers. -* % in template: Output Template. -* & in constraint: Modifiers. -* * in constraint: Modifiers. -* + in constraint: Modifiers. -* /i in RTL dump: Flags. -* /s in RTL dump: Flags. -* /s in RTL dump: Flags. -* /u in RTL dump: Flags. -* /v in RTL dump: Flags. -* 0 in constraint: Simple Constraints. -* < in constraint: Simple Constraints. -* = in constraint: Modifiers. -* > in constraint: Simple Constraints. -* ? in constraint: Multi-Alternative. -* d in constraint: Simple Constraints. -* E in constraint: Simple Constraints. -* F in constraint: Simple Constraints. -* G in constraint: Simple Constraints. -* g in constraint: Simple Constraints. -* H in constraint: Simple Constraints. -* I in constraint: Simple Constraints. -* i in constraint: Simple Constraints. -* m in constraint: Simple Constraints. -* n in constraint: Simple Constraints. -* o in constraint: Simple Constraints. -* p in constraint: Simple Constraints. -* Q, in constraint: Simple Constraints. -* r in constraint: Simple Constraints. -* store_multiple instruction pattern: Standard Names. -* s in constraint: Simple Constraints. -* V in constraint: Simple Constraints. -* X in constraint: Simple Constraints. -* _ in variables in macros: Naming Types. -* abort: C Dialect Options. -* abort: Portability. -* abs: C Dialect Options. -* abs: Arithmetic. -* absolute value: Arithmetic. -* access to operands: Accessors. -* accessors: Accessors. -* ACCUMULATE_OUTGOING_ARGS: Stack Arguments. -* ADDITIONAL_REGISTER_NAMES: Instruction Output. -* address: RTL Template. -* address constraints: Simple Constraints. -* address of a label: Labels as Values. -* addressing modes: Addressing Modes. -* ADDRESS_COST: Costs. -* address_operand: Simple Constraints. -* addr_diff_vec: Side Effects. -* addr_vec: Side Effects. -* ADJUST_COST: Costs. -* ADJUST_INSN_LENGTH: Insn Lengths. -* aggregates as return values: Aggregate Return. -* alignment: Alignment. -* Alliant: Interoperation. -* alloca: C Dialect Options. -* ALLOCATE_TRAMPOLINE: Trampolines. -* ALL_REGS: Register Classes. -* alternate keywords: Alternate Keywords. -* AMD29K options: AMD29K Options. -* analysis, data flow: Passes. -* and: Arithmetic. -* ANSI support: C Dialect Options. -* apostrophes: Incompatibilities. -* APPLY_RESULT_SIZE: Scalar Return. -* ARGS_GROW_DOWNWARD: Frame Layout. -* argument passing: Interface. -* arguments in frame (88k): M88K Options. -* arguments in registers: Register Arguments. -* arguments on stack: Stack Arguments. -* ARG_POINTER_REGNUM: Frame Registers. -* arg_pointer_rtx: Frame Registers. -* arithmetic libraries: Interface. -* arithmetic shift: Arithmetic. -* arithmetic simplifications: Passes. -* arithmetic, in RTL: Arithmetic. -* ARM options: ARM Options. -* arrays of length zero: Zero Length. -* arrays of variable length: Variable Length. -* arrays, non-lvalue: Subscripting. -* ashift: Arithmetic. -* ashiftrt: Arithmetic. -* ASM_APP_OFF: File Framework. -* ASM_APP_ON: File Framework. -* ASM_BYTE_OP: Data Output. -* ASM_CLOSE_PAREN: Data Output. -* ASM_COMMENT_START: File Framework. -* ASM_DECLARE_FUNCTION_NAME: Label Output. -* ASM_DECLARE_FUNCTION_SIZE: Label Output. -* ASM_DECLARE_OBJECT_NAME: Label Output. -* ASM_FILE_END: File Framework. -* ASM_FILE_START: File Framework. -* ASM_FINAL_SPEC: Driver. -* ASM_FINISH_DECLARE_OBJECT: Label Output. -* ASM_FORMAT_PRIVATE_NAME: Label Output. -* asm_fprintf: Instruction Output. -* ASM_GENERATE_INTERNAL_LABEL: Label Output. -* ASM_GLOBALIZE_LABEL: Label Output. -* ASM_IDENTIFY_GCC: File Framework. -* asm_input: Side Effects. -* asm_noperands: Insns. -* ASM_NO_SKIP_IN_TEXT: Alignment Output. -* ASM_OPEN_PAREN: Data Output. -* ASM_OUTPUT_ADDR_DIFF_ELT: Dispatch Tables. -* ASM_OUTPUT_ADDR_VEC_ELT: Dispatch Tables. -* ASM_OUTPUT_ALIGN: Alignment Output. -* ASM_OUTPUT_ALIGNED_COMMON: Uninitialized Data. -* ASM_OUTPUT_ALIGNED_LOCAL: Uninitialized Data. -* ASM_OUTPUT_ALIGN_CODE: Alignment Output. -* ASM_OUTPUT_ASCII: Data Output. -* ASM_OUTPUT_BYTE: Data Output. -* ASM_OUTPUT_CASE_END: Dispatch Tables. -* ASM_OUTPUT_CASE_LABEL: Dispatch Tables. -* ASM_OUTPUT_CHAR: Data Output. -* ASM_OUTPUT_COMMON: Uninitialized Data. -* ASM_OUTPUT_CONSTRUCTOR: Macros for Initialization. -* ASM_OUTPUT_DEF: Label Output. -* ASM_OUTPUT_DESTRUCTOR: Macros for Initialization. -* ASM_OUTPUT_DOUBLE: Data Output. -* ASM_OUTPUT_DOUBLE_INT: Data Output. -* ASM_OUTPUT_EXTERNAL: Label Output. -* ASM_OUTPUT_EXTERNAL_LIBCALL: Label Output. -* ASM_OUTPUT_FLOAT: Data Output. -* ASM_OUTPUT_IDENT: File Framework. -* ASM_OUTPUT_INT: Data Output. -* ASM_OUTPUT_INTERNAL_LABEL: Label Output. -* ASM_OUTPUT_LABEL: Label Output. -* ASM_OUTPUT_LABELREF: Label Output. -* ASM_OUTPUT_LOCAL: Uninitialized Data. -* ASM_OUTPUT_LONG_DOUBLE: Data Output. -* ASM_OUTPUT_LOOP_ALIGN: Alignment Output. -* ASM_OUTPUT_OPCODE: Instruction Output. -* ASM_OUTPUT_POOL_PROLOGUE: Data Output. -* ASM_OUTPUT_QUADRUPLE_INT: Data Output. -* ASM_OUTPUT_REG_POP: Instruction Output. -* ASM_OUTPUT_REG_PUSH: Instruction Output. -* ASM_OUTPUT_SECTION_NAME: File Framework. -* ASM_OUTPUT_SHARED_COMMON: Uninitialized Data. -* ASM_OUTPUT_SHARED_LOCAL: Uninitialized Data. -* ASM_OUTPUT_SHORT: Data Output. -* ASM_OUTPUT_SKIP: Alignment Output. -* ASM_OUTPUT_SOURCE_FILENAME: File Framework. -* ASM_OUTPUT_SOURCE_LINE: File Framework. -* ASM_OUTPUT_SPECIAL_POOL_ENTRY: Data Output. -* ASM_SPEC: Driver. -* ASM_STABD_OP: DBX Options. -* ASM_STABN_OP: DBX Options. -* ASM_STABS_OP: DBX Options. -* assembler format: File Framework. -* assembler instructions: Extended Asm. -* assembler instructions in RTL: Assembler. -* assembler names for identifiers: Asm Labels. -* assembler syntax, 88k: M88K Options. -* ASSEMBLER_DIALECT: Instruction Output. -* assemble_name: Label Output. -* assembly code, invalid: Bug Criteria. -* assigning attribute values to insns: Tagging Insns. -* asterisk in template: Output Statement. -* atof: Cross-compilation. -* attr: Tagging Insns. -* attribute expressions: Expressions. -* attribute of variables: Variable Attributes. -* attribute specifications: Attr Example. -* attribute specifications example: Attr Example. -* attributes, defining: Defining Attributes. -* attr_flag: Expressions. -* autoincrement addressing, availability: Portability. -* autoincrement/decrement addressing: Simple Constraints. -* autoincrement/decrement analysis: Passes. -* automatic inline for C++ member fns: Inline. -* backslash: Output Template. -* backtrace for bug reports: Bug Reporting. -* barrier: Insns. -* BASE_REG_CLASS: Register Classes. -* basic blocks: Passes. -* bcmp: Config. -* BIGGEST_ALIGNMENT: Storage Layout. -* BIGGEST_FIELD_ALIGNMENT: Storage Layout. -* Bison parser generator: Installation. -* bit fields: Bit Fields. -* bit shift overflow (88k): M88K Options. -* BITFIELD_NBYTES_LIMITED: Storage Layout. -* BITS_BIG_ENDIAN: Storage Layout. -* BITS_PER_UNIT: Storage Layout. -* BITS_PER_WORD: Storage Layout. -* bitwise complement: Arithmetic. -* bitwise exclusive-or: Arithmetic. -* bitwise inclusive-or: Arithmetic. -* bitwise logical-and: Arithmetic. -* BLKmode: Machine Modes. -* BLOCK_PROFILER: Profiling. -* BLOCK_PROFILER_CODE: Profiling. -* BRANCH_COST: Costs. -* break_out_memory_refs: Addressing Modes. -* bug criteria: Bug Criteria. -* bug report mailing lists: Bug Lists. -* bugs: Bugs. -* bugs, known: Trouble. -* builtin functions: C Dialect Options. -* byte writes (29k): AMD29K Options. -* BYTES_BIG_ENDIAN: Storage Layout. -* byte_mode: Machine Modes. -* bzero: Config. -* C compilation options: Invoking GCC. -* C intermediate output, nonexistent: G++ and GCC. -* C language extensions: C Extensions. -* C language, traditional: C Dialect Options. -* C statements for assembler output: Output Statement. -* c++: Invoking G++. -* C++: G++ and GCC. -* C++ compilation options: Invoking GCC. -* C++ interface and implementation headers: C++ Interface. -* C++ language extensions: C++ Extensions. -* C++ member fns, automatically inline: Inline. -* C++ misunderstandings: C++ Misunderstandings. -* C++ named return value: Naming Results. -* C++ options, command line: C++ Dialect Options. -* C++ pragmas, effect on inlining: C++ Interface. -* C++ signatures: C++ Signatures. -* C++ source file suffixes: Invoking G++. -* C++ static data, declaring and defining: Static Definitions. -* C++ subtype polymorphism: C++ Signatures. -* C++ type abstraction: C++ Signatures. -* call: Side Effects. -* call-clobbered register: Register Basics. -* call-saved register: Register Basics. -* call-used register: Register Basics. -* CALLER_SAVE_PROFITABLE: Caller Saves. -* calling conventions: Stack and Calling. -* calling functions in RTL: Calls. -* call_insn: Insns. -* CALL_INSN_FUNCTION_USAGE: Insns. -* CALL_USED_REGISTERS: Register Basics. -* call_used_regs: Register Basics. -* canonicalization of instructions: Insn Canonicalizations. -* CANONICALIZE_COMPARISON: Condition Code. -* CAN_DEBUG_WITHOUT_FP: Run-time Target. -* CAN_ELIMINATE: Elimination. -* case labels in initializers: Labeled Elements. -* case ranges: Case Ranges. -* case sensitivity and VMS: VMS Misc. -* CASE_DROPS_THROUGH: Misc. -* CASE_VALUES_THRESHOLD: Misc. -* CASE_VECTOR_MODE: Misc. -* CASE_VECTOR_PC_RELATIVE: Misc. -* cast to a union: Cast to Union. -* casts as lvalues: Lvalues. -* cc0: Regs and Memory. -* cc0_rtx: Regs and Memory. -* CC1PLUS_SPEC: Driver. -* CC1_SPEC: Driver. -* CCmode: Machine Modes. -* cc_status: Condition Code. -* CC_STATUS_MDEP: Condition Code. -* CC_STATUS_MDEP_INIT: Condition Code. -* CDImode: Machine Modes. -* change_address: Standard Names. -* CHAR_TYPE_SIZE: Type Layout. -* CHECK_FLOAT_VALUE: Storage Layout. -* CHImode: Machine Modes. -* class definitions, register: Register Classes. -* class preference constraints: Class Preferences. -* classes of RTX codes: Accessors. -* CLASS_LIKELY_SPILLED_P: Register Classes. -* CLASS_MAX_NREGS: Register Classes. -* CLEAR_INSN_CACHE: Trampolines. -* clobber: Side Effects. -* code generation conventions: Code Gen Options. -* code generation RTL sequences: Expander Definitions. -* code motion: Passes. -* codes, RTL expression: RTL Objects. -* code_label: Insns. -* CODE_LABEL_NUMBER: Insns. -* COImode: Machine Modes. -* combiner pass: Regs and Memory. -* command options: Invoking GCC. -* common subexpression elimination: Passes. -* compare: Arithmetic. -* compilation in a separate directory: Other Dir. -* compiler bugs, reporting: Bug Reporting. -* compiler compared to C++ preprocessor: G++ and GCC. -* compiler options, C++: C++ Dialect Options. -* compiler passes and files: Passes. -* compiler version, specifying: Target Options. -* COMPILER_PATH: Environment Variables. -* complement, bitwise: Arithmetic. -* complex numbers: Complex. -* compound expressions as lvalues: Lvalues. -* computed gotos: Labels as Values. -* computing the length of an insn: Insn Lengths. -* COMP_TYPE_ATTRIBUTES: Misc. -* cond: Comparisons. -* condition code register: Regs and Memory. -* condition code status: Condition Code. -* condition codes: Comparisons. -* conditional expressions as lvalues: Lvalues. -* conditional expressions, extensions: Conditionals. -* CONDITIONAL_REGISTER_USAGE: Register Basics. -* conditions, in patterns: Patterns. -* configuration file: Config. -* configurations supported by GNU CC: Configurations. -* conflicting types: Disappointments. -* CONST0_RTX: Constants. -* const0_rtx: Constants. -* const1_rtx: Constants. -* CONST1_RTX: Constants. -* CONST2_RTX: Constants. -* const2_rtx: Constants. -* constant attributes: Constant Attributes. -* constant folding: Passes. -* constant folding and floating point: Cross-compilation. -* constant propagation: Passes. -* constants in constraints: Simple Constraints. -* CONSTANT_ADDRESS_P: Addressing Modes. -* CONSTANT_ALIGNMENT: Storage Layout. -* CONSTANT_P: Addressing Modes. -* CONSTANT_POOL_ADDRESS_P: Flags. -* constm1_rtx: Constants. -* constraint modifier characters: Modifiers. -* constraint, matching: Simple Constraints. -* constraints: Constraints. -* constraints, machine specific: Machine Constraints. -* constructing calls: Constructing Calls. -* constructor expressions: Constructors. -* constructors vs goto: Destructors and Goto. -* constructors, automatic calls: Collect2. -* constructors, output of: Initialization. -* CONST_CALL_P: Flags. -* CONST_COSTS: Costs. -* const_double: Constants. -* CONST_DOUBLE_CHAIN: Constants. -* CONST_DOUBLE_LOW: Constants. -* CONST_DOUBLE_MEM: Constants. -* CONST_DOUBLE_OK_FOR_LETTER_P: Register Classes. -* const_int: Constants. -* CONST_OK_FOR_LETTER_P: Register Classes. -* const_string: Constants. -* const_true_rtx: Constants. -* contributors: Contributors. -* controlling register usage: Register Basics. -* controlling the compilation driver: Driver. -* conventions, run-time: Interface. -* conversions: Conversions. -* Convex options: Convex Options. -* copy_rtx_if_shared: Sharing. -* core dump: Bug Criteria. -* cos: C Dialect Options. -* costs of instructions: Costs. -* COSTS_N_INSNS: Costs. -* CPLUS_INCLUDE_PATH: Environment Variables. -* CPP_PREDEFINES: Run-time Target. -* CPP_SPEC: Driver. -* CQImode: Machine Modes. -* cross compilation and floating point: Cross-compilation. -* cross compiling: Target Options. -* cross-compiler, installation: Cross-Compiler. -* cross-jumping: Passes. -* CSImode: Machine Modes. -* CTImode: Machine Modes. -* CUMULATIVE_ARGS: Register Arguments. -* current_function_epilogue_delay_list: Function Entry. -* current_function_outgoing_args_size: Stack Arguments. -* current_function_pops_args: Function Entry. -* current_function_pretend_args_size: Function Entry. -* C_INCLUDE_PATH: Environment Variables. -* data flow analysis: Passes. -* DATA_ALIGNMENT: Storage Layout. -* data_section: Sections. -* DATA_SECTION_ASM_OP: Sections. -* DBR_OUTPUT_SEQEND: Instruction Output. -* dbr_sequence_length: Instruction Output. -* DBX: Interoperation. -* DBX_BLOCKS_FUNCTION_RELATIVE: DBX Options. -* DBX_CONTIN_CHAR: DBX Options. -* DBX_CONTIN_LENGTH: DBX Options. -* DBX_DEBUGGING_INFO: DBX Options. -* DBX_FUNCTION_FIRST: DBX Options. -* DBX_LBRAC_FIRST: DBX Options. -* DBX_MEMPARM_STABS_LETTER: DBX Options. -* DBX_NO_XREFS: DBX Options. -* DBX_OUTPUT_ENUM: DBX Hooks. -* DBX_OUTPUT_FUNCTION_END: DBX Hooks. -* DBX_OUTPUT_LBRAC: DBX Hooks. -* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY: File Names and DBX. -* DBX_OUTPUT_MAIN_SOURCE_FILENAME: File Names and DBX. -* DBX_OUTPUT_MAIN_SOURCE_FILE_END: File Names and DBX. -* DBX_OUTPUT_RBRAC: DBX Hooks. -* DBX_OUTPUT_SOURCE_FILENAME: File Names and DBX. -* DBX_OUTPUT_STANDARD_TYPES: DBX Hooks. -* DBX_REGISTER_NUMBER: All Debuggers. -* DBX_REGPARM_STABS_CODE: DBX Options. -* DBX_REGPARM_STABS_LETTER: DBX Options. -* DBX_STATIC_CONST_VAR_CODE: DBX Options. -* DBX_STATIC_STAB_DATA_SECTION: DBX Options. -* DBX_TYPE_DECL_STABS_CODE: DBX Options. -* DBX_WORKING_DIRECTORY: File Names and DBX. -* DCmode: Machine Modes. -* De Morgan's law: Insn Canonicalizations. -* dead code: Passes. -* dead_or_set_p: Peephole Definitions. -* deallocating variable length arrays: Variable Length. -* death notes: Obsolete Register Macros. -* DEBUGGER_ARG_OFFSET: All Debuggers. -* DEBUGGER_AUTO_OFFSET: All Debuggers. -* debugging information generation: Passes. -* debugging information options: Debugging Options. -* debugging, 88k OCS: M88K Options. -* debug_rtx: Bug Reporting. -* DEBUG_SYMS_TEXT: DBX Options. -* declaration scope: Incompatibilities. -* declarations inside expressions: Statement Exprs. -* declarations, RTL: RTL Declarations. -* declaring attributes of functions: Function Attributes. -* declaring static data in C++: Static Definitions. -* default implementation, signature member function: C++ Signatures. -* DEFAULT_CALLER_SAVES: Caller Saves. -* DEFAULT_GDB_EXTENSIONS: DBX Options. -* DEFAULT_MAIN_RETURN: Misc. -* DEFAULT_PCC_STRUCT_RETURN: Aggregate Return. -* DEFAULT_SHORT_ENUMS: Type Layout. -* DEFAULT_SIGNED_CHAR: Type Layout. -* define_asm_attributes: Tagging Insns. -* define_attr: Defining Attributes. -* define_delay: Delay Slots. -* define_expand: Expander Definitions. -* define_function_unit: Function Units. -* define_insn: Patterns. -* define_peephole: Expander Definitions. -* define_split: Insn Splitting. -* defining attributes and their values: Defining Attributes. -* defining jump instruction patterns: Jump Patterns. -* defining peephole optimizers: Peephole Definitions. -* defining RTL sequences for code generation: Expander Definitions. -* defining static data in C++: Static Definitions. -* delay slots, defining: Delay Slots. -* delayed branch scheduling: Passes. -* DELAY_SLOTS_FOR_EPILOGUE: Function Entry. -* dependencies for make as output: Environment Variables. -* dependencies, make: Preprocessor Options. -* DEPENDENCIES_OUTPUT: Environment Variables. -* Dependent Patterns: Dependent Patterns. -* destructors vs goto: Destructors and Goto. -* destructors, output of: Initialization. -* detecting -traditional: C Dialect Options. -* DFmode: Machine Modes. -* dialect options: C Dialect Options. -* digits in constraint: Simple Constraints. -* DImode: Machine Modes. -* directory options: Directory Options. -* DIR_SEPARATOR: Config. -* disabling certain registers: Register Basics. -* dispatch table: Dispatch Tables. -* div: Arithmetic. -* DIVDI3_LIBCALL: Library Calls. -* divide instruction, 88k: M88K Options. -* division: Arithmetic. -* division: Arithmetic. -* division: Arithmetic. -* DIVSI3_LIBCALL: Library Calls. -* dollar signs in identifier names: Dollar Signs. -* DOLLARS_IN_IDENTIFIERS: Misc. -* DONE: Expander Definitions. -* DONT_DECLARE_SYS_SIGLIST: Config. -* DONT_REDUCE_ADDR: Costs. -* double-word arithmetic: Long Long. -* DOUBLE_TYPE_SIZE: Type Layout. -* downward funargs: Nested Functions. -* driver: Driver. -* DW bit (29k): AMD29K Options. -* DWARF_DEBUGGING_INFO: SDB and DWARF. -* DYNAMIC_CHAIN_ADDRESS: Frame Layout. -* EASY_DIV_EXPR: Misc. -* ELIGIBLE_FOR_EPILOGUE_DELAY: Function Entry. -* ELIMINABLE_REGS: Elimination. -* empty constraints: No Constraints. -* EMPTY_FIELD_BOUNDARY: Storage Layout. -* ENCODE_SECTION_INFO: Sections. -* ENDFILE_SPEC: Driver. -* endianness: Portability. -* enum machine_mode: Machine Modes. -* enum reg_class: Register Classes. -* enumeration clash warnings: Warning Options. -* environment variables: Environment Variables. -* epilogue: Function Entry. -* eq: Comparisons. -* equal: Comparisons. -* eq_attr: Expressions. -* error messages: Warnings and Errors. -* escape sequences, traditional: C Dialect Options. -* exclamation point: Multi-Alternative. -* exclusive-or, bitwise: Arithmetic. -* EXECUTABLE_SUFFIX: Config. -* exit: C Dialect Options. -* exit status and VMS: VMS Misc. -* EXIT_BODY: Misc. -* EXIT_IGNORE_STACK: Function Entry. -* expander definitions: Expander Definitions. -* EXPAND_BUILTIN_SAVEREGS: Varargs. -* explicit register variables: Explicit Reg Vars. -* expression codes: RTL Objects. -* expressions containing statements: Statement Exprs. -* expressions, compound, as lvalues: Lvalues. -* expressions, conditional, as lvalues: Lvalues. -* expressions, constructor: Constructors. -* expr_list: Insns. -* extended asm: Extended Asm. -* extensible constraints: Simple Constraints. -* extensions, ?:: Lvalues. -* extensions, ?:: Conditionals. -* extensions, C language: C Extensions. -* extensions, C++ language: C++ Extensions. -* extern int target_flags: Run-time Target. -* external declaration scope: Incompatibilities. -* EXTRA_CC_MODES: Condition Code. -* EXTRA_CC_NAMES: Condition Code. -* EXTRA_CONSTRAINT: Register Classes. -* EXTRA_SECTIONS: Sections. -* EXTRA_SECTION_FUNCTIONS: Sections. -* fabs: C Dialect Options. -* FAIL: Expander Definitions. -* FAILURE_EXIT_CODE: Config. -* fatal signal: Bug Criteria. -* features, optional, in system conventions: Run-time Target. -* ffs: Arithmetic. -* ffs: C Dialect Options. -* file name suffix: Overall Options. -* file names: Link Options. -* files and passes of the compiler: Passes. -* final pass: Passes. -* FINALIZE_PIC: PIC. -* FINAL_PRESCAN_INSN: Instruction Output. -* FINAL_REG_PARM_STACK_SPACE: Stack Arguments. -* final_scan_insn: Function Entry. -* final_sequence: Instruction Output. -* FIRST_INSN_ADDRESS: Insn Lengths. -* FIRST_PARM_OFFSET: Frame Layout. -* FIRST_PSEUDO_REGISTER: Register Basics. -* FIRST_STACK_REG: Stack Registers. -* FIRST_VIRTUAL_REGISTER: Regs and Memory. -* fix: Conversions. -* fix: Conversions. -* fixed register: Register Basics. -* FIXED_REGISTERS: Register Basics. -* fixed_regs: Register Basics. -* FIXUNS_TRUNC_LIKE_FIX_TRUNC: Misc. -* flags in RTL expression: Flags. -* float: Conversions. -* FLOATIFY: Library Calls. -* floating point and cross compilation: Cross-compilation. -* FLOAT_ARG_TYPE: Library Calls. -* float_extend: Conversions. -* FLOAT_STORE_FLAG_VALUE: Misc. -* float_truncate: Conversions. -* FLOAT_TYPE_SIZE: Type Layout. -* FLOAT_VALUE_TYPE: Library Calls. -* FLOAT_WORDS_BIG_ENDIAN: Storage Layout. -* force_reg: Standard Names. -* forwarding calls: Constructing Calls. -* frame layout: Frame Layout. -* FRAME_GROWS_DOWNWARD: Frame Layout. -* frame_pointer_needed: Function Entry. -* FRAME_POINTER_REGNUM: Frame Registers. -* FRAME_POINTER_REQUIRED: Elimination. -* frame_pointer_rtx: Frame Registers. -* function attributes: Function Attributes. -* function call conventions: Interface. -* function entry and exit: Function Entry. -* function pointers, arithmetic: Pointer Arith. -* function prototype declarations: Function Prototypes. -* function units, for scheduling: Function Units. -* function, size of pointer to: Pointer Arith. -* function-call insns: Calls. -* functions in arbitrary sections: Function Attributes. -* functions that have no side effects: Function Attributes. -* functions that never return: Function Attributes. -* functions with printf or scanf style arguments: Function Attributes. -* functions, leaf: Leaf Functions. -* FUNCTION_ARG: Register Arguments. -* FUNCTION_ARG_ADVANCE: Register Arguments. -* FUNCTION_ARG_BOUNDARY: Register Arguments. -* FUNCTION_ARG_CALLEE_COPIES: Register Arguments. -* FUNCTION_ARG_PADDING: Register Arguments. -* FUNCTION_ARG_PARTIAL_NREGS: Register Arguments. -* FUNCTION_ARG_PASS_BY_REFERENCE: Register Arguments. -* FUNCTION_ARG_REGNO_P: Register Arguments. -* FUNCTION_BLOCK_PROFILER: Profiling. -* FUNCTION_BOUNDARY: Storage Layout. -* FUNCTION_CONVERSION_BUG: Config. -* FUNCTION_EPILOGUE: Function Entry. -* FUNCTION_INCOMING_ARG: Register Arguments. -* FUNCTION_MODE: Misc. -* FUNCTION_OUTGOING_VALUE: Scalar Return. -* FUNCTION_PROFILER: Profiling. -* FUNCTION_PROLOGUE: Function Entry. -* FUNCTION_VALUE: Scalar Return. -* FUNCTION_VALUE_REGNO_P: Scalar Return. -* G++: G++ and GCC. -* g++: Invoking G++. -* GCC: G++ and GCC. -* GCC_EXEC_PREFIX: Environment Variables. -* ge: Comparisons. -* gencodes: Passes. -* genconfig: Passes. -* generalized lvalues: Lvalues. -* general_operand: RTL Template. -* GENERAL_REGS: Register Classes. -* generating assembler output: Output Statement. -* generating insns: RTL Template. -* genflags: Passes. -* GEN_ERRNO_RTX: Library Calls. -* get_attr: Expressions. -* get_attr_length: Insn Lengths. -* GET_CLASS_NARROWEST_MODE: Machine Modes. -* GET_CODE: RTL Objects. -* get_frame_size: Elimination. -* get_insns: Insns. -* get_last_insn: Insns. -* GET_MODE: Machine Modes. -* GET_MODE_ALIGNMENT: Machine Modes. -* GET_MODE_BITSIZE: Machine Modes. -* GET_MODE_CLASS: Machine Modes. -* GET_MODE_MASK: Machine Modes. -* GET_MODE_NAME: Machine Modes. -* GET_MODE_NUNITS: Machine Modes. -* GET_MODE_SIZE: Machine Modes. -* GET_MODE_UNIT_SIZE: Machine Modes. -* GET_MODE_WIDER_MODE: Machine Modes. -* GET_RTX_CLASS: Accessors. -* GET_RTX_FORMAT: Accessors. -* GET_RTX_LENGTH: Accessors. -* geu: Comparisons. -* global offset table: Code Gen Options. -* global register after longjmp: Global Reg Vars. -* global register allocation: Passes. -* global register variables: Global Reg Vars. -* GLOBALDEF: Global Declarations. -* GLOBALREF: Global Declarations. -* GLOBALVALUEDEF: Global Declarations. -* GLOBALVALUEREF: Global Declarations. -* GNU CC and portability: Portability. -* GNU CC command options: Invoking GCC. -* goto with computed label: Labels as Values. -* GO_IF_LEGITIMATE_ADDRESS: Addressing Modes. -* GO_IF_MODE_DEPENDENT_ADDRESS: Addressing Modes. -* gp-relative references (MIPS): MIPS Options. -* greater than: Comparisons. -* greater than: Comparisons. -* greater than: Comparisons. -* grouping options: Invoking GCC. -* gt: Comparisons. -* gtu: Comparisons. -* HANDLE_PRAGMA: Misc. -* hard registers: Regs and Memory. -* hardware models and configurations, specifying: Submodel Options. -* HARD_FRAME_POINTER_REGNUM: Frame Registers. -* HARD_REGNO_MODE_OK: Values in Registers. -* HARD_REGNO_NREGS: Values in Registers. -* HAS_INIT_SECTION: Macros for Initialization. -* HAVE_ATEXIT: Misc. -* HAVE_POST_DECREMENT: Addressing Modes. -* HAVE_POST_INCREMENT: Addressing Modes. -* HAVE_PRE_DECREMENT: Addressing Modes. -* HAVE_PRE_INCREMENT: Addressing Modes. -* HAVE_PUTENV: Config. -* HAVE_VPRINTF: Config. -* header files and VMS: Include Files and VMS. -* high: Constants. -* HImode: Machine Modes. -* HOST_BITS_PER_CHAR: Config. -* HOST_BITS_PER_INT: Config. -* HOST_BITS_PER_LONG: Config. -* HOST_BITS_PER_SHORT: Config. -* HOST_FLOAT_FORMAT: Config. -* HOST_FLOAT_WORDS_BIG_ENDIAN: Config. -* HOST_WORDS_BIG_ENDIAN: Config. -* HPPA Options: HPPA Options. -* i386 Options: i386 Options. -* IBM RS/6000 and PowerPC Options: RS/6000 and PowerPC Options. -* IBM RT options: RT Options. -* IBM RT PC: Interoperation. -* identifier names, dollar signs in: Dollar Signs. -* identifiers, names in assembler code: Asm Labels. -* identifying source, compiler (88k): M88K Options. -* IEEE_FLOAT_FORMAT: Storage Layout. -* if_then_else: Comparisons. -* immediate_operand: RTL Template. -* IMMEDIATE_PREFIX: Instruction Output. -* implicit argument: return value: Naming Results. -* IMPLICIT_FIX_EXPR: Misc. -* implied #pragma implementation: C++ Interface. -* include files and VMS: Include Files and VMS. -* INCLUDE_DEFAULTS: Driver. -* inclusive-or, bitwise: Arithmetic. -* INCOMING_REGNO: Register Basics. -* incompatibilities of GNU CC: Incompatibilities. -* increment operators: Bug Criteria. -* INDEX_REG_CLASS: Register Classes. -* initialization routines: Initialization. -* initializations in expressions: Constructors. -* initializers with labeled elements: Labeled Elements. -* initializers, non-constant: Initializers. -* INITIALIZE_TRAMPOLINE: Trampolines. -* INITIAL_ELIMINATION_OFFSET: Elimination. -* INITIAL_FRAME_POINTER_OFFSET: Elimination. -* INIT_CUMULATIVE_ARGS: Register Arguments. -* INIT_CUMULATIVE_INCOMING_ARGS: Register Arguments. -* INIT_SECTION_ASM_OP: Sections. -* INIT_SECTION_ASM_OP: Macros for Initialization. -* INIT_TARGET_OPTABS: Library Calls. -* inline functions: Inline. -* inline functions, omission of: Inline. -* inline, automatic: Passes. -* inlining and C++ pragmas: C++ Interface. -* insn: Insns. -* insn attributes: Insn Attributes. -* insn canonicalization: Insn Canonicalizations. -* insn lengths, computing: Insn Lengths. -* insn splitting: Insn Splitting. -* insn-attr.h: Defining Attributes. -* insns: Insns. -* insns, generating: RTL Template. -* insns, recognizing: RTL Template. -* INSN_ANNULLED_BRANCH_P: Flags. -* INSN_CACHE_DEPTH: Trampolines. -* INSN_CACHE_LINE_WIDTH: Trampolines. -* INSN_CACHE_SIZE: Trampolines. -* INSN_CLOBBERS_REGNO_P: Obsolete Register Macros. -* INSN_CODE: Insns. -* INSN_DELETED_P: Flags. -* INSN_FROM_TARGET_P: Flags. -* insn_list: Insns. -* INSN_REFERENCES_ARE_DELAYED: Misc. -* INSN_SETS_ARE_DELAYED: Misc. -* INSN_UID: Insns. -* installation trouble: Trouble. -* installing GNU CC: Installation. -* installing GNU CC on the Sun: Sun Install. -* installing GNU CC on VMS: VMS Install. -* instruction attributes: Insn Attributes. -* instruction combination: Passes. -* instruction patterns: Patterns. -* instruction recognizer: Passes. -* instruction scheduling: Passes. -* instruction scheduling: Passes. -* instruction splitting: Insn Splitting. -* integrated: Flags. -* INTEGRATE_THRESHOLD: Misc. -* integrating function code: Inline. -* Intel 386 Options: i386 Options. -* Interdependence of Patterns: Dependent Patterns. -* interface and implementation headers, C++: C++ Interface. -* interfacing to GNU CC output: Interface. -* intermediate C version, nonexistent: G++ and GCC. -* INTIFY: Library Calls. -* introduction: Top. -* INT_TYPE_SIZE: Type Layout. -* invalid assembly code: Bug Criteria. -* invalid input: Bug Criteria. -* INVOKE__main: Macros for Initialization. -* invoking g++: Invoking G++. -* in_data: Sections. -* in_struct: Flags. -* in_text: Sections. -* ior: Arithmetic. -* isinf: Cross-compilation. -* isnan: Cross-compilation. -* IS_ASM_LOGICAL_LINE_SEPARATOR: Data Output. -* jump instruction patterns: Jump Patterns. -* jump instructions and set: Side Effects. -* jump optimization: Passes. -* jump threading: Passes. -* jump_insn: Insns. -* JUMP_LABEL: Insns. -* JUMP_TABLES_IN_TEXT_SECTION: Sections. -* kernel and user registers (29k): AMD29K Options. -* keywords, alternate: Alternate Keywords. -* known causes of trouble: Trouble. -* labeled elements in initializers: Labeled Elements. -* labels as values: Labels as Values. -* LABEL_NUSES: Insns. -* LABEL_OUTSIDE_LOOP_P: Flags. -* LABEL_PRESERVE_P: Flags. -* label_ref: Constants. -* labs: C Dialect Options. -* language dialect options: C Dialect Options. -* large bit shifts (88k): M88K Options. -* large return values: Aggregate Return. -* LAST_STACK_REG: Stack Registers. -* LAST_VIRTUAL_REGISTER: Regs and Memory. -* ldexp: Cross-compilation. -* le: Comparisons. -* leaf functions: Leaf Functions. -* leaf_function: Leaf Functions. -* leaf_function_p: Standard Names. -* LEAF_REGISTERS: Leaf Functions. -* LEAF_REG_REMAP: Leaf Functions. -* left rotate: Arithmetic. -* left shift: Arithmetic. -* LEGITIMATE_CONSTANT_P: Addressing Modes. -* LEGITIMATE_PIC_OPERAND_P: PIC. -* LEGITIMIZE_ADDRESS: Addressing Modes. -* length-zero arrays: Zero Length. -* less than: Comparisons. -* less than or equal: Comparisons. -* leu: Comparisons. -* LIBCALL_VALUE: Scalar Return. -* LIBGCC_NEEDS_DOUBLE: Library Calls. -* Libraries: Link Options. -* library subroutine names: Library Calls. -* LIBRARY_PATH: Environment Variables. -* LIB_SPEC: Driver. -* LIMIT_RELOAD_CLASS: Register Classes. -* link options: Link Options. -* LINK_LIBGCC_SPECIAL: Driver. -* LINK_LIBGCC_SPECIAL_1: Driver. -* LINK_SPEC: Driver. -* load address instruction: Simple Constraints. -* LOAD_EXTEND_OP: Misc. -* local labels: Local Labels. -* local register allocation: Passes. -* local variables in macros: Naming Types. -* local variables, specifying registers: Local Reg Vars. -* LOCAL_INCLUDE_DIR: Driver. -* LOCAL_LABEL_PREFIX: Instruction Output. -* logical-and, bitwise: Arithmetic. -* LOG_LINKS: Insns. -* longjmp: Global Reg Vars. -* LONGJMP_RESTORE_FROM_STACK: Elimination. -* LONG_DOUBLE_TYPE_SIZE: Type Layout. -* LONG_LONG_TYPE_SIZE: Type Layout. -* LONG_TYPE_SIZE: Type Layout. -* loop optimization: Passes. -* lo_sum: Arithmetic. -* lshiftrt: Arithmetic. -* lt: Comparisons. -* ltu: Comparisons. -* lvalues, generalized: Lvalues. -* M680x0 options: M680x0 Options. -* M88k options: M88K Options. -* machine dependent options: Submodel Options. -* machine description macros: Target Macros. -* machine descriptions: Machine Desc. -* machine mode conversions: Conversions. -* machine modes: Machine Modes. -* machine specific constraints: Machine Constraints. -* MACHINE_DEPENDENT_REORG: Misc. -* macro with variable arguments: Macro Varargs. -* macros containing asm: Extended Asm. -* macros, inline alternative: Inline. -* macros, local labels: Local Labels. -* macros, local variables in: Naming Types. -* macros, statements in expressions: Statement Exprs. -* macros, target description: Target Macros. -* macros, types of arguments: Typeof. -* make: Preprocessor Options. -* make_safe_from: Expander Definitions. -* matching constraint: Simple Constraints. -* matching operands: Output Template. -* match_dup: RTL Template. -* match_operand: RTL Template. -* match_operator: RTL Template. -* match_op_dup: RTL Template. -* match_parallel: RTL Template. -* match_par_dup: RTL Template. -* match_scratch: RTL Template. -* math libraries: Interface. -* math, in RTL: Arithmetic. -* maximum operator: Min and Max. -* MAX_BITS_PER_WORD: Storage Layout. -* MAX_CHAR_TYPE_SIZE: Type Layout. -* MAX_FIXED_MODE_SIZE: Storage Layout. -* MAX_INT_TYPE_SIZE: Type Layout. -* MAX_LONG_TYPE_SIZE: Type Layout. -* MAX_MOVE_MAX: Misc. -* MAX_OFILE_ALIGNMENT: Storage Layout. -* MAX_REGS_PER_ADDRESS: Addressing Modes. -* MAX_UNITS_PER_WORD: Storage Layout. -* MAX_WCHAR_TYPE_SIZE: Type Layout. -* MAYBE_REG_PARM_STACK_SPACE: Stack Arguments. -* mcount: Profiling. -* MD_CALL_PROTOTYPES: Config. -* MD_EXEC_PREFIX: Driver. -* MD_STARTFILE_PREFIX: Driver. -* MD_STARTFILE_PREFIX_1: Driver. -* mem: Regs and Memory. -* member fns, automatically inline: Inline. -* memcmp: C Dialect Options. -* memcpy: C Dialect Options. -* memory model (29k): AMD29K Options. -* memory reference, nonoffsettable: Simple Constraints. -* memory references in constraints: Simple Constraints. -* MEMORY_MOVE_COST: Costs. -* MEM_IN_STRUCT_P: Flags. -* MEM_VOLATILE_P: Flags. -* messages, warning: Warning Options. -* messages, warning and error: Warnings and Errors. -* middle-operands, omitted: Conditionals. -* minimum operator: Min and Max. -* minus: Arithmetic. -* MIPS options: MIPS Options. -* misunderstandings in C++: C++ Misunderstandings. -* mod: Arithmetic. -* MODDI3_LIBCALL: Library Calls. -* mode classes: Machine Modes. -* MODES_TIEABLE_P: Values in Registers. -* MODE_CC: Machine Modes. -* MODE_COMPLEX_FLOAT: Machine Modes. -* MODE_COMPLEX_INT: Machine Modes. -* MODE_FLOAT: Machine Modes. -* MODE_FUNCTION: Machine Modes. -* MODE_INT: Machine Modes. -* MODE_PARTIAL_INT: Machine Modes. -* MODE_RANDOM: Machine Modes. -* modifiers in constraints: Modifiers. -* MODSI3_LIBCALL: Library Calls. -* MOVE_MAX: Misc. -* MOVE_RATIO: Costs. -* MULDI3_LIBCALL: Library Calls. -* MULSI3_LIBCALL: Library Calls. -* mult: Arithmetic. -* MULTIBYTE_CHARS: Config. -* multiple alternative constraints: Multi-Alternative. -* multiplication: Arithmetic. -* multiprecision arithmetic: Long Long. -* name augmentation: VMS Misc. -* named patterns and conditions: Patterns. -* named return value in C++: Naming Results. -* names used in assembler code: Asm Labels. -* names, pattern: Standard Names. -* naming convention, implementation headers: C++ Interface. -* naming types: Naming Types. -* ne: Comparisons. -* neg: Arithmetic. -* nested functions: Nested Functions. -* nested functions, trampolines for: Trampolines. -* newline vs string constants: C Dialect Options. -* next_cc0_user: Jump Patterns. -* NEXT_INSN: Insns. -* NEXT_OBJC_RUNTIME: Library Calls. -* nil: RTL Objects. -* no constraints: No Constraints. -* no-op move instructions: Passes. -* non-constant initializers: Initializers. -* non-static inline function: Inline. -* nongcc_SI_type: Library Calls. -* nongcc_word_type: Library Calls. -* nonoffsettable memory reference: Simple Constraints. -* NON_SAVING_SETJMP: Register Basics. -* not: Arithmetic. -* not equal: Comparisons. -* not using constraints: No Constraints. -* note: Insns. -* NOTE_INSN_BLOCK_BEG: Insns. -* NOTE_INSN_BLOCK_END: Insns. -* NOTE_INSN_DELETED: Insns. -* NOTE_INSN_FUNCTION_END: Insns. -* NOTE_INSN_LOOP_BEG: Insns. -* NOTE_INSN_LOOP_CONT: Insns. -* NOTE_INSN_LOOP_END: Insns. -* NOTE_INSN_LOOP_VTOP: Insns. -* NOTE_INSN_SETJMP: Insns. -* NOTE_LINE_NUMBER: Insns. -* NOTE_SOURCE_FILE: Insns. -* NOTICE_UPDATE_CC: Condition Code. -* NO_BUILTIN_PTRDIFF_TYPE: Driver. -* NO_BUILTIN_SIZE_TYPE: Driver. -* NO_DOLLAR_IN_LABEL: Misc. -* NO_DOT_IN_LABEL: Misc. -* NO_FUNCTION_CSE: Costs. -* NO_IMPLICIT_EXTERN_C: Misc. -* NO_MD_PROTOTYPES: Config. -* NO_RECURSIVE_FUNCTION_CSE: Costs. -* NO_REGS: Register Classes. -* NO_STAB_H: Config. -* NO_SYS_SIGLIST: Config. -* NUM_MACHINE_MODES: Machine Modes. -* N_REG_CLASSES: Register Classes. -* OBJC_GEN_METHOD_LABEL: Label Output. -* OBJC_INCLUDE_PATH: Environment Variables. -* OBJC_INT_SELECTORS: Type Layout. -* OBJC_PROLOGUE: File Framework. -* OBJC_SELECTORS_WITHOUT_LABELS: Type Layout. -* Objective C: G++ and GCC. -* OBJECT_FORMAT_COFF: Macros for Initialization. -* OBJECT_FORMAT_ROSE: Macros for Initialization. -* OBSTACK_CHUNK_ALLOC: Config. -* OBSTACK_CHUNK_FREE: Config. -* OBSTACK_CHUNK_SIZE: Config. -* obstack_free: Configurations. -* OCS (88k): M88K Options. -* offsettable address: Simple Constraints. -* old-style function definitions: Function Prototypes. -* omitted middle-operands: Conditionals. -* ONLY_INT_FIELDS: Config. -* open coding: Inline. -* operand access: Accessors. -* operand constraints: Constraints. -* operand substitution: Output Template. -* operands: Patterns. -* OPTIMIZATION_OPTIONS: Run-time Target. -* optimize options: Optimize Options. -* optional hardware or system features: Run-time Target. -* options to control warnings: Warning Options. -* options, C++: C++ Dialect Options. -* options, code generation: Code Gen Options. -* options, debugging: Debugging Options. -* options, dialect: C Dialect Options. -* options, directory search: Directory Options. -* options, GNU CC command: Invoking GCC. -* options, grouping: Invoking GCC. -* options, linking: Link Options. -* options, optimization: Optimize Options. -* options, order: Invoking GCC. -* options, preprocessor: Preprocessor Options. -* order of evaluation, side effects: Non-bugs. -* order of options: Invoking GCC. -* order of register allocation: Allocation Order. -* Ordering of Patterns: Pattern Ordering. -* ORDER_REGS_FOR_LOCAL_ALLOC: Allocation Order. -* other directory, compilation in: Other Dir. -* OUTGOING_REGNO: Register Basics. -* OUTGOING_REG_PARM_STACK_SPACE: Stack Arguments. -* output file option: Overall Options. -* output of assembler code: File Framework. -* output statements: Output Statement. -* output templates: Output Template. -* output_addr_const: Data Output. -* output_asm_insn: Output Statement. -* overflow while constant folding: Cross-compilation. -* OVERLAPPING_REGNO_P: Obsolete Register Macros. -* overloaded virtual fn, warning: Warning Options. -* OVERRIDE_OPTIONS: Run-time Target. -* parallel: Side Effects. -* parameter forward declaration: Variable Length. -* parameters, miscellaneous: Misc. -* PARM_BOUNDARY: Storage Layout. -* parser generator, Bison: Installation. -* parsing pass: Passes. -* passes and files of the compiler: Passes. -* passing arguments: Interface. -* PATH_SEPARATOR: Config. -* PATTERN: Insns. -* pattern conditions: Patterns. -* pattern names: Standard Names. -* Pattern Ordering: Pattern Ordering. -* patterns: Patterns. -* pc: Regs and Memory. -* PCC_BITFIELD_TYPE_MATTERS: Storage Layout. -* PCC_STATIC_STRUCT_RETURN: Aggregate Return. -* pc_rtx: Regs and Memory. -* PDImode: Machine Modes. -* peephole optimization: Passes. -* peephole optimization, RTL representation: Side Effects. -* peephole optimizer definitions: Peephole Definitions. -* percent sign: Output Template. -* perform_...: Library Calls. -* PIC: PIC. -* PIC: Code Gen Options. -* PIC_OFFSET_TABLE_REGNUM: PIC. -* plus: Arithmetic. -* Pmode: Misc. -* pointer arguments: Function Attributes. -* POINTER_SIZE: Storage Layout. -* portability: Portability. -* portions of temporary objects, pointers to: Temporaries. -* position independent code: PIC. -* post_dec: Incdec. -* post_inc: Incdec. -* pragma: Misc. -* pragma, reason for not using: Function Attributes. -* pragmas in C++, effect on inlining: C++ Interface. -* pragmas, interface and implementation: C++ Interface. -* predefined macros: Run-time Target. -* PREDICATE_CODES: Misc. -* PREFERRED_DEBUGGING_TYPE: All Debuggers. -* PREFERRED_OUTPUT_RELOAD_CLASS: Register Classes. -* PREFERRED_RELOAD_CLASS: Register Classes. -* preprocessing numbers: Incompatibilities. -* preprocessing tokens: Incompatibilities. -* preprocessor options: Preprocessor Options. -* PRESERVE_DEATH_INFO_REGNO_P: Obsolete Register Macros. -* prev_cc0_setter: Jump Patterns. -* PREV_INSN: Insns. -* prev_nonnote_insn: Peephole Definitions. -* pre_dec: Incdec. -* pre_inc: Incdec. -* PRINT_OPERAND: Instruction Output. -* PRINT_OPERAND_ADDRESS: Instruction Output. -* PRINT_OPERAND_PUNCT_VALID_P: Instruction Output. -* processor selection (29k): AMD29K Options. -* product: Arithmetic. -* PROFILE_BEFORE_PROLOGUE: Profiling. -* profiling, code generation: Profiling. -* program counter: Regs and Memory. -* prologue: Function Entry. -* PROMOTE_FOR_CALL_ONLY: Storage Layout. -* PROMOTE_FUNCTION_ARGS: Storage Layout. -* PROMOTE_FUNCTION_RETURN: Storage Layout. -* PROMOTE_MODE: Storage Layout. -* PROMOTE_PROTOTYPES: Stack Arguments. -* promotion of formal parameters: Function Prototypes. -* pseudo registers: Regs and Memory. -* PSImode: Machine Modes. -* PTRDIFF_TYPE: Type Layout. -* push address instruction: Simple Constraints. -* PUSH_ROUNDING: Stack Arguments. -* putenv: Config. -* PUT_CODE: RTL Objects. -* PUT_MODE: Machine Modes. -* PUT_REG_NOTE_KIND: Insns. -* PUT_SDB_...: SDB and DWARF. -* QImode: Machine Modes. -* question mark: Multi-Alternative. -* quotient: Arithmetic. -* r0-relative references (88k): M88K Options. -* ranges in case statements: Case Ranges. -* read-only strings: Incompatibilities. -* READONLY_DATA_SECTION: Sections. -* REAL_ARITHMETIC: Cross-compilation. -* REAL_INFINITY: Cross-compilation. -* REAL_NM_FILE_NAME: Macros for Initialization. -* REAL_VALUES_EQUAL: Cross-compilation. -* REAL_VALUES_LESS: Cross-compilation. -* REAL_VALUE_ATOF: Cross-compilation. -* REAL_VALUE_FIX: Cross-compilation. -* REAL_VALUE_FROM_INT: Cross-compilation. -* REAL_VALUE_ISINF: Cross-compilation. -* REAL_VALUE_ISNAN: Cross-compilation. -* REAL_VALUE_LDEXP: Cross-compilation. -* REAL_VALUE_NEGATE: Cross-compilation. -* REAL_VALUE_RNDZINT: Cross-compilation. -* REAL_VALUE_TO_DECIMAL: Data Output. -* REAL_VALUE_TO_INT: Cross-compilation. -* REAL_VALUE_TO_TARGET_DOUBLE: Data Output. -* REAL_VALUE_TO_TARGET_LONG_DOUBLE: Data Output. -* REAL_VALUE_TO_TARGET_SINGLE: Data Output. -* REAL_VALUE_TRUNCATE: Cross-compilation. -* REAL_VALUE_TYPE: Cross-compilation. -* REAL_VALUE_UNSIGNED_FIX: Cross-compilation. -* REAL_VALUE_UNSIGNED_RNDZINT: Cross-compilation. -* recognizing insns: RTL Template. -* recog_operand: Instruction Output. -* reg: Regs and Memory. -* register allocation: Passes. -* register allocation order: Allocation Order. -* register allocation, stupid: Passes. -* register class definitions: Register Classes. -* register class preference constraints: Class Preferences. -* register class preference pass: Passes. -* register pairs: Values in Registers. -* register positions in frame (88k): M88K Options. -* register positions in frame (88k): M88K Options. -* Register Transfer Language (RTL): RTL. -* register usage: Registers. -* register use analysis: Passes. -* register variable after longjmp: Global Reg Vars. -* register-to-stack conversion: Passes. -* registers: Extended Asm. -* registers arguments: Register Arguments. -* registers for local variables: Local Reg Vars. -* registers in constraints: Simple Constraints. -* registers, global allocation: Explicit Reg Vars. -* registers, global variables in: Global Reg Vars. -* REGISTER_MOVE_COST: Costs. -* REGISTER_NAMES: Instruction Output. -* register_operand: RTL Template. -* REGISTER_PREFIX: Instruction Output. -* REGNO_OK_FOR_BASE_P: Register Classes. -* REGNO_OK_FOR_INDEX_P: Register Classes. -* REGNO_REG_CLASS: Register Classes. -* regs_ever_live: Function Entry. -* REG_ALLOC_ORDER: Allocation Order. -* REG_CC_SETTER: Insns. -* REG_CC_USER: Insns. -* REG_CLASS_CONTENTS: Register Classes. -* REG_CLASS_FROM_LETTER: Register Classes. -* REG_CLASS_NAMES: Register Classes. -* REG_DEAD: Insns. -* REG_DEP_ANTI: Insns. -* REG_DEP_OUTPUT: Insns. -* REG_EQUAL: Insns. -* REG_EQUIV: Insns. -* REG_FUNCTION_VALUE_P: Flags. -* REG_INC: Insns. -* REG_LABEL: Insns. -* REG_LIBCALL: Insns. -* REG_LOOP_TEST_P: Flags. -* reg_names: Instruction Output. -* REG_NONNEG: Insns. -* REG_NOTES: Insns. -* REG_NOTE_KIND: Insns. -* REG_NO_CONFLICT: Insns. -* REG_OK_FOR_BASE_P: Addressing Modes. -* REG_OK_FOR_INDEX_P: Addressing Modes. -* REG_OK_STRICT: Addressing Modes. -* REG_PARM_STACK_SPACE: Stack Arguments. -* REG_RETVAL: Insns. -* REG_UNUSED: Insns. -* REG_USERVAR_P: Flags. -* REG_WAS_0: Insns. -* relative costs: Costs. -* RELATIVE_PREFIX_NOT_LINKDIR: Driver. -* reload pass: Regs and Memory. -* reloading: Passes. -* reload_completed: Standard Names. -* reload_in_progress: Standard Names. -* remainder: Arithmetic. -* reordering, warning: Warning Options. -* reporting bugs: Bugs. -* representation of RTL: RTL. -* rest argument (in macro): Macro Varargs. -* rest_of_compilation: Passes. -* rest_of_decl_compilation: Passes. -* return: Side Effects. -* return value of main: VMS Misc. -* return value, named, in C++: Naming Results. -* return values in registers: Scalar Return. -* returning aggregate values: Aggregate Return. -* returning structures and unions: Interface. -* RETURN_ADDR_IN_PREVIOUS_FRAME: Frame Layout. -* RETURN_ADDR_RTX: Frame Layout. -* RETURN_IN_MEMORY: Aggregate Return. -* RETURN_POPS_ARGS: Stack Arguments. -* REVERSIBLE_CC_MODE: Condition Code. -* right rotate: Arithmetic. -* right shift: Arithmetic. -* rotate: Arithmetic. -* rotate: Arithmetic. -* rotatert: Arithmetic. -* ROUND_TYPE_ALIGN: Storage Layout. -* ROUND_TYPE_SIZE: Storage Layout. -* RS/6000 and PowerPC Options: RS/6000 and PowerPC Options. -* RT options: RT Options. -* RT PC: Interoperation. -* RTL addition: Arithmetic. -* RTL comparison: Arithmetic. -* RTL comparison operations: Comparisons. -* RTL constant expression types: Constants. -* RTL constants: Constants. -* RTL declarations: RTL Declarations. -* RTL difference: Arithmetic. -* RTL expression: RTL Objects. -* RTL expressions for arithmetic: Arithmetic. -* RTL format: Accessors. -* RTL format characters: Accessors. -* RTL function-call insns: Calls. -* RTL generation: Passes. -* RTL insn template: RTL Template. -* RTL integers: RTL Objects. -* RTL memory expressions: Regs and Memory. -* RTL object types: RTL Objects. -* RTL postdecrement: Incdec. -* RTL postincrement: Incdec. -* RTL predecrement: Incdec. -* RTL preincrement: Incdec. -* RTL register expressions: Regs and Memory. -* RTL representation: RTL. -* RTL side effect expressions: Side Effects. -* RTL strings: RTL Objects. -* RTL structure sharing assumptions: Sharing. -* RTL subtraction: Arithmetic. -* RTL sum: Arithmetic. -* RTL vectors: RTL Objects. -* RTX (See RTL): RTL Objects. -* RTX_COSTS: Costs. -* RTX_INTEGRATED_P: Flags. -* RTX_UNCHANGING_P: Flags. -* run-time conventions: Interface. -* run-time options: Code Gen Options. -* run-time target specification: Run-time Target. -* saveable_obstack: Addressing Modes. -* scalars, returned as values: Scalar Return. -* SCCS_DIRECTIVE: Misc. -* scheduling, delayed branch: Passes. -* scheduling, instruction: Passes. -* scheduling, instruction: Passes. -* SCHED_GROUP_P: Flags. -* SCmode: Machine Modes. -* scope of a variable length array: Variable Length. -* scope of declaration: Disappointments. -* scope of external declarations: Incompatibilities. -* scratch: Regs and Memory. -* scratch operands: Regs and Memory. -* SDB_ALLOW_FORWARD_REFERENCES: SDB and DWARF. -* SDB_ALLOW_UNKNOWN_REFERENCES: SDB and DWARF. -* SDB_DEBUGGING_INFO: SDB and DWARF. -* SDB_DELIM: SDB and DWARF. -* SDB_GENERATE_FAKE: SDB and DWARF. -* search path: Directory Options. -* second include path: Preprocessor Options. -* SECONDARY_INPUT_RELOAD_CLASS: Register Classes. -* SECONDARY_MEMORY_NEEDED: Register Classes. -* SECONDARY_MEMORY_NEEDED_MODE: Register Classes. -* SECONDARY_MEMORY_NEEDED_RTX: Register Classes. -* SECONDARY_OUTPUT_RELOAD_CLASS: Register Classes. -* SECONDARY_RELOAD_CLASS: Register Classes. -* SELECT_CC_MODE: Condition Code. -* SELECT_RTX_SECTION: Sections. -* SELECT_SECTION: Sections. -* separate directory, compilation in: Other Dir. -* sequence: Side Effects. -* sequential consistency on 88k: M88K Options. -* set: Side Effects. -* setjmp: Global Reg Vars. -* SETUP_FRAME_ADDRESSES: Frame Layout. -* SETUP_INCOMING_VARARGS: Varargs. -* set_attr: Tagging Insns. -* set_attr_alternative: Tagging Insns. -* SET_DEFAULT_TYPE_ATTRIBUTES: Misc. -* SET_DEST: Side Effects. -* SET_SRC: Side Effects. -* SFmode: Machine Modes. -* shared strings: Incompatibilities. -* shared VMS run time system: VMS Misc. -* SHARED_SECTION_ASM_OP: Sections. -* sharing of RTL components: Sharing. -* shift: Arithmetic. -* SHIFT_COUNT_TRUNCATED: Misc. -* SHORT_TYPE_SIZE: Type Layout. -* side effect in ?:: Conditionals. -* side effects, macro argument: Statement Exprs. -* side effects, order of evaluation: Non-bugs. -* signature: C++ Signatures. -* signature member function default implemention: C++ Signatures. -* signatures, C++: C++ Signatures. -* signed division: Arithmetic. -* signed maximum: Arithmetic. -* signed minimum: Arithmetic. -* SIGNED_CHAR_SPEC: Driver. -* sign_extend: Conversions. -* sign_extract: Bit Fields. -* SImode: Machine Modes. -* simple constraints: Simple Constraints. -* simplifications, arithmetic: Passes. -* sin: C Dialect Options. -* sizeof: Typeof. -* SIZE_TYPE: Type Layout. -* SLOW_BYTE_ACCESS: Costs. -* SLOW_UNALIGNED_ACCESS: Costs. -* SLOW_ZERO_EXTEND: Costs. -* smaller data references (88k): M88K Options. -* smaller data references (MIPS): MIPS Options. -* SMALL_REGISTER_CLASSES: Register Classes. -* smax: Arithmetic. -* smin: Arithmetic. -* SPARC options: SPARC Options. -* specified registers: Explicit Reg Vars. -* specifying compiler version and target machine: Target Options. -* specifying hardware config: Submodel Options. -* specifying machine version: Target Options. -* specifying registers for local variables: Local Reg Vars. -* speed of instructions: Costs. -* splitting instructions: Insn Splitting. -* sqrt: C Dialect Options. -* sqrt: Arithmetic. -* square root: Arithmetic. -* stack arguments: Stack Arguments. -* stack checks (29k): AMD29K Options. -* stack frame layout: Frame Layout. -* STACK_BOUNDARY: Storage Layout. -* STACK_DYNAMIC_OFFSET: Frame Layout. -* STACK_GROWS_DOWNWARD: Frame Layout. -* STACK_PARMS_IN_REG_PARM_AREA: Stack Arguments. -* STACK_POINTER_OFFSET: Frame Layout. -* STACK_POINTER_REGNUM: Frame Registers. -* stack_pointer_rtx: Frame Registers. -* STACK_REGS: Stack Registers. -* stage1: Installation. -* standard pattern names: Standard Names. -* STANDARD_EXEC_PREFIX: Driver. -* STANDARD_INCLUDE_DIR: Driver. -* STANDARD_STARTFILE_PREFIX: Driver. -* start files: Tools and Libraries. -* STARTFILE_SPEC: Driver. -* STARTING_FRAME_OFFSET: Frame Layout. -* statements inside expressions: Statement Exprs. -* static data in C++, declaring and defining: Static Definitions. -* STATIC_CHAIN: Frame Registers. -* STATIC_CHAIN_INCOMING: Frame Registers. -* STATIC_CHAIN_INCOMING_REGNUM: Frame Registers. -* STATIC_CHAIN_REGNUM: Frame Registers. -* STDC_VALUE: Run-time Target. -* storage layout: Storage Layout. -* storem bug (29k): AMD29K Options. -* STORE_FLAG_VALUE: Misc. -* strcmp: C Dialect Options. -* strcpy: C Dialect Options. -* strcpy: Storage Layout. -* strength-reduction: Passes. -* STRICT_ALIGNMENT: Storage Layout. -* strict_low_part: RTL Declarations. -* string constants: Incompatibilities. -* string constants vs newline: C Dialect Options. -* STRIP_NAME_ENCODING: Sections. -* strlen: C Dialect Options. -* structure passing (88k): M88K Options. -* structure value address: Aggregate Return. -* structures: Incompatibilities. -* structures, constructor expression: Constructors. -* structures, returning: Interface. -* STRUCTURE_SIZE_BOUNDARY: Storage Layout. -* STRUCT_VALUE: Aggregate Return. -* STRUCT_VALUE_INCOMING: Aggregate Return. -* STRUCT_VALUE_INCOMING_REGNUM: Aggregate Return. -* STRUCT_VALUE_REGNUM: Aggregate Return. -* stupid register allocation: Passes. -* submodel options: Submodel Options. -* subreg: Regs and Memory. -* SUBREG_PROMOTED_UNSIGNED_P: Flags. -* SUBREG_PROMOTED_VAR_P: Flags. -* SUBREG_REG: Regs and Memory. -* SUBREG_WORD: Regs and Memory. -* subscripting: Subscripting. -* subscripting and function values: Subscripting. -* subtype polymorphism, C++: C++ Signatures. -* SUCCESS_EXIT_CODE: Config. -* suffixes for C++ source: Invoking G++. -* Sun installation: Sun Install. -* suppressing warnings: Warning Options. -* surprises in C++: C++ Misunderstandings. -* SVr4: M88K Options. -* SWITCHES_NEED_SPACES: Driver. -* SWITCH_TAKES_ARG: Driver. -* symbolic label: Sharing. -* symbol_ref: Constants. -* SYMBOL_REF_FLAG: Flags. -* SYMBOL_REF_USED: Flags. -* syntax checking: Warning Options. -* synthesized methods, warning: Warning Options. -* SYSTEM_INCLUDE_DIR: Driver. -* sys_siglist: Config. -* tagging insns: Tagging Insns. -* tail recursion optimization: Passes. -* target description macros: Target Macros. -* target machine, specifying: Target Options. -* target options: Target Options. -* target specifications: Run-time Target. -* target-parameter-dependent code: Passes. -* TARGET_BELL: Type Layout. -* TARGET_BS: Type Layout. -* TARGET_CR: Type Layout. -* TARGET_EDOM: Library Calls. -* TARGET_FF: Type Layout. -* TARGET_FLOAT_FORMAT: Storage Layout. -* TARGET_MEM_FUNCTIONS: Library Calls. -* TARGET_NEWLINE: Type Layout. -* TARGET_OPTIONS: Run-time Target. -* TARGET_SWITCHES: Run-time Target. -* TARGET_TAB: Type Layout. -* TARGET_VERSION: Run-time Target. -* TARGET_VT: Type Layout. -* TCmode: Machine Modes. -* template debugging: Warning Options. -* template instantiation: Template Instantiation. -* temporaries, lifetime of: Temporaries. -* termination routines: Initialization. -* text_section: Sections. -* TEXT_SECTION_ASM_OP: Sections. -* TFmode: Machine Modes. -* thunks: Nested Functions. -* TImode: Machine Modes. -* TMPDIR: Environment Variables. -* top level of compiler: Passes. -* traditional C language: C Dialect Options. -* TRADITIONAL_RETURN_FLOAT: Scalar Return. -* trampolines for nested functions: Trampolines. -* TRAMPOLINE_ALIGNMENT: Trampolines. -* TRAMPOLINE_SECTION: Trampolines. -* TRAMPOLINE_SIZE: Trampolines. -* TRAMPOLINE_TEMPLATE: Trampolines. -* TRANSFER_FROM_TRAMPOLINE: Trampolines. -* TRULY_NOOP_TRUNCATION: Misc. -* truncate: Conversions. -* type abstraction, C++: C++ Signatures. -* type alignment: Alignment. -* typedef names as function parameters: Incompatibilities. -* typeof: Typeof. -* udiv: Arithmetic. -* UDIVDI3_LIBCALL: Library Calls. -* UDIVSI3_LIBCALL: Library Calls. -* Ultrix calling convention: Interoperation. -* umax: Arithmetic. -* umin: Arithmetic. -* umod: Arithmetic. -* UMODDI3_LIBCALL: Library Calls. -* UMODSI3_LIBCALL: Library Calls. -* unchanging: Flags. -* undefined behavior: Bug Criteria. -* undefined function value: Bug Criteria. -* underscores in variables in macros: Naming Types. -* underscores, avoiding (88k): M88K Options. -* union, casting to a: Cast to Union. -* unions: Incompatibilities. -* unions, returning: Interface. -* UNITS_PER_WORD: Storage Layout. -* UNKNOWN_FLOAT_FORMAT: Storage Layout. -* unreachable code: Passes. -* unresolved references and -nostdlib: Link Options. -* unshare_all_rtl: Sharing. -* unsigned division: Arithmetic. -* unsigned greater than: Comparisons. -* unsigned greater than: Comparisons. -* unsigned less than: Comparisons. -* unsigned less than: Comparisons. -* unsigned minimum and maximum: Arithmetic. -* unsigned_fix: Conversions. -* unsigned_float: Conversions. -* unspec: Side Effects. -* unspec_volatile: Side Effects. -* use: Side Effects. -* used: Flags. -* USER_LABEL_PREFIX: Instruction Output. -* USE_C_ALLOCA: Config. -* USE_PROTOTYPES: Config. -* USG: Config. -* VALID_MACHINE_ATTRIBUTE: Misc. -* value after longjmp: Global Reg Vars. -* values, returned by functions: Scalar Return. -* varargs implementation: Varargs. -* variable alignment: Alignment. -* variable attributes: Variable Attributes. -* variable number of arguments: Macro Varargs. -* variable-length array scope: Variable Length. -* variable-length arrays: Variable Length. -* variables in specified registers: Explicit Reg Vars. -* variables, local, in macros: Naming Types. -* Vax calling convention: Interoperation. -* VAX options: VAX Options. -* VAX_FLOAT_FORMAT: Storage Layout. -* VIRTUAL_INCOMING_ARGS_REGNUM: Regs and Memory. -* VIRTUAL_OUTGOING_ARGS_REGNUM: Regs and Memory. -* VIRTUAL_STACK_DYNAMIC_REGNUM: Regs and Memory. -* VIRTUAL_STACK_VARS_REGNUM: Regs and Memory. -* VMS: Config. -* VMS and case sensitivity: VMS Misc. -* VMS and include files: Include Files and VMS. -* VMS installation: VMS Install. -* void pointers, arithmetic: Pointer Arith. -* void, size of pointer to: Pointer Arith. -* VOIDmode: Machine Modes. -* volatil: Flags. -* volatile memory references: Flags. -* voting between constraint alternatives: Class Preferences. -* vprintf: Config. -* warning for enumeration conversions: Warning Options. -* warning for overloaded virtual fn: Warning Options. -* warning for reordering of member initializers: Warning Options. -* warning for synthesized methods: Warning Options. -* warning messages: Warning Options. -* warnings vs errors: Warnings and Errors. -* WCHAR_TYPE: Type Layout. -* WCHAR_TYPE_SIZE: Type Layout. -* which_alternative: Output Statement. -* whitespace: Incompatibilities. -* WORDS_BIG_ENDIAN: Storage Layout. -* word_mode: Machine Modes. -* WORD_REGISTER_OPERATIONS: Misc. -* WORD_SWITCH_TAKES_ARG: Driver. -* XCmode: Machine Modes. -* XCOFF_DEBUGGING_INFO: DBX Options. -* XEXP: Accessors. -* XFmode: Machine Modes. -* XINT: Accessors. -* xor: Arithmetic. -* XSTR: Accessors. -* XVEC: Accessors. -* XVECEXP: Accessors. -* XVECLEN: Accessors. -* XWINT: Accessors. -* zero division on 88k: M88K Options. -* zero-length arrays: Zero Length. -* zero_extend: Conversions. -* zero_extract: Bit Fields. -* \: Output Template. -* __bb_init_func: Profiling. -* __builtin_apply: Constructing Calls. -* __builtin_apply_args: Constructing Calls. -* __builtin_args_info: Varargs. -* __builtin_classify_type: Varargs. -* __builtin_next_arg: Varargs. -* __builtin_return: Constructing Calls. -* __builtin_saveregs: Varargs. -* __CTOR_LIST__: Initialization. -* __DTOR_LIST__: Initialization. -* __main: Collect2. +* Target Fragment:: Writing the `t-TARGET' file. +* Host Fragment:: Writing the `x-HOST' file. + + +File: gcc.info, Node: Target Fragment, Next: Host Fragment, Up: Fragments + +The Target Makefile Fragment +============================ + + The target makefile fragment, `t-TARGET', defines special target +dependent variables and targets used in the `Makefile': + +`LIBGCC1' + The rule to use to build `libgcc1.a'. If your target does not + need to use the functions in `libgcc1.a', set this to empty. + *Note Interface::. + +`CROSS_LIBGCC1' + The rule to use to build `libgcc1.a' when building a cross + compiler. If your target does not need to use the functions in + `libgcc1.a', set this to empty. *Note Cross Runtime::. + +`LIBGCC2_CFLAGS' + Compiler flags to use when compiling `libgcc2.c'. + +`LIB2FUNCS_EXTRA' + A list of source file names to be compiled or assembled and + inserted into `libgcc.a'. + +`CRTSTUFF_T_CFLAGS' + Special flags used when compiling `crtstuff.c'. *Note + Initialization::. + +`MULTILIB_OPTIONS' + For some targets, invoking GNU CC in different ways produces + objects that can not be linked together. For example, for some + targets GNU CC produces both big and little endian code. For + these targets, you must arrange for multiple versions of + `libgcc.a' to be compiled, one for each set of incompatible + options. When GNU CC invokes the linker, it arranges to link in + the right version of `libgcc.a', based on the command line options + used. + + The `MULTILIB_OPTIONS' macro lists the set of options for which + special versions of `libgcc.a' must be built. Write options that + are mutually incompatible side by side, separated by a slash. + Write options that may be used together separated by a space. The + build procedure will build all combinations of compatible options. + + For example, if you set `MULTILIB_OPTIONS' to `m68000/m68020 + msoft-float', `Makefile' will build special versions of `libgcc.a' + using the options `-m68000', `-m68020', `-msoft-float', `-m68000 + -msoft-float', and `-m68020 -msoft-float'. + +`MULTILIB_DIRNAMES' + If `MULTILIB_OPTIONS' is used, this variable specifies the + directory names that should be used to hold the various libraries. + Write one element in `MULTILIB_DIRNAMES' for each element in + `MULTILIB_OPTIONS'. If `MULTILIB_DIRNAMES' is not used, the + default value will be `MULTILIB_OPTIONS', with all slashes treated + as spaces. + + For example, if `MULTILIB_OPTIONS' is `m68000/m68020 msoft-float', + then the default value of `MULTILIB_DIRNAMES' is `m68000 m68020 + msoft-float'. You may specify a different value if you desire a + different set of directory names. + +`MULTILIB_MATCHES' + Sometimes the same option may be written in two different ways. + If an option is listed in `MULTILIB_OPTIONS', GNU CC needs to know + about any synonyms. In that case, set `MULTILIB_MATCHES' to a + list of items of the form `option=option' to describe all relevant + synonyms. For example, `m68000=mc68000 m68020=mc68020'. + + +File: gcc.info, Node: Host Fragment, Prev: Target Fragment, Up: Fragments + +The Host Makefile Fragment +========================== + + The host makefile fragment, `x-HOST', defines special host dependent +variables and targets used in the `Makefile': + +`CC' + The compiler to use when building the first stage. + +`CLIB' + Additional host libraries to link with. + +`OLDCC' + The compiler to use when building `libgcc1.a' for a native + compilation. + +`OLDAR' + The version of `ar' to use when building `libgcc1.a' for a native + compilation. +`INSTALL' + The install program to use.