--- gcc/gcc.info-17 2018/04/24 17:51:23 1.1.1.1 +++ gcc/gcc.info-17 2018/04/24 18:07:30 1.1.1.5 @@ -1,1617 +1,1005 @@ -This is Info file gcc.info, produced by Makeinfo-1.43 from the input +This is Info file gcc.info, produced by Makeinfo-1.54 from the input file gcc.texi. This file documents the use and the internals of the GNU compiler. - Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc. + Published by the Free Software Foundation 675 Massachusetts Avenue +Cambridge, MA 02139 USA - Permission is granted to make and distribute verbatim copies of -this manual provided the copyright notice and this permission notice -are preserved on all copies. + Copyright (C) 1988, 1989, 1992, 1993 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 +preserved on all copies. Permission is granted to copy and distribute modified versions of this manual under the conditions for verbatim copying, provided also -that the section entitled "GNU General Public License" is included -exactly as in the original, and provided that the entire resulting -derived work is distributed under the terms of a permission notice -identical to this one. +that the sections entitled "GNU General Public License" and "Protect +Your Freedom--Fight `Look And Feel'" are included exactly as in the +original, and provided that the entire resulting derived work is +distributed under the terms of a permission notice identical to this +one. Permission is granted to copy and distribute translations of this manual into another language, under the above conditions for modified -versions, except that the section entitled "GNU General Public -License" and this permission notice may be included in translations -approved by the Free Software Foundation instead of in the original -English. +versions, except that the sections entitled "GNU General Public +License" and "Protect Your Freedom--Fight `Look And Feel'", and this +permission notice, may be included in translations approved by the Free +Software Foundation instead of in the original English. + + +File: gcc.info, Node: Obsolete Register Macros, Prev: Stack Registers, Up: Registers + +Obsolete Macros for Controlling Register Usage +---------------------------------------------- + + These features do not work very well. They exist because they used +to be required to generate correct code for the 80387 coprocessor of the +80386. They are no longer used by that machine description and may be +removed in a later version of the compiler. Don't use them! + +`OVERLAPPING_REGNO_P (REGNO)' + If defined, this is a C expression whose value is nonzero if hard + register number REGNO is an overlapping register. This means a + hard register which overlaps a hard register with a different + number. (Such overlap is undesirable, but occasionally it allows + a machine to be supported which otherwise could not be.) This + macro must return nonzero for *all* the registers which overlap + each other. GNU CC can use an overlapping register only in + certain limited ways. It can be used for allocation within a + basic block, and may be spilled for reloading; that is all. + + If this macro is not defined, it means that none of the hard + registers overlap each other. This is the usual situation. + +`INSN_CLOBBERS_REGNO_P (INSN, REGNO)' + If defined, this is a C expression whose value should be nonzero if + the insn INSN has the effect of mysteriously clobbering the + contents of hard register number REGNO. By "mysterious" we mean + that the insn's RTL expression doesn't describe such an effect. + + If this macro is not defined, it means that no insn clobbers + registers mysteriously. This is the usual situation; all else + being equal, it is best for the RTL expression to show all the + activity. + +`PRESERVE_DEATH_INFO_REGNO_P (REGNO)' + If defined, this is a C expression whose value is nonzero if + accurate `REG_DEAD' notes are needed for hard register number REGNO + at the time of outputting the assembler code. When this is so, a + few optimizations that take place after register allocation and + could invalidate the death notes are not done when this register is + involved. + + You would arrange to preserve death info for a register when some + of the code in the machine description which is executed to write + the assembler code looks at the death notes. This is necessary + only when the actual hardware feature which GNU CC thinks of as a + register is not actually a register of the usual sort. (It might, + for example, be a hardware stack.) + + If this macro is not defined, it means that no death notes need to + be preserved. This is the usual situation.  -File: gcc.info, Node: Index, Prev: Config, Up: Top +File: gcc.info, Node: Register Classes, Next: Stack and Calling, Prev: Registers, Up: Target Macros -Index -***** +Register Classes +================ + + On many machines, the numbered registers are not all equivalent. +For example, certain registers may not be allowed for indexed +addressing; certain registers may not be allowed in some instructions. +These machine restrictions are described to the compiler using +"register classes". + + You define a number of register classes, giving each one a name and +saying which of the registers belong to it. Then you can specify +register classes that are allowed as operands to particular instruction +patterns. + + In general, each register will belong to several classes. In fact, +one class must be named `ALL_REGS' and contain all the registers. +Another class must be named `NO_REGS' and contain no registers. Often +the union of two classes will be another class; however, this is not +required. + + One of the classes must be named `GENERAL_REGS'. There is nothing +terribly special about the name, but the operand constraint letters `r' +and `g' specify this class. If `GENERAL_REGS' is the same as +`ALL_REGS', just define it as a macro which expands to `ALL_REGS'. + + Order the classes so that if class X is contained in class Y then X +has a lower class number than Y. + + The way classes other than `GENERAL_REGS' are specified in operand +constraints is through machine-dependent operand constraint letters. +You can define such letters to correspond to various classes, then use +them in operand constraints. + + You should define a class for the union of two classes whenever some +instruction allows both classes. For example, if an instruction allows +either a floating point (coprocessor) register or a general register +for a certain operand, you should define a class `FLOAT_OR_GENERAL_REGS' +which includes both of them. Otherwise you will get suboptimal code. + + You must also specify certain redundant information about the +register classes: for each class, which classes contain it and which +ones are contained in it; for each pair of classes, the largest class +contained in their union. + + When a value occupying several consecutive registers is expected in a +certain class, all the registers used must belong to that class. +Therefore, register classes cannot be used to enforce a requirement for +a register pair to start with an even-numbered register. The way to +specify this requirement is with `HARD_REGNO_MODE_OK'. + + Register classes used for input-operands of bitwise-and or shift +instructions have a special requirement: each such class must have, for +each fixed-point machine mode, a subclass whose registers can transfer +that mode to or from memory. For example, on some machines, the +operations for single-byte values (`QImode') are limited to certain +registers. When this is so, each register class that is used in a +bitwise-and or shift instruction must have a subclass consisting of +registers from which single-byte values can be loaded or stored. This +is so that `PREFERRED_RELOAD_CLASS' can always have a possible value to +return. + +`enum reg_class' + An enumeral type that must be defined with all the register class + names as enumeral values. `NO_REGS' must be first. `ALL_REGS' + must be the last register class, followed by one more enumeral + value, `LIM_REG_CLASSES', which is not a register class but rather + tells how many classes there are. + + Each register class has a number, which is the value of casting + the class name to type `int'. The number serves as an index in + many of the tables described below. + +`N_REG_CLASSES' + The number of distinct register classes, defined as follows: + + #define N_REG_CLASSES (int) LIM_REG_CLASSES + +`REG_CLASS_NAMES' + An initializer containing the names of the register classes as C + string constants. These names are used in writing some of the + debugging dumps. + +`REG_CLASS_CONTENTS' + An initializer containing the contents of the register classes, as + integers which are bit masks. The Nth integer specifies the + contents of class N. The way the integer MASK is interpreted is + that register R is in the class if `MASK & (1 << R)' is 1. + + When the machine has more than 32 registers, an integer does not + suffice. Then the integers are replaced by sub-initializers, + braced groupings containing several integers. Each + sub-initializer must be suitable as an initializer for the type + `HARD_REG_SET' which is defined in `hard-reg-set.h'. + +`REGNO_REG_CLASS (REGNO)' + A C expression whose value is a register class containing hard + register REGNO. In general there is more than one such class; + choose a class which is "minimal", meaning that no smaller class + also contains the register. + +`BASE_REG_CLASS' + A macro whose definition is the name of the class to which a valid + base register must belong. A base register is one used in an + address which is the register value plus a displacement. + +`INDEX_REG_CLASS' + A macro whose definition is the name of the class to which a valid + index register must belong. An index register is one used in an + address where its value is either multiplied by a scale factor or + added to another register (as well as added to a displacement). + +`REG_CLASS_FROM_LETTER (CHAR)' + A C expression which defines the machine-dependent operand + constraint letters for register classes. If CHAR is such a + letter, the value should be the register class corresponding to + it. Otherwise, the value should be `NO_REGS'. The register + letter `r', corresponding to class `GENERAL_REGS', will not be + passed to this macro; you do not need to handle it. + +`REGNO_OK_FOR_BASE_P (NUM)' + A C expression which is nonzero if register number NUM is suitable + for use as a base register in operand addresses. It may be either + a suitable hard register or a pseudo register that has been + allocated such a hard register. + +`REGNO_OK_FOR_INDEX_P (NUM)' + A C expression which is nonzero if register number NUM is suitable + for use as an index register in operand addresses. It may be + either a suitable hard register or a pseudo register that has been + allocated such a hard register. + + The difference between an index register and a base register is + that the index register may be scaled. If an address involves the + sum of two registers, neither one of them scaled, then either one + may be labeled the "base" and the other the "index"; but whichever + labeling is used must fit the machine's constraints of which + registers may serve in each capacity. The compiler will try both + labelings, looking for one that is valid, and will reload one or + both registers only if neither labeling works. + +`PREFERRED_RELOAD_CLASS (X, CLASS)' + A C expression that places additional restrictions on the register + class to use when it is necessary to copy value X into a register + in class CLASS. The value is a register class; perhaps CLASS, or + perhaps another, smaller class. On many machines, the following + definition is safe: + + #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS + + Sometimes returning a more restrictive class makes better code. + For example, on the 68000, when X is an integer constant that is + in range for a `moveq' instruction, the value of this macro is + always `DATA_REGS' as long as CLASS includes the data registers. + Requiring a data register guarantees that a `moveq' will be used. + + If X is a `const_double', by returning `NO_REGS' you can force X + into a memory constant. This is useful on certain machines where + immediate floating values cannot be loaded into certain kinds of + registers. + +`PREFERRED_OUTPUT_RELOAD_CLASS (X, CLASS)' + Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of + input reloads. If you don't define this macro, the default is to + use CLASS, unchanged. + +`LIMIT_RELOAD_CLASS (MODE, CLASS)' + A C expression that places additional restrictions on the register + class to use when it is necessary to be able to hold a value of + mode MODE in a reload register for which class CLASS would + ordinarily be used. + + Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when + there are certain modes that simply can't go in certain reload + classes. + + The value is a register class; perhaps CLASS, or perhaps another, + smaller class. + + Don't define this macro unless the target machine has limitations + which require the macro to do something nontrivial. + +`SECONDARY_RELOAD_CLASS (CLASS, MODE, X)' +`SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)' +`SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)' + Many machines have some registers that cannot be copied directly + to or from memory or even from other types of registers. An + example is the `MQ' register, which on most machines, can only be + copied to or from general registers, but not memory. Some + machines allow copying all registers to and from memory, but + require a scratch register for stores to some memory locations + (e.g., those with symbolic address on the RT, and those with + certain symbolic address on the Sparc when compiling PIC). In + some cases, both an intermediate and a scratch register are + required. + + You should define these macros to indicate to the reload phase + that it may need to allocate at least one register for a reload in + addition to the register to contain the data. Specifically, if + copying X to a register CLASS in MODE requires an intermediate + register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to + return the largest register class all of whose registers can be + used as intermediate registers or scratch registers. + + If copying a register CLASS in MODE to X requires an intermediate + or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be + defined to return the largest register class required. If the + requirements for input and output reloads are the same, the macro + `SECONDARY_RELOAD_CLASS' should be used instead of defining both + macros identically. + + The values returned by these macros are often `GENERAL_REGS'. + Return `NO_REGS' if no spare register is needed; i.e., if X can be + directly copied to or from a register of CLASS in MODE without + requiring a scratch register. Do not define this macro if it + would always return `NO_REGS'. + + If a scratch register is required (either with or without an + intermediate register), you should define patterns for + `reload_inM' or `reload_outM', as required (*note Standard + Names::.. These patterns, which will normally be implemented with + a `define_expand', should be similar to the `movM' patterns, + except that operand 2 is the scratch register. + + Define constraints for the reload register and scratch register + that contain a single register class. If the original reload + register (whose class is CLASS) can meet the constraint given in + the pattern, the value returned by these macros is used for the + class of the scratch register. Otherwise, two additional reload + registers are required. Their classes are obtained from the + constraints in the insn pattern. + + X might be a pseudo-register or a `subreg' of a pseudo-register, + which could either be in a hard register or in memory. Use + `true_regnum' to find out; it will return -1 if the pseudo is in + memory and the hard register number if it is in a register. + + These macros should not be used in the case where a particular + class of registers can only be copied to memory and not to another + class of registers. In that case, secondary reload registers are + not needed and would not be helpful. Instead, a stack location + must be used to perform the copy and the `movM' pattern should use + memory as a intermediate storage. This case often occurs between + floating-point and general registers. + +`SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)' + Certain machines have the property that some registers cannot be + copied to some other registers without using memory. Define this + macro on those machines to be a C expression that is non-zero if + objects of mode M in registers of CLASS1 can only be copied to + registers of class CLASS2 by storing a register of CLASS1 into + memory and loading that memory location into a register of CLASS2. + + Do not define this macro if its value would always be zero. + +`SECONDARY_MEMORY_NEEDED_RTX (MODE)' + Normally, when `SECONDARY_MEMORY_NEEDED' is defined, the compiler + will allocate a stack slot when a memory location for a register + copy is needed. If this macro is defined, the compiler instead + uses the memory location defined by this macro. + +`SMALL_REGISTER_CLASSES' + Normally the compiler will avoid choosing spill registers from + registers that have been explicitly mentioned in the rtl (these + registers are normally those used to pass parameters and return + values). However, some machines have so few registers of certain + classes that there would not be enough registers to use as spill + registers if this were done. + + You should define `SMALL_REGISTER_CLASSES' on those machines. When + it is defined, the compiler allows registers explicitly used in + the rtl to be used as spill registers but prevents the compiler + from extending the lifetime of these registers. + + Defining this macro is always safe, but unnecessarily defining + this macro will reduce the amount of optimizations that can be + performed in some cases. If this macro is not defined but needs + to be, the compiler will run out of reload registers and print a + fatal error message. + + For most machines, this macro should not be defined. + +`CLASS_LIKELY_SPILLED_P (CLASS)' + A C expression whose value is nonzero if pseudos that have been + assigned to registers of class CLASS would likely be spilled + because registers of CLASS are needed for spill registers. + + The default value of this macro returns 1 if CLASS has exactly one + register and zero otherwise. On most machines, this default + should be used. Only define this macro to some other expression + if pseudo allocated by `local-alloc.c' end up in memory because + their hard registers were needed for spill regisers. If this + macro returns nonzero for those classes, those pseudos will only + be allocated by `global.c', which knows how to reallocate the + pseudo to another register. If there would not be another + register available for reallocation, you should not change the + definition of this macro since the only effect of such a + definition would be to slow down register allocation. + +`CLASS_MAX_NREGS (CLASS, MODE)' + A C expression for the maximum number of consecutive registers of + class CLASS needed to hold a value of mode MODE. + + This is closely related to the macro `HARD_REGNO_NREGS'. In fact, + the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be + the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' for all + REGNO values in the class CLASS. + + This macro helps control the handling of multiple-word values in + the reload pass. + + Three other special macros describe which operands fit which +constraint letters. + +`CONST_OK_FOR_LETTER_P (VALUE, C)' + A C expression that defines the machine-dependent operand + constraint letters that specify particular ranges of integer + values. If C is one of those letters, the expression should check + that VALUE, an integer, is in the appropriate range and return 1 + if so, 0 otherwise. If C is not one of those letters, the value + should be 0 regardless of VALUE. + +`CONST_DOUBLE_OK_FOR_LETTER_P (VALUE, C)' + A C expression that defines the machine-dependent operand + constraint letters that specify particular ranges of + `const_double' values. + + If C is one of those letters, the expression should check that + VALUE, an RTX of code `const_double', is in the appropriate range + and return 1 if so, 0 otherwise. If C is not one of those + letters, the value should be 0 regardless of VALUE. + + `const_double' is used for all floating-point constants and for + `DImode' fixed-point constants. A given letter can accept either + or both kinds of values. It can use `GET_MODE' to distinguish + between these kinds. + +`EXTRA_CONSTRAINT (VALUE, C)' + A C expression that defines the optional machine-dependent + constraint letters that can be used to segregate specific types of + operands, usually memory references, for the target machine. + Normally this macro will not be defined. If it is required for a + particular target machine, it should return 1 if VALUE corresponds + to the operand type represented by the constraint letter C. If C + is not defined as an extra constraint, the value returned should + be 0 regardless of VALUE. + + For example, on the ROMP, load instructions cannot have their + output in r0 if the memory reference contains a symbolic address. + Constraint letter `Q' is defined as representing a memory address + that does *not* contain a symbolic address. An alternative is + specified with a `Q' constraint on the input and `r' on the + output. The next alternative specifies `m' on the input and a + register class that does not include r0 on the output. + + +File: gcc.info, Node: Stack and Calling, Next: Varargs, Prev: Register Classes, Up: Target Macros + +Stack Layout and Calling Conventions +==================================== * Menu: -* #pragma: Misc. -* $: Dollar Signs. -* ': Incompatibilities. -* (nil): RTL Objects. -* 3b1 installation: 3b1 Install. -* ?: side effect: Conditionals. -* #pragma, reason for not using: Function Attributes. -* * in template: Output Statement. -* ?: extensions: Conditionals. -* ?: extensions: Lvalues. -* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry. -* ARG_POINTER_REGNUM and virtual registers: Regs and Memory. -* BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields. -* BLKmode, and function return values: Calls. -* ENCODE_SECTION_INFO and address validation: Addressing Modes. -* ENCODE_SECTION_INFO usage: Instruction Output. -* FIRST_PARM_OFFSET and virtual registers: Regs and Memory. -* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory. -* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory. -* FUNCTION_EPILOGUE and trampolines: Trampolines. -* FUNCTION_PROLOGUE and trampolines: Trampolines. -* HImode, in insn: Insns. -* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments. -* PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout. -* QImode, in insn: Insns. -* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments. -* 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. -* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections. -* WORDS_BIG_ENDIAN, effect on subreg: Regs and Memory. -* absM2 instruction pattern: Standard Names. -* abs and attributes: Expressions. -* addM3 instruction pattern: Standard Names. -* addr_diff_vec, length of: Insn Lengths. -* addr_vec, length of: Insn Lengths. -* alloca and SunOs: Installation. -* alloca vs variable-length arrays: Variable Length. -* alloca, for SunOs: Sun Install. -* alloca, for Unos: Unos Install. -* andM3 instruction pattern: Standard Names. -* and and attributes: Expressions. -* and, canonicalization of: Insn Canonicalizations. -* 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. -* 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. -* define_insn example: Example. -* divM3 instruction pattern: Standard Names. -* divmodM4 instruction pattern: Standard Names. -* div and attributes: Expressions. -* eq and attributes: Expressions. -* extendMN instruction pattern: Standard Names. -* extv instruction pattern: Standard Names. -* extzv instruction pattern: Standard Names. -* ffsM2 instruction pattern: Standard Names. -* fixMN2 instruction pattern: Standard Names. -* fix_truncMN2 instruction pattern: Standard Names. -* fixunsMN2 instruction pattern: Standard Names. -* fixuns_truncMN2 instruction pattern: Standard Names. -* floatMN2 instruction pattern: Standard Names. -* floatunsMN2 instruction pattern: Standard Names. -* float as function value type: Incompatibilities. -* fscanf, and constant strings: Incompatibilities. -* ftruncM2 instruction pattern: Standard Names. -* genflags, crash on Sun 4: Trouble. -* geu and attributes: Expressions. -* ge and attributes: Expressions. -* gprof: Debugging Options. -* gtu and attributes: Expressions. -* gt and attributes: Expressions. -* if_then_else and attributes: Expressions. -* if_then_else usage: Side Effects. -* 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. -* indirect_jump instruction pattern: Standard Names. -* 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. -* 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. -* long long data types: Long Long. -* longjmp and automatic variables: Interface. -* longjmp and automatic variables: Dialect Options. -* longjmp incompatibilities: Incompatibilities. -* longjmp warnings: Warning Options. -* lshiftrt and attributes: Expressions. -* lshift and attributes: Expressions. -* lshlM3 instruction pattern: Standard Names. -* 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. -* 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. -* negM2 instruction pattern: Standard Names. -* neg and attributes: Expressions. -* neg, canonicalization of: Insn Canonicalizations. -* ne and attributes: Expressions. -* nop instruction pattern: Standard Names. -* not and attributes: Expressions. -* not, canonicalization of: Insn Canonicalizations. -* one_cmplM2 instruction pattern: Standard Names. -* pc and attributes: Insn Lengths. -* pc, RTL sharing: Sharing. -* plus and attributes: Expressions. -* plus, canonicalization of: Insn Canonicalizations. -* prof: Debugging Options. -* qsort, and global register variables: Global Reg Vars. -* reg and /i: Flags. -* reg and /s: Flags. -* reg and /u: Flags. -* reg and /v: Flags. -* reg, RTL sharing: Sharing. -* return instruction pattern: Standard Names. -* rotlM3 instruction pattern: Standard Names. -* rotrM3 instruction pattern: Standard Names. -* sCOND instruction pattern: Standard Names. -* scanf, and constant strings: Incompatibilities. -* scratch, RTL sharing: Sharing. -* setjmp incompatibilities: Incompatibilities. -* sign_extract, canonicalization of: Insn Canonicalizations. -* sqrtM2 instruction pattern: Standard Names. -* sscanf, and constant strings: Incompatibilities. -* subM3 instruction pattern: Standard Names. -* subreg, in strict_low_part: RTL Declarations. -* subreg, special reload handling: Regs and Memory. -* 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 symbol_ref: Flags. -* 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. -* xorM3 instruction pattern: Standard Names. -* xor, canonicalization of: Insn Canonicalizations. -* zero_extendMN instruction pattern: Standard Names. -* zero_extract, canonicalization of: Insn Canonicalizations. -* VAXCRTL: VMS Misc. -* libgcc.a: Library Calls. -* stdarg.h and RT PC: RT Options. -* stdarg.h and register arguments: Register Arguments. -* tm.h macros: Machine Macros. -* varargs.h and RT PC: RT Options. -* 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. -* E in constraint: Simple Constraints. -* F in constraint: Simple Constraints. -* G in constraint: Simple Constraints. -* H in constraint: Simple Constraints. -* I in constraint: Simple Constraints. -* Q, in constraint: Simple Constraints. -* V in constraint: Simple Constraints. -* X in constraint: Simple Constraints. -* _ in variables in macros: Naming Types. -* d in constraint: Simple Constraints. -* g 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. -* r in constraint: Simple Constraints. -* s in constraint: Simple Constraints. -* ACCUMULATE_OUTGOING_ARGS: Stack Arguments. -* ADDITIONAL_REGISTER_NAMES: Instruction Output. -* ADDRESS_COST: Costs. -* ADJUST_INSN_LENGTH: Insn Lengths. -* ALLOCATE_TRAMPOLINE: Trampolines. -* ALL_REGS: Register Classes. -* AMD29K options: AMD29K Options. -* ANSI support: Dialect Options. -* ARGS_GROW_DOWNWARD: Frame Layout. -* ARG_POINTER_REGNUM: Frame Registers. -* 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_FORMAT_PRIVATE_NAME: Label Output. -* ASM_GENERATE_INTERNAL_LABEL: Label Output. -* ASM_GLOBALIZE_LABEL: Label Output. -* ASM_IDENTIFY_GCC: File Framework. -* 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: Constructor Output. -* ASM_OUTPUT_DESTRUCTOR: Constructor Output. -* 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_LABELREF_AS_INT: 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_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: Debugging Info. -* ASM_STABN_OP: Debugging Info. -* ASM_STABS_OP: Debugging Info. -* Alliant: Incompatibilities. -* BASE_REG_CLASS: Register Classes. -* BIGGEST_ALIGNMENT: Storage Layout. -* BIGGEST_FIELD_ALIGNMENT: Storage Layout. -* BITFIELD_NBYTES_LIMITED: Storage Layout. -* BITS_BIG_ENDIAN: Storage Layout. -* BITS_PER_UNIT: Storage Layout. -* BITS_PER_WORD: Storage Layout. -* BLKmode: Machine Modes. -* BLOCK_PROFILER: Profiling. -* BRANCH_COST: Costs. -* BYTES_BIG_ENDIAN: Storage Layout. -* BYTE_LOADS_ZERO_EXTEND: Misc. -* Bison parser generator: Installation. -* C language extensions: Extensions. -* C language, traditional: Dialect Options. -* C statements for assembler output: Output Statement. -* C++_INCLUDE_PATH: Environment Variables. -* CALLER_SAVE_PROFITABLE: Caller Saves. -* CALL_USED_REGISTERS: Register Basics. -* CAN_ELIMINATE: Elimination. -* CASE_DROPS_THROUGH: Misc. -* CASE_VECTOR_MODE: Misc. -* CASE_VECTOR_PC_RELATIVE: Misc. -* CC1PLUS_SPEC: Driver. -* CC1_SPEC: Driver. -* CC_STATUS_MDEP: Condition Code. -* CC_STATUS_MDEP_INIT: Condition Code. -* CCmode: Machine Modes. -* CHAR_TYPE_SIZE: Type Layout. -* CHECK_FLOAT_VALUE: Storage Layout. -* CLASS_MAX_NREGS: Register Classes. -* CODE_LABEL_NUMBER: Insns. -* COMPILER_PATH: Environment Variables. -* CONDITIONAL_REGISTER_USAGE: Register Basics. -* CONST0_RTX: Constants. -* CONST1_RTX: Constants. -* CONST2_RTX: Constants. -* CONSTANT_ADDRESS_P: Addressing Modes. -* CONSTANT_ALIGNMENT: Storage Layout. -* CONSTANT_P: Addressing Modes. -* CONSTANT_POOL_ADDRESS_P: Flags. -* CONST_CALL_P: Flags. -* CONST_COSTS: Costs. -* CONST_DOUBLE_CHAIN: Constants. -* CONST_DOUBLE_LOW: Constants. -* CONST_DOUBLE_MEM: Constants. -* CONST_DOUBLE_OK_FOR_LETTER_P: Register Classes. -* CONST_OK_FOR_LETTER_P: Register Classes. -* COSTS_N_INSNS: Costs. -* CPP_PREDEFINES: Run-time Target. -* CPP_SPEC: Driver. -* CUMULATIVE_ARGS: Register Arguments. -* C_INCLUDE_PATH: Environment Variables. -* Convex options: Convex Options. -* DATA_ALIGNMENT: Storage Layout. -* DATA_SECTION_ASM_OP: Sections. -* DBR_OUTPUT_SEQEND: Instruction Output. -* DBX: Incompatibilities. -* DBX_CONTIN_CHAR: Debugging Info. -* DBX_CONTIN_LENGTH: Debugging Info. -* DBX_DEBUGGING_INFO: Debugging Info. -* DBX_FUNCTION_FIRST: Debugging Info. -* DBX_LBRAC_FIRST: Debugging Info. -* DBX_NO_XREFS: Debugging Info. -* DBX_OUTPUT_FUNCTION_END: Debugging Info. -* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY: Debugging Info. -* DBX_OUTPUT_MAIN_SOURCE_FILENAME: Debugging Info. -* DBX_OUTPUT_MAIN_SOURCE_FILE_END: Debugging Info. -* DBX_OUTPUT_SOURCE_FILENAME: Debugging Info. -* DBX_OUTPUT_STANDARD_TYPES: Debugging Info. -* DBX_REGISTER_NUMBER: Debugging Info. -* DBX_STATIC_STAB_DATA_SECTION: Debugging Info. -* DCmode: Machine Modes. -* DEBUGGER_ARG_OFFSET: Debugging Info. -* DEBUGGER_AUTO_OFFSET: Debugging Info. -* DEBUG_SYMS_TEXT: Debugging Info. -* DEFAULT_CALLER_SAVES: Caller Saves. -* DEFAULT_GDB_EXTENSIONS: Debugging Info. -* DEFAULT_MAIN_RETURN: Misc. -* DEFAULT_SHORT_ENUMS: Type Layout. -* DEFAULT_SIGNED_CHAR: Type Layout. -* DELAY_SLOTS_FOR_EPILOGUE: Function Entry. -* DEPENDENCIES_OUTPUT: Environment Variables. -* DFmode: Machine Modes. -* DIVDI3_LIBCALL: Library Calls. -* DIVSI3_LIBCALL: Library Calls. -* DImode: Machine Modes. -* DOLLARS_IN_IDENTIFIERS: Misc. -* DONE: Expander Definitions. -* DONT_REDUCE_ADDR: Costs. -* DOUBLE_TYPE_SIZE: Type Layout. -* DWARF_DEBUGGING_INFO: Debugging Info. -* DYNAMIC_CHAIN_ADDRESS: Frame Layout. -* De Morgan's law: Insn Canonicalizations. -* Dependent Patterns: Dependent Patterns. -* EASY_DIV_EXPR: Misc. -* ELIGIBLE_FOR_EPILOGUE_DELAY: Function Entry. -* ELIMINABLE_REGS: Elimination. -* EMPTY_FIELD_BOUNDARY: Storage Layout. -* ENCODE_SECTION_INFO: Sections. -* ENDFILE_SPEC: Driver. -* EXECUTABLE_SUFFIX: Config. -* EXIT_BODY: Misc. -* EXIT_IGNORE_STACK: Function Entry. -* EXPAND_BUILTIN_SAVEREGS: Varargs. -* EXTRA_CC_MODES: Condition Code. -* EXTRA_CC_NAMES: Condition Code. -* EXTRA_CONSTRAINT: Register Classes. -* EXTRA_SECTIONS: Sections. -* EXTRA_SECTION_FUNCTIONS: Sections. -* FAIL: Expander Definitions. -* FAILURE_EXIT_CODE: Config. -* FINALIZE_PIC: PIC. -* FINAL_PRESCAN_INSN: 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. -* FIXED_REGISTERS: Register Basics. -* FIXUNS_TRUNC_LIKE_FIX_TRUNC: Misc. -* FLOATIFY: Library Calls. -* FLOAT_ARG_TYPE: Library Calls. -* FLOAT_TYPE_SIZE: Type Layout. -* FLOAT_VALUE_TYPE: Library Calls. -* FRAME_GROWS_DOWNWARD: Frame Layout. -* FRAME_POINTER_REGNUM: Frame Registers. -* FRAME_POINTER_REQUIRED: Elimination. -* FUNCTION_ARG: Register Arguments. -* FUNCTION_ARG_ADVANCE: Register Arguments. -* FUNCTION_ARG_BOUNDARY: 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. -* GCC_EXEC_PREFIX: Environment Variables. -* GENERAL_REGS: Register Classes. -* GET_CLASS_NARROWEST_MODE: Machine Modes. -* GET_CODE: RTL Objects. -* 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. -* GLOBALDEF: Global Declarations. -* GLOBALREF: Global Declarations. -* GLOBALVALUEDEF: Global Declarations. -* GLOBALVALUEREF: Global Declarations. -* GNU CC and portability: Portability. -* GNU CC command options: Invoking GCC. -* GNU extensions to the C language: Extensions. -* GO_IF_LEGITIMATE_ADDRESS: Addressing Modes. -* GO_IF_MODE_DEPENDENT_ADDRESS: Addressing Modes. -* HANDLE_PRAGMA: Misc. -* HARD_REGNO_MODE_OK: Values in Registers. -* HARD_REGNO_NREGS: Values in Registers. -* HAVE_ATEXIT: Misc. -* HAVE_POST_DECREMENT: Addressing Modes. -* HAVE_POST_INCREMENT: Addressing Modes. -* HAVE_PRE_DECREMENT: Addressing Modes. -* HAVE_PRE_INCREMENT: Addressing Modes. -* HAVE_VPRINTF: Misc. -* 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_WORDS_BIG_ENDIAN: Config. -* IBM RS/6000 Options: RS/6000 Options. -* IBM RT PC: Incompatibilities. -* IBM RT options: RT Options. -* IEEE_FLOAT_FORMAT: Storage Layout. -* IMMEDIATE_PREFIX: Instruction Output. -* IMPLICIT_FIX_EXPR: Misc. -* INCLUDE_DEFAULTS: Driver. -* INDEX_REG_CLASS: Register Classes. -* 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. -* 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_UID: Insns. -* INTEGRATE_THRESHOLD: Misc. -* INTIFY: Library Calls. -* INT_TYPE_SIZE: Type Layout. -* Interdependence of Patterns: Dependent Patterns. -* JUMP_LABEL: Insns. -* JUMP_TABLES_IN_TEXT_SECTION: Sections. -* LABEL_NUSES: Insns. -* LABEL_OUTSIDE_LOOP_P: Flags. -* LABEL_PRESERVE_P: Flags. -* LAST_STACK_REG: Stack Registers. -* LAST_VIRTUAL_REGISTER: Regs and Memory. -* LEAF_REGISTERS: Leaf Functions. -* LEAF_REG_REMAP: Leaf Functions. -* LEGITIMATE_CONSTANT_P: Addressing Modes. -* LEGITIMATE_PIC_OPERAND_P: Addressing Modes. -* LEGITIMIZE_ADDRESS: Addressing Modes. -* LIBCALL_VALUE: Scalar Return. -* LIBGCC_NEEDS_DOUBLE: Library Calls. -* LIBRARY_PATH: Environment Variables. -* LIB_SPEC: Driver. -* LIMIT_RELOAD_CLASS: Register Classes. -* LINK_LIBGCC_SPECIAL: Driver. -* LINK_SPEC: Driver. -* LOCAL_INCLUDE_DIR: Driver. -* LOCAL_LABEL_PREFIX: Instruction Output. -* LOG_LINKS: Insns. -* LONGJMP_RESTORE_FROM_STACK: Elimination. -* LONG_DOUBLE_TYPE_SIZE: Type Layout. -* LONG_LONG_TYPE_SIZE: Type Layout. -* LONG_TYPE_SIZE: Type Layout. -* Libraries: Link Options. -* M680x0 options: M680x0 Options. -* M88k options: M88K Options. -* MAX_BITS_PER_WORD: Storage Layout. -* MAX_FIXED_MODE_SIZE: Storage Layout. -* MAX_OFILE_ALIGNMENT: Storage Layout. -* MAX_REGS_PER_ADDRESS: Addressing Modes. -* MD_EXEC_PREFIX: Driver. -* MD_STARTFILE_PREFIX: Driver. -* MEMORY_MOVE_COST: Costs. -* MEM_IN_STRUCT_P: Flags. -* MEM_VOLATILE_P: Flags. -* MIPS options: MIPS Options. -* MODDI3_LIBCALL: Library Calls. -* 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. -* MODSI3_LIBCALL: Library Calls. -* MOVE_MAX: Misc. -* MOVE_RATIO: Costs. -* MULDI3_LIBCALL: Library Calls. -* MULSI3_LIBCALL: Library Calls. -* MULTIBYTE_CHARS: Type Layout. -* NEXT_INSN: Insns. -* NEXT_OBJC_RUNTIME: Library Calls. -* NON_SAVING_SETJMP: Register Basics. -* 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_FUNCTION_CSE: Costs. -* NO_RECURSIVE_FUNCTION_CSE: Costs. -* NO_REGS: Register Classes. -* 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_NONUNIQUE_SELECTORS: Type Layout. -* OBJC_PROLOGUE: File Framework. -* OBSTACK_CHUNK_ALLOC: Config. -* OBSTACK_CHUNK_FREE: Config. -* OBSTACK_CHUNK_SIZE: Config. -* OCS (88k): M88K Options. -* ONLY_INT_FIELDS: Config. -* OPTIMIZATION_OPTIONS: Run-time Target. -* ORDER_REGS_FOR_LOCAL_ALLOC: Allocation Order. -* OUTGOING_REG_PARM_STACK_SPACE: Stack Arguments. -* OVERLAPPING_REGNO_P: Obsolete Register Macros. -* OVERRIDE_OPTIONS: Run-time Target. -* Ordering of Patterns: Pattern Ordering. -* PARM_BOUNDARY: Storage Layout. -* PATTERN: Insns. -* PCC_BITFIELD_TYPE_MATTERS: Storage Layout. -* PCC_STATIC_STRUCT_RETURN: Aggregate Return. -* PDImode: Machine Modes. -* PIC: PIC. -* PIC_OFFSET_TABLE_REGNUM: PIC. -* POINTER_SIZE: Storage Layout. -* PREDICATE_CODES: Misc. -* PREFERRED_RELOAD_CLASS: Register Classes. -* PRESERVE_DEATH_INFO_REGNO_P: Obsolete Register Macros. -* PREV_INSN: Insns. -* PRINT_OPERAND: Instruction Output. -* PRINT_OPERAND_ADDRESS: Instruction Output. -* PRINT_OPERAND_PUNCT_VALID_P: Instruction Output. -* PROFILE_BEFORE_PROLOGUE: Profiling. -* PROMOTE_PROTOTYPES: Stack Arguments. -* PSImode: Machine Modes. -* PTRDIFF_TYPE: Type Layout. -* PUSH_ROUNDING: Stack Arguments. -* PUT_CODE: RTL Objects. -* PUT_MODE: Machine Modes. -* PUT_REG_NOTE_KIND: Insns. -* PUT_SDB_...: Debugging Info. -* Pattern Ordering: Pattern Ordering. -* Pmode: Misc. -* QImode: Machine Modes. -* READONLY_DATA_SECTION: Sections. -* REAL_ARITHMETIC: Cross-compilation. -* REAL_INFINITY: Cross-compilation. -* REAL_VALUES_EQUAL: Cross-compilation. -* REAL_VALUES_LESS: Cross-compilation. -* REAL_VALUE_ATOF: Cross-compilation. -* REAL_VALUE_FIX: Cross-compilation. -* REAL_VALUE_FIX_TRUNCATE: 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_TO_INT: Cross-compilation. -* REAL_VALUE_TRUNCATE: Cross-compilation. -* REAL_VALUE_TYPE: Cross-compilation. -* REAL_VALUE_UNSIGNED_FIX: Cross-compilation. -* REAL_VALUE_UNSIGNED_FIX_TRUNCATE: Cross-compilation. -* REGISTER_MOVE_COST: Costs. -* REGISTER_NAMES: Instruction Output. -* REGISTER_PREFIX: Instruction Output. -* REGNO_OK_FOR_BASE_P: Register Classes. -* REGNO_OK_FOR_INDEX_P: Register Classes. -* REGNO_REG_CLASS: Register Classes. -* 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_LEAF_ALLOC_ORDER: Leaf Functions. -* REG_LIBCALL: Insns. -* REG_LOOP_TEST_P: Flags. -* 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_PREFIX_NOT_LINKDIR: Driver. -* RETURN_IN_MEMORY: Aggregate Return. -* RETURN_POPS_ARGS: Stack Arguments. -* ROUND_TYPE_ALIGN: Storage Layout. -* ROUND_TYPE_SIZE: Storage Layout. -* RS/6000 Options: RS/6000 Options. -* RT PC: Incompatibilities. -* RT options: RT Options. -* 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. -* Register Transfer Language (RTL): RTL. -* SCCS_DIRECTIVE: Misc. -* SCHED_GROUP_P: Flags. -* SCO installation: SCO Install. -* SCmode: Machine Modes. -* SDB_ALLOW_FORWARD_REFERENCES: Debugging Info. -* SDB_ALLOW_UNKNOWN_REFERENCES: Debugging Info. -* SDB_DEBUGGING_INFO: Debugging Info. -* SDB_DELIM: Debugging Info. -* SDB_GENERATE_FAKE: Debugging Info. -* SECONDARY_INPUT_RELOAD_CLASS: 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. -* SETUP_INCOMING_VARARGS: Varargs. -* SET_DEST: Side Effects. -* SET_SRC: Side Effects. -* SFmode: Machine Modes. -* SHARED_SECTION_ASM_OP: Sections. -* SHIFT_COUNT_TRUNCATED: Misc. -* SHORT_TYPE_SIZE: Type Layout. -* SIGNED_CHAR_SPEC: Driver. -* SIZE_TYPE: Type Layout. -* SImode: Machine Modes. -* SItype: Library Calls. -* SLOW_BYTE_ACCESS: Costs. -* SLOW_UNALIGNED_ACCESS: Costs. -* SLOW_ZERO_EXTEND: Costs. -* SMALL_REGISTER_CLASSES: Register Classes. -* SPARC options: Sparc Options. -* 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_REGS: Stack Registers. -* STANDARD_EXEC_PREFIX: Driver. -* STANDARD_INCLUDE_DIR: Driver. -* STANDARD_STARTFILE_PREFIX: Driver. -* STARTFILE_SPEC: Driver. -* STARTING_FRAME_OFFSET: Frame Layout. -* 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. -* STORE_FLAG_VALUE: Misc. -* STRICT_ALIGNMENT: Storage Layout. -* 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. -* SUBREG_REG: Regs and Memory. -* SUBREG_WORD: Regs and Memory. -* SUCCESS_EXIT_CODE: Config. -* SVr4: M88K Options. -* SWITCHES_NEED_SPACES: Driver. -* SWITCH_TAKES_ARG: Driver. -* SYMBOL_REF_FLAG: Flags. -* SYMBOL_REF_USED: Flags. -* SYSTEM_INCLUDE_DIR: Driver. -* Sun installation: Sun Install. -* TARGET_BELL: Type Layout. -* TARGET_BS: Type Layout. -* TARGET_CR: Type Layout. -* 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. -* TEXT_SECTION_ASM_OP: Sections. -* TFmode: Machine Modes. -* TImode: Machine Modes. -* TMPDIR: Environment Variables. -* TRADITIONAL_RETURN_FLOAT: Scalar Return. -* TRAMPOLINE_ALIGNMENT: Trampolines. -* TRAMPOLINE_SIZE: Trampolines. -* TRAMPOLINE_TEMPLATE: Trampolines. -* TRANSFER_FROM_TRAMPOLINE: Trampolines. -* TRULY_NOOP_TRUNCATION: Misc. -* UDIVDI3_LIBCALL: Library Calls. -* UDIVSI3_LIBCALL: Library Calls. -* UMODDI3_LIBCALL: Library Calls. -* UMODSI3_LIBCALL: Library Calls. -* UNITS_PER_WORD: Storage Layout. -* UNKNOWN_FLOAT_FORMAT: Storage Layout. -* USER_LABEL_PREFIX: Instruction Output. -* USE_C_ALLOCA: Config. -* USG: Config. -* Ultrix calling convention: Incompatibilities. -* Unos installation: Unos Install. -* 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. -* VOIDmode: Machine Modes. -* Vax calling convention: Incompatibilities. -* WCHAR_TYPE: Type Layout. -* WCHAR_TYPE_SIZE: Type Layout. -* WORDS_BIG_ENDIAN: Storage Layout. -* WORD_SWITCH_TAKES_ARG: Driver. -* XCmode: Machine Modes. -* XEXP: Accessors. -* XFmode: Machine Modes. -* XINT: Accessors. -* XSTR: Accessors. -* XVEC: Accessors. -* XVECEXP: Accessors. -* XVECLEN: Accessors. -* \: Output Template. -* __bb_init_func: Profiling. -* __builtin_args_info: Varargs. -* __builtin_classify_type: Varargs. -* __builtin_next_arg: Varargs. -* __builtin_saveregs: Varargs. -* abort: Portability. -* abs: Arithmetic. -* absolute value: Arithmetic. -* access to operands: Accessors. -* accessors: Accessors. -* addr_diff_vec: Side Effects. -* addr_vec: Side Effects. -* address: RTL Template. -* address constraints: Simple Constraints. -* address of a label: Labels as Values. -* address_operand: Simple Constraints. -* addressing modes: Addressing Modes. -* aggregates as return values: Aggregate Return. -* alignment: Alignment. -* alternate keywords: Alternate Keywords. -* analysis, data flow: Passes. -* and: Arithmetic. -* apostrophes: Incompatibilities. -* arg_pointer_rtx: Frame Registers. -* argument passing: Interface. -* arguments in frame (88k): M88K Options. -* arguments in registers: Register Arguments. -* arguments on stack: Stack Arguments. -* arithmetic libraries: Interface. -* arithmetic shift: Arithmetic. -* arithmetic simplifications: Passes. -* arithmetic, in RTL: Arithmetic. -* arrays of length zero: Zero Length. -* arrays of variable length: Variable Length. -* arrays, non-lvalue: Subscripting. -* ashift: Arithmetic. -* ashiftrt: Arithmetic. -* asm_fprintf: Instruction Output. -* asm_input: Side Effects. -* asm_noperands: Insns. -* assemble_name: Label Output. -* assembler format: File Framework. -* assembler instructions: Extended Asm. -* assembler instructions in RTL: Assembler. -* assembler names for identifiers: Asm Labels. -* assembler syntax, 88k: M88K Options. -* 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. -* autoincrement addressing, availability: Portability. -* autoincrement/decrement addressing: Simple Constraints. -* autoincrement/decrement analysis: Passes. -* backslash: Output Template. -* backtrace for bug reports: Bug Reporting. -* barrier: Insns. -* basic blocks: Passes. -* bcmp: Config. -* bit fields: Bit Fields. -* bit shift overflow (88k): M88K Options. -* bitwise complement: Arithmetic. -* bitwise exclusive-or: Arithmetic. -* bitwise inclusive-or: Arithmetic. -* bitwise logical-and: Arithmetic. -* break_out_memory_refs: Addressing Modes. -* bug criteria: Bug Criteria. -* bug reports: Bug Reporting. -* bugs: Bugs. -* bugs, known: Trouble. -* byte_mode: Machine Modes. -* bzero: Config. -* call: Side Effects. -* call-clobbered register: Register Basics. -* call-saved register: Register Basics. -* call-used register: Register Basics. -* call_insn: Insns. -* call_used_regs: Register Basics. -* calling conventions: Stack and Calling. -* calling functions in RTL: Calls. -* canonicalization of instructions: Insn Canonicalizations. -* case labels in initializers: Labeled Elements. -* case ranges: Case Ranges. -* case sensitivity and VMS: VMS Misc. -* cast to a union: Cast to Union. -* casts as lvalues: Lvalues. -* cc0: Regs and Memory. -* cc0_rtx: Regs and Memory. -* cc_status: Condition Code. -* change_address: Standard Names. -* class definitions, register: Register Classes. -* class preference constraints: Class Preferences. -* classes of RTX codes: Accessors. -* clobber: Side Effects. -* code generation RTL sequences: Expander Definitions. -* code generation conventions: Code Gen Options. -* code motion: Passes. -* code_label: Insns. -* codes, RTL expression: RTL Objects. -* 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 passes and files: Passes. -* compiler version, specifying: Target Options. -* complement, bitwise: Arithmetic. -* compound expressions as lvalues: Lvalues. -* computed gotos: Labels as Values. -* computing the length of an insn: Insn Lengths. -* 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. -* conditions, in patterns: Patterns. -* configuration file: Config. -* conflicting types: Trouble. -* const0_rtx: Constants. -* const1_rtx: Constants. -* const2_rtx: Constants. -* const_double: Constants. -* const_int: Constants. -* const_string: Constants. -* const_true_rtx: Constants. -* constant folding: Passes. -* constant folding and floating point: Cross-compilation. -* constant propagation: Passes. -* constants in constraints: Simple Constraints. -* constm1_rtx: Constants. -* constraint modifier characters: Modifiers. -* constraint, matching: Simple Constraints. -* constraints: Constraints. -* constructor expressions: Constructors. -* constructors, output of: Constructor Output. -* contributors: Contributors. -* controlling register usage: Register Basics. -* controlling the compilation driver: Driver. -* conventions, run-time: Interface. -* conversions: Conversions. -* copy_rtx_if_shared: Sharing. -* core dump: Bug Criteria. -* costs of instructions: Costs. -* cross compilation and floating point: Cross-compilation. -* cross compiling: Target Options. -* cross-jumping: Passes. -* 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. -* data flow analysis: Passes. -* data_section: Sections. -* dbr_sequence_length: Instruction Output. -* dead code: Passes. -* dead_or_set_p: Peephole Definitions. -* deallocating variable length arrays: Variable Length. -* death notes: Obsolete Register Macros. -* debug_rtx: Bug Reporting. -* debugging information generation: Passes. -* debugging information options: Debugging Options. -* debugging, 88k OCS: M88K Options. -* declaration scope: Incompatibilities. -* declarations inside expressions: Statement Exprs. -* declarations, RTL: RTL Declarations. -* declaring attributes of functions: Function Attributes. -* 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. -* defining RTL sequences for code generation: Expander Definitions. -* defining attributes and their values: Defining Attributes. -* defining jump instruction patterns: Jump Patterns. -* defining peephole optimizers: Peephole Definitions. -* delay slots, defining: Delay Slots. -* delayed branch scheduling: Passes. -* dependencies for make as output: Environment Variables. -* dependencies, make: Preprocessor Options. -* destructors, output of: Constructor Output. -* dialect options: Dialect Options. -* digits in constraint: Simple Constraints. -* directory options: Directory Options. -* disabling certain registers: Register Basics. -* dispatch table: Dispatch Tables. -* div: Arithmetic. -* divide instruction, 88k: M88K Options. -* division: Arithmetic. -* division: Arithmetic. -* division: Arithmetic. -* dollar signs in identifier names: Dollar Signs. -* double-word arithmetic: Long Long. -* downward funargs: Nested Functions. -* driver: Driver. -* empty constraints: No Constraints. -* endianness: Portability. -* enum machine_mode: Machine Modes. -* enum reg_class: Register Classes. -* environment variables: Environment Variables. -* epilogue: Function Entry. -* eq: Comparisons. -* eq_attr: Expressions. -* equal: Comparisons. -* error: Storage Layout. -* exclamation point: Multi-Alternative. -* exclusive-or, bitwise: Arithmetic. -* exit status and VMS: VMS Misc. -* expander definitions: Expander Definitions. -* explicit register variables: Explicit Reg Vars. -* expr_list: Insns. -* expression codes: RTL Objects. -* expressions containing statements: Statement Exprs. -* expressions, compound, as lvalues: Lvalues. -* expressions, conditional, as lvalues: Lvalues. -* expressions, constructor: Constructors. -* extended asm: Extended Asm. -* extensible constraints: Simple Constraints. -* extensions, ?:: Lvalues. -* extensions, ?:: Conditionals. -* extensions, C language: Extensions. -* extern int target_flags: Run-time Target. -* external declaration scope: Incompatibilities. -* fatal signal: Bug Criteria. -* features, optional, in system conventions: Run-time Target. -* ffs: Arithmetic. -* file name suffix: Overall Options. -* file names: Link Options. -* files and passes of the compiler: Passes. -* final pass: Passes. -* final_scan_insn: Function Entry. -* final_sequence: Instruction Output. -* fix: Conversions. -* fix: Conversions. -* fixed register: Register Basics. -* fixed_regs: Register Basics. -* flags in RTL expression: Flags. -* float: Conversions. -* float_extend: Conversions. -* float_truncate: Conversions. -* floating point format and cross compilation: Cross-compilation. -* force_reg: Standard Names. -* frame layout: Frame Layout. -* frame_pointer_needed: Function Entry. -* 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 units, for scheduling: Function Units. -* function, size of pointer to: Pointer Arith. -* function-call insns: Calls. -* functions that have no side effects: Function Attributes. -* functions that never return: Function Attributes. -* functions, leaf: Leaf Functions. -* ge: Comparisons. -* gencodes: Passes. -* genconfig: Passes. -* general_operand: RTL Template. -* generalized lvalues: Lvalues. -* generating assembler output: Output Statement. -* generating insns: RTL Template. -* genflags: Passes. -* get_attr: Expressions. -* get_attr_value: Insn Lengths. -* get_frame_size: Elimination. -* get_insns: Insns. -* get_last_insn: Insns. -* 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. -* goto with computed label: Labels as Values. -* gp-relative references (MIPS): MIPS Options. -* greater than: Comparisons. -* greater than: Comparisons. -* greater than: Comparisons. -* grouping options: Invoking GCC. -* gt: Comparisons. -* gtu: Comparisons. -* hard registers: Regs and Memory. -* hardware models and configurations, specifying: Submodel Options. -* header files and VMS: Include Files and VMS. -* high: Constants. -* identifier names, dollar signs in: Dollar Signs. -* identifiers, names in assembler code: Asm Labels. -* identifying source, compiler (88k): M88K Options. -* if_then_else: Comparisons. -* immediate_operand: RTL Template. -* in_data: Sections. -* in_struct: Flags. -* in_text: Sections. -* include files and VMS: Include Files and VMS. -* inclusive-or, bitwise: Arithmetic. -* incompatibilities of GNU CC: Incompatibilities. -* increment operators: Bug Criteria. -* initialization routines: Constructor Output. -* initializations in expressions: Constructors. -* initializers with labeled elements: Labeled Elements. -* initializers, non-constant: Initializers. -* inline functions: Inline. -* inline functions, omission of: Inline. -* inline, automatic: Passes. -* insn: Insns. -* insn attributes: Insn Attributes. -* insn canonicalization: Insn Canonicalizations. -* insn lengths, computing: Insn Lengths. -* insn splitting: Insn Splitting. -* insn-attr.h: Defining Attributes. -* insn_list: Insns. -* insns: Insns. -* insns, generating: RTL Template. -* insns, recognizing: RTL Template. -* installation on SCO systems: SCO Install. -* installation trouble: Trouble. -* installing GNU CC: Installation. -* installing GNU CC on Unos: Unos Install. -* installing GNU CC on VMS: VMS Install. -* installing GNU CC on the 3b1: 3b1 Install. -* installing GNU CC on the Sun: Sun 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. -* integrating function code: Inline. -* interfacing to GNU CC output: Interface. -* introduction: Top. -* invalid assembly code: Bug Criteria. -* invalid input: Bug Criteria. -* ior: Arithmetic. -* isinf: Cross-compilation. -* isnan: Cross-compilation. -* jump instruction patterns: Jump Patterns. -* jump instructions and set: Side Effects. -* jump optimization: Passes. -* jump threading: Passes. -* jump_insn: Insns. -* keywords, alternate: Alternate Keywords. -* known causes of trouble: Trouble. -* label_ref: Constants. -* labeled elements in initializers: Labeled Elements. -* labels as values: Labels as Values. -* language dialect options: Dialect Options. -* large bit shifts (88k): M88K Options. -* large return values: Aggregate Return. -* ldexp: Cross-compilation. -* le: Comparisons. -* leaf functions: Leaf Functions. -* leaf_function: Leaf Functions. -* leaf_function_p: Standard Names. -* left rotate: Arithmetic. -* left shift: Arithmetic. -* left shift: Arithmetic. -* length-zero arrays: Zero Length. -* less than: Comparisons. -* less than or equal: Comparisons. -* leu: Comparisons. -* library subroutine names: Library Calls. -* link options: Link Options. -* lo_sum: Arithmetic. -* load address instruction: Simple Constraints. -* local labels: Local Labels. -* local register allocation: Passes. -* local variables in macros: Naming Types. -* local variables, specifying registers: Local Reg Vars. -* logical shift: Arithmetic. -* logical-and, bitwise: Arithmetic. -* longjmp: Global Reg Vars. -* loop optimization: Passes. -* lshift: Arithmetic. -* lshiftrt: Arithmetic. -* lt: Comparisons. -* ltu: Comparisons. -* lvalues, generalized: Lvalues. -* machine dependent options: Submodel Options. -* machine description macros: Machine Macros. -* machine descriptions: Machine Desc. -* machine mode conversions: Conversions. -* machine modes: Machine Modes. -* macros containing asm: Extended Asm. -* macros, inline alternative: Inline. -* macros, local labels: Local Labels. -* macros, local variables in: Naming Types. -* macros, machine description: Machine Macros. -* macros, statements in expressions: Statement Exprs. -* macros, types of arguments: Typeof. -* make: Preprocessor Options. -* make_safe_from: Expander Definitions. -* match_dup: RTL Template. -* match_operand: RTL Template. -* match_operator: RTL Template. -* match_scratch: RTL Template. -* matching constraint: Simple Constraints. -* matching operands: Output Template. -* math libraries: Interface. -* math, in RTL: Arithmetic. -* mcount: Profiling. -* mem: Regs and Memory. -* memory reference, nonoffsettable: Simple Constraints. -* memory references in constraints: Simple Constraints. -* messages, warning: Warning Options. -* middle-operands, omitted: Conditionals. -* minus: Arithmetic. -* mod: Arithmetic. -* mode classes: Machine Modes. -* modifiers in constraints: Modifiers. -* mult: Arithmetic. -* multiple alternative constraints: Multi-Alternative. -* multiplication: Arithmetic. -* multiprecision arithmetic: Long Long. -* name augmentation: VMS Misc. -* named patterns and conditions: Patterns. -* names used in assembler code: Asm Labels. -* names, pattern: Standard Names. -* naming types: Naming Types. -* ne: Comparisons. -* neg: Arithmetic. -* nested functions: Nested Functions. -* nested functions, trampolines for: Trampolines. -* next_cc0_user: Jump Patterns. -* nil: RTL Objects. -* no constraints: No Constraints. -* no-op move instructions: Passes. -* non-constant initializers: Initializers. -* non-static inline function: Inline. -* nonoffsettable memory reference: Simple Constraints. -* not: Arithmetic. -* not equal: Comparisons. -* not using constraints: No Constraints. -* note: Insns. -* obstack_free: 3b1 Install. -* offsettable address: Simple Constraints. -* omitted middle-operands: Conditionals. -* open coding: Inline. -* operand access: Accessors. -* operand constraints: Constraints. -* operand substitution: Output Template. -* operands: Patterns. -* optimize options: Optimize Options. -* optional hardware or system features: Run-time Target. -* options to control warnings: Warning Options. -* options, GNU CC command: Invoking GCC. -* options, code generation: Code Gen Options. -* options, debugging: Debugging Options. -* options, dialect: Dialect Options. -* options, directory search: Directory Options. -* options, grouping: Invoking GCC. -* options, linking: Link Options. -* options, optimization: Optimize Options. -* options, order: Invoking GCC. -* options, preprocessor: Preprocessor Options. -* order of options: Invoking GCC. -* order of register allocation: Allocation Order. -* other directory, compilation in: Other Dir. -* 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. -* parallel: Side Effects. -* parameter forward declaration: Variable Length. -* parameters, miscellaneous: Misc. -* parser generator, Bison: Installation. -* parsing pass: Passes. -* passes and files of the compiler: Passes. -* passing arguments: Interface. -* pattern conditions: Patterns. -* pattern names: Standard Names. -* patterns: Patterns. -* pc: Regs and Memory. -* pc_rtx: Regs and Memory. -* peephole optimization: Passes. -* peephole optimization, RTL representation: Side Effects. -* peephole optimizer definitions: Peephole Definitions. -* percent sign: Output Template. -* perform_...: Library Calls. -* plus: Arithmetic. -* pointer arguments: Function Attributes. -* portability: Portability. -* position independent code: PIC. -* post_dec: Incdec. -* post_inc: Incdec. -* pragma: Misc. -* pragma, reason for not using: Function Attributes. -* pre_dec: Incdec. -* pre_inc: Incdec. -* predefined macros: Run-time Target. -* preprocessor options: Preprocessor Options. -* prev_cc0_setter: Jump Patterns. -* prev_nonnote_insn: Peephole Definitions. -* product: Arithmetic. -* profiling, code generation: Profiling. -* program counter: Regs and Memory. -* prologue: Function Entry. -* promotion of formal parameters: Trouble. -* pseudo registers: Regs and Memory. -* push address instruction: Simple Constraints. -* question mark: Multi-Alternative. -* quotient: Arithmetic. -* r0-relative references (88k): M88K Options. -* ranges in case statements: Case Ranges. -* read-only strings: Incompatibilities. -* recog_operand: Instruction Output. -* recognizing insns: RTL Template. -* reg: Regs and Memory. -* reg_names: Instruction Output. -* 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 usage: Registers. -* register use analysis: Passes. -* register variable after longjmp: Global Reg Vars. -* register-to-stack conversion: Passes. -* register_operand: RTL Template. -* 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. -* regs_ever_live: Function Entry. -* relative costs: Costs. -* reload pass: Regs and Memory. -* reload_completed: Standard Names. -* reload_in: Standard Names. -* reload_in_progress: Standard Names. -* reload_out: Standard Names. -* reloading: Passes. -* remainder: Arithmetic. -* reporting bugs: Bugs. -* representation of RTL: RTL. -* rest_of_compilation: Passes. -* rest_of_decl_compilation: Passes. -* return: Side Effects. -* return value of main: VMS Misc. -* return values in registers: Scalar Return. -* returning aggregate values: Aggregate Return. -* returning structures and unions: Interface. -* right rotate: Arithmetic. -* right shift: Arithmetic. -* rotate: Arithmetic. -* rotate: Arithmetic. -* rotatert: Arithmetic. -* 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. -* scheduling, delayed branch: Passes. -* scheduling, instruction: Passes. -* scheduling, instruction: Passes. -* scope of a variable length array: Variable Length. -* scope of declaration: Trouble. -* scope of external declarations: Incompatibilities. -* scratch: Regs and Memory. -* scratch operands: Regs and Memory. -* search path: Directory Options. -* separate directory, compilation in: Other Dir. -* sequence: Side Effects. -* set: Side Effects. -* set_attr: Tagging Insns. -* set_attr_alternative: Tagging Insns. -* setjmp: Global Reg Vars. -* shared VMS run time system: VMS Misc. -* shared strings: Incompatibilities. -* sharing of RTL components: Sharing. -* shift: Arithmetic. -* side effect in ?:: Conditionals. -* side effects, macro argument: Statement Exprs. -* sign_extend: Conversions. -* sign_extract: Bit Fields. -* signed division: Arithmetic. -* signed maximum: Arithmetic. -* signed minimum: Arithmetic. -* simple constraints: Simple Constraints. -* simplifications, arithmetic: Passes. -* sizeof: Typeof. -* smaller data references (88k): M88K Options. -* smaller data references (MIPS): MIPS Options. -* smax: Arithmetic. -* smin: Arithmetic. -* 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: Arithmetic. -* square root: Arithmetic. -* stack arguments: Stack Arguments. -* stack frame layout: Frame Layout. -* stack_pointer_rtx: Frame Registers. -* stage1: Installation. -* standard pattern names: Standard Names. -* statements inside expressions: Statement Exprs. -* storage layout: Storage Layout. -* strcpy: Storage Layout. -* strength-reduction: Passes. -* strict_low_part: RTL Declarations. -* string constants: Incompatibilities. -* structure passing (88k): M88K Options. -* structure value address: Aggregate Return. -* structures: Incompatibilities. -* structures, constructor expression: Constructors. -* structures, returning: Interface. -* stupid register allocation: Passes. -* submodel options: Submodel Options. -* subreg: Regs and Memory. -* subscripting: Subscripting. -* subscripting and function values: Subscripting. -* suppressing warnings: Warning Options. -* symbol_ref: Constants. -* symbolic label: Sharing. -* syntax checking: Warning Options. -* tagging insns: Tagging Insns. -* tail recursion optimization: Passes. -* target machine, specifying: Target Options. -* target options: Target Options. -* target specifications: Run-time Target. -* target-parameter-dependent code: Passes. -* termination routines: Constructor Output. -* text_section: Sections. -* thunks: Nested Functions. -* top level of compiler: Passes. -* traditional C language: Dialect Options. -* trampolines for nested functions: Trampolines. -* truncate: Conversions. -* type alignment: Alignment. -* typedef names as function parameters: Incompatibilities. -* typeof: Typeof. -* udiv: Arithmetic. -* umax: Arithmetic. -* umin: Arithmetic. -* umod: Arithmetic. -* 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. -* unreachable code: Passes. -* 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. -* value after longjmp: Global Reg Vars. -* values, returned by functions: Scalar Return. -* varargs implementation: Varargs. -* variable alignment: Alignment. -* variable attributes: Variable Attributes. -* variable-length array scope: Variable Length. -* variable-length arrays: Variable Length. -* variables in specified registers: Explicit Reg Vars. -* variables, local, in macros: Naming Types. -* void pointers, arithmetic: Pointer Arith. -* void, size of pointer to: Pointer Arith. -* volatil: Flags. -* volatile memory references: Flags. -* voting between constraint alternatives: Class Preferences. -* vprintf: Misc. -* warning messages: Warning Options. -* which_alternative: Output Statement. -* whitespace: Incompatibilities. -* word_mode: Machine Modes. -* xor: Arithmetic. -* zero division on 88k: M88K Options. -* zero-length arrays: Zero Length. -* zero_extend: Conversions. -* zero_extract: Bit Fields. +* Frame Layout:: +* Frame Registers:: +* Elimination:: +* Stack Arguments:: +* Register Arguments:: +* Scalar Return:: +* Aggregate Return:: +* Caller Saves:: +* Function Entry:: +* Profiling:: + + +File: gcc.info, Node: Frame Layout, Next: Frame Registers, Up: Stack and Calling + +Basic Stack Layout +------------------ + +`STACK_GROWS_DOWNWARD' + Define this macro if pushing a word onto the stack moves the stack + pointer to a smaller address. + + When we say, "define this macro if ...," it means that the + compiler checks this macro only with `#ifdef' so the precise + definition used does not matter. + +`FRAME_GROWS_DOWNWARD' + Define this macro if the addresses of local variable slots are at + negative offsets from the frame pointer. + +`ARGS_GROW_DOWNWARD' + Define this macro if successive arguments to a function occupy + decreasing addresses on the stack. + +`STARTING_FRAME_OFFSET' + Offset from the frame pointer to the first local variable slot to + be allocated. + + If `FRAME_GROWS_DOWNWARD', find the next slot's offset by + subtracting the first slot's length from `STARTING_FRAME_OFFSET'. + Otherwise, it is found by adding the length of the first slot to + the value `STARTING_FRAME_OFFSET'. + +`STACK_POINTER_OFFSET' + Offset from the stack pointer register to the first location at + which outgoing arguments are placed. If not specified, the + default value of zero is used. This is the proper value for most + machines. + + If `ARGS_GROW_DOWNWARD', this is the offset to the location above + the first location at which outgoing arguments are placed. + +`FIRST_PARM_OFFSET (FUNDECL)' + Offset from the argument pointer register to the first argument's + address. On some machines it may depend on the data type of the + function. + + If `ARGS_GROW_DOWNWARD', this is the offset to the location above + the first argument's address. + +`STACK_DYNAMIC_OFFSET (FUNDECL)' + Offset from the stack pointer register to an item dynamically + allocated on the stack, e.g., by `alloca'. + + The default value for this macro is `STACK_POINTER_OFFSET' plus the + length of the outgoing arguments. The default is correct for most + machines. See `function.c' for details. + +`DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)' + A C expression whose value is RTL representing the address in a + stack frame where the pointer to the caller's frame is stored. + Assume that FRAMEADDR is an RTL expression for the address of the + stack frame itself. + + If you don't define this macro, the default is to return the value + of FRAMEADDR--that is, the stack frame address is also the address + of the stack word that points to the previous frame. + +`SERTUP_FRAME_ADDRESSES ()' + If defined, a C expression that produces the machine-specific code + to setup the stack so that arbitrary frames can be accessed. For + example, on the Sparc, we must flush all of the register windows + to the stack before we can access arbitrary stack frames. This + macro will seldom need to be defined. + +`RETURN_ADDR_RTX (COUNT, FRAMEADDR)' + A C expression whose value is RTL representing the value of the + return address for the frame COUNT steps up from the current frame. + fRAMEADDR is the frame pointer of the COUNT frame, or the frame + pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' + is defined. + +`RETURN_ADDR_IN_PREVIOUS_FRAME' + Define this if the return address of a particular stack frame is + accessed from the frame pointer of the previous stack frame. + + +File: gcc.info, Node: Frame Registers, Next: Elimination, Prev: Frame Layout, Up: Stack and Calling + +Registers That Address the Stack Frame +-------------------------------------- + +`STACK_POINTER_REGNUM' + The register number of the stack pointer register, which must also + be a fixed register according to `FIXED_REGISTERS'. On most + machines, the hardware determines which register this is. + +`FRAME_POINTER_REGNUM' + The register number of the frame pointer register, which is used to + access automatic variables in the stack frame. On some machines, + the hardware determines which register this is. On other + machines, you can choose any register you wish for this purpose. + +`ARG_POINTER_REGNUM' + The register number of the arg pointer register, which is used to + access the function's argument list. On some machines, this is + the same as the frame pointer register. On some machines, the + hardware determines which register this is. On other machines, + you can choose any register you wish for this purpose. If this is + not the same register as the frame pointer register, then you must + mark it as a fixed register according to `FIXED_REGISTERS', or + arrange to be able to eliminate it (*note Elimination::.). + +`STATIC_CHAIN_REGNUM' +`STATIC_CHAIN_INCOMING_REGNUM' + Register numbers used for passing a function's static chain + pointer. If register windows are used, the register number as + seen by the called function is `STATIC_CHAIN_INCOMING_REGNUM', + while the register number as seen by the calling function is + `STATIC_CHAIN_REGNUM'. If these registers are the same, + `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. + + The static chain register need not be a fixed register. + + If the static chain is passed in memory, these macros should not be + defined; instead, the next two macros should be defined. + +`STATIC_CHAIN' +`STATIC_CHAIN_INCOMING' + If the static chain is passed in memory, these macros provide rtx + giving `mem' expressions that denote where they are stored. + `STATIC_CHAIN' and `STATIC_CHAIN_INCOMING' give the locations as + seen by the calling and called functions, respectively. Often the + former will be at an offset from the stack pointer and the latter + at an offset from the frame pointer. + + The variables `stack_pointer_rtx', `frame_pointer_rtx', and + `arg_pointer_rtx' will have been initialized prior to the use of + these macros and should be used to refer to those items. + + If the static chain is passed in a register, the two previous + macros should be defined instead. + + +File: gcc.info, Node: Elimination, Next: Stack Arguments, Prev: Frame Registers, Up: Stack and Calling + +Eliminating Frame Pointer and Arg Pointer +----------------------------------------- + +`FRAME_POINTER_REQUIRED' + A C expression which is nonzero if a function must have and use a + frame pointer. This expression is evaluated in the reload pass. + If its value is nonzero the function will have a frame pointer. + + The expression can in principle examine the current function and + decide according to the facts, but on most machines the constant 0 + or the constant 1 suffices. Use 0 when the machine allows code to + be generated with no frame pointer, and doing so saves some time + or space. Use 1 when there is no possible advantage to avoiding a + frame pointer. + + In certain cases, the compiler does not know how to produce valid + code without a frame pointer. The compiler recognizes those cases + and automatically gives the function a frame pointer regardless of + what `FRAME_POINTER_REQUIRED' says. You don't need to worry about + them. + + In a function that does not require a frame pointer, the frame + pointer register can be allocated for ordinary usage, unless you + mark it as a fixed register. See `FIXED_REGISTERS' for more + information. + + This macro is ignored and you do not need to define it if the + function `ELIMINABLE_REGS' is defined. + +`INITIAL_FRAME_POINTER_OFFSET (DEPTH-VAR)' + A C statement to store in the variable DEPTH-VAR the difference + between the frame pointer and the stack pointer values immediately + after the function prologue. The value would be computed from + information such as the result of `get_frame_size ()' and the + tables of registers `regs_ever_live' and `call_used_regs'. + + If `ELIMINABLE_REGS' is defined, this macro will be not be used and + need not be defined. Otherwise, it must be defined even if + `FRAME_POINTER_REQUIRED' is defined to always be true; in that + case, you may set DEPTH-VAR to anything. + +`ELIMINABLE_REGS' + If defined, this macro specifies a table of register pairs used to + eliminate unneeded registers that point into the stack frame. If + it is not defined, the only elimination attempted by the compiler + is to replace references to the frame pointer with references to + the stack pointer. + + The definition of this macro is a list of structure + initializations, each of which specifies an original and + replacement register. + + On some machines, the position of the argument pointer is not + known until the compilation is completed. In such a case, a + separate hard register must be used for the argument pointer. + This register can be eliminated by replacing it with either the + frame pointer or the argument pointer, depending on whether or not + the frame pointer has been eliminated. + + In this case, you might specify: + #define ELIMINABLE_REGS \ + {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ + {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ + {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} + + Note that the elimination of the argument pointer with the stack + pointer is specified first since that is the preferred elimination. + +`CAN_ELIMINATE (FROM-REG, TO-REG)' + A C expression that returns non-zero if the compiler is allowed to + try to replace register number FROM-REG with register number + TO-REG. This macro need only be defined if `ELIMINABLE_REGS' is + defined, and will usually be the constant 1, since most of the + cases preventing register elimination are things that the compiler + already knows about. + +`INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)' + This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It + specifies the initial difference between the specified pair of + registers. This macro must be defined if `ELIMINABLE_REGS' is + defined. + +`LONGJMP_RESTORE_FROM_STACK' + Define this macro if the `longjmp' function restores registers from + the stack frames, rather than from those saved specifically by + `setjmp'. Certain quantities must not be kept in registers across + a call to `setjmp' on such machines. + + +File: gcc.info, Node: Stack Arguments, Next: Register Arguments, Prev: Elimination, Up: Stack and Calling + +Passing Function Arguments on the Stack +--------------------------------------- + + The macros in this section control how arguments are passed on the +stack. See the following section for other macros that control passing +certain arguments in registers. + +`PROMOTE_PROTOTYPES' + Define this macro if an argument declared as `char' or `short' in + a prototype should actually be passed as an `int'. In addition to + avoiding errors in certain cases of mismatch, it also makes for + better code on certain machines. + +`PUSH_ROUNDING (NPUSHED)' + A C expression that is the number of bytes actually pushed onto the + stack when an instruction attempts to push NPUSHED bytes. + + If the target machine does not have a push instruction, do not + define this macro. That directs GNU CC to use an alternate + strategy: to allocate the entire argument block and then store the + arguments into it. + + On some machines, the definition + + #define PUSH_ROUNDING(BYTES) (BYTES) + + will suffice. But on other machines, instructions that appear to + push one byte actually push two bytes in an attempt to maintain + alignment. Then the definition should be + + #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) + +`ACCUMULATE_OUTGOING_ARGS' + If defined, the maximum amount of space required for outgoing + arguments will be computed and placed into the variable + `current_function_outgoing_args_size'. No space will be pushed + onto the stack for each call; instead, the function prologue should + increase the stack frame size by this amount. + + Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is + not proper. + +`REG_PARM_STACK_SPACE (FNDECL)' + Define this macro if functions should assume that stack space has + been allocated for arguments even when their values are passed in + registers. + + The value of this macro is the size, in bytes, of the area + reserved for arguments passed in registers for the function + represented by FNDECL. + + This space can be allocated by the caller, or be a part of the + machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says + which. + +`MAYBE_REG_PARM_STACK_SPACE' +`FINAL_REG_PARM_STACK_SPACE (CONST_SIZE, VAR_SIZE)' + Define these macros in addition to the one above if functions might + allocate stack space for arguments even when their values are + passed in registers. These should be used when the stack space + allocated for arguments in registers is not a simple constant + independent of the function declaration. + + The value of the first macro is the size, in bytes, of the area + that we should initially assume would be reserved for arguments + passed in registers. + + The value of the second macro is the actual size, in bytes, of the + area that will be reserved for arguments passed in registers. + This takes two arguments: an integer representing the number of + bytes of fixed sized arguments on the stack, and a tree + representing the number of bytes of variable sized arguments on + the stack. + + When these macros are defined, `REG_PARM_STACK_SPACE' will only be + called for libcall functions, the current function, or for a + function being called when it is known that such stack space must + be allocated. In each case this value can be easily computed. + + When deciding whether a called function needs such stack space, + and how much space to reserve, GNU CC uses these two macros + instead of `REG_PARM_STACK_SPACE'. + +`OUTGOING_REG_PARM_STACK_SPACE' + Define this if it is the responsibility of the caller to allocate + the area reserved for arguments passed in registers. + + If `ACCUMULATE_OUTGOING_ARGS' is defined, this macro controls + whether the space for these arguments counts in the value of + `current_function_outgoing_args_size'. + +`STACK_PARMS_IN_REG_PARM_AREA' + Define this macro if `REG_PARM_STACK_SPACE' is defined, but the + stack parameters don't skip the area specified by it. + + Normally, when a parameter is not passed in registers, it is + placed on the stack beyond the `REG_PARM_STACK_SPACE' area. + Defining this macro suppresses this behavior and causes the + parameter to be passed on the stack in its natural location. + +`RETURN_POPS_ARGS (FUNTYPE, STACK-SIZE)' + A C expression that should indicate the number of bytes of its own + arguments that a function pops on returning, or 0 if the function + pops no arguments and the caller must therefore pop them all after + the function returns. + + FUNTYPE is a C variable whose value is a tree node that describes + the function in question. Normally it is a node of type + `FUNCTION_TYPE' that describes the data type of the function. + From this it is possible to obtain the data types of the value and + arguments (if known). + + When a call to a library function is being considered, FUNTYPE + will contain an identifier node for the library function. Thus, if + you need to distinguish among various library functions, you can + do so by their names. Note that "library function" in this + context means a function used to perform arithmetic, whose name is + known specially in the compiler and was not mentioned in the C + code being compiled. + + STACK-SIZE is the number of bytes of arguments passed on the + stack. If a variable number of bytes is passed, it is zero, and + argument popping will always be the responsibility of the calling + function. + + On the Vax, all functions always pop their arguments, so the + definition of this macro is STACK-SIZE. On the 68000, using the + standard calling convention, no functions pop their arguments, so + the value of the macro is always 0 in this case. But an + alternative calling convention is available in which functions + that take a fixed number of arguments pop them but other functions + (such as `printf') pop nothing (the caller pops all). When this + convention is in use, FUNTYPE is examined to determine whether a + function takes a fixed number of arguments. + + +File: gcc.info, Node: Register Arguments, Next: Scalar Return, Prev: Stack Arguments, Up: Stack and Calling + +Passing Arguments in Registers +------------------------------ + This section describes the macros which let you control how various +types of arguments are passed in registers or how they are arranged in +the stack. + +`FUNCTION_ARG (CUM, MODE, TYPE, NAMED)' + A C expression that controls whether a function argument is passed + in a register, and which register. + + The arguments are CUM, which summarizes all the previous + arguments; MODE, the machine mode of the argument; TYPE, the data + type of the argument as a tree node or 0 if that is not known + (which happens for C support library functions); and NAMED, which + is 1 for an ordinary argument and 0 for nameless arguments that + correspond to `...' in the called function's prototype. + + The value of the expression should either be a `reg' RTX for the + hard register in which to pass the argument, or zero to pass the + argument on the stack. + + For machines like the Vax and 68000, where normally all arguments + are pushed, zero suffices as a definition. + + The usual way to make the ANSI library `stdarg.h' work on a machine + where some arguments are usually passed in registers, is to cause + nameless arguments to be passed on the stack instead. This is done + by making `FUNCTION_ARG' return 0 whenever NAMED is 0. + + You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the + definition of this macro to determine if this argument is of a + type that must be passed in the stack. If `REG_PARM_STACK_SPACE' + is not defined and `FUNCTION_ARG' returns non-zero for such an + argument, the compiler will abort. If `REG_PARM_STACK_SPACE' is + defined, the argument will be computed in the stack and then + loaded into a register. + +`FUNCTION_INCOMING_ARG (CUM, MODE, TYPE, NAMED)' + Define this macro if the target machine has "register windows", so + that the register in which a function sees an arguments is not + necessarily the same as the one in which the caller passed the + argument. + + For such machines, `FUNCTION_ARG' computes the register in which + the caller passes the value, and `FUNCTION_INCOMING_ARG' should be + defined in a similar fashion to tell the function being called + where the arguments will arrive. + + If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves + both purposes. + +`FUNCTION_ARG_PARTIAL_NREGS (CUM, MODE, TYPE, NAMED)' + A C expression for the number of words, at the beginning of an + argument, must be put in registers. The value must be zero for + arguments that are passed entirely in registers or that are + entirely pushed on the stack. + + On some machines, certain arguments must be passed partially in + registers and partially in memory. On these machines, typically + the first N words of arguments are passed in registers, and the + rest on the stack. If a multi-word argument (a `double' or a + structure) crosses that boundary, its first few words must be + passed in registers and the rest must be pushed. This macro tells + the compiler when this occurs, and how many of the words should go + in registers. + + `FUNCTION_ARG' for these arguments should return the first + register to be used by the caller for this argument; likewise + `FUNCTION_INCOMING_ARG', for the called function. + +`FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED)' + A C expression that indicates when an argument must be passed by + reference. If nonzero for an argument, a copy of that argument is + made in memory and a pointer to the argument is passed instead of + the argument itself. The pointer is passed in whatever way is + appropriate for passing a pointer to that type. + + On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable + definition of this macro might be + #define FUNCTION_ARG_PASS_BY_REFERENCE\ + (CUM, MODE, TYPE, NAMED) \ + MUST_PASS_IN_STACK (MODE, TYPE) + +`FUNCTION_ARG_CALLEE_COPIES (CUM, MODE, TYPE, NAMED)' + If defined, a C expression that indicates when it is the called + function's responsibility to make a copy of arguments passed by + invisible reference. Normally, the caller makes a copy and passes + the address of the copy to the routine being called. When + FUNCTION_ARG_CALLEE_COPIES is defined and is nonzero, the caller + does not make a copy. Instead, it passes a pointer to the "live" + value. The called function must not modify this value. If it can + be determined that the value won't be modified, it need not make a + copy; otherwise a copy must be made. + +`CUMULATIVE_ARGS' + A C type for declaring a variable that is used as the first + argument of `FUNCTION_ARG' and other related values. For some + target machines, the type `int' suffices and can hold the number + of bytes of argument so far. + + There is no need to record in `CUMULATIVE_ARGS' anything about the + arguments that have been passed on the stack. The compiler has + other variables to keep track of that. For target machines on + which all arguments are passed on the stack, there is no need to + store anything in `CUMULATIVE_ARGS'; however, the data structure + must exist and should not be empty, so use `int'. + +`INIT_CUMULATIVE_ARGS (CUM, FNTYPE, LIBNAME)' + A C statement (sans semicolon) for initializing the variable CUM + for the state at the beginning of the argument list. The variable + has type `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node + for the data type of the function which will receive the args, or 0 + if the args are to a compiler support library function. + + When processing a call to a compiler support library function, + LIBNAME identifies which one. It is a `symbol_ref' rtx which + contains the name of the function, as a string. LIBNAME is 0 when + an ordinary C function call is being processed. Thus, each time + this macro is called, either LIBNAME or FNTYPE is nonzero, but + never both of them at once. + +`INIT_CUMULATIVE_INCOMING_ARGS (CUM, FNTYPE, LIBNAME)' + Like `INIT_CUMULATIVE_ARGS' but overrides it for the purposes of + finding the arguments for the function being compiled. If this + macro is undefined, `INIT_CUMULATIVE_ARGS' is used instead. + + The value passed for LIBNAME is always 0, since library routines + with special calling conventions are never compiled with GNU CC. + The argument LIBNAME exists for symmetry with + `INIT_CUMULATIVE_ARGS'. + +`FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)' + A C statement (sans semicolon) to update the summarizer variable + CUM to advance past an argument in the argument list. The values + MODE, TYPE and NAMED describe that argument. Once this is done, + the variable CUM is suitable for analyzing the *following* + argument with `FUNCTION_ARG', etc. + + This macro need not do anything if the argument in question was + passed on the stack. The compiler knows how to track the amount + of stack space used for arguments without any special help. + +`FUNCTION_ARG_PADDING (MODE, TYPE)' + If defined, a C expression which determines whether, and in which + direction, to pad out an argument with extra space. The value + should be of type `enum direction': either `upward' to pad above + the argument, `downward' to pad below, or `none' to inhibit + padding. + + The *amount* of padding is always just enough to reach the next + multiple of `FUNCTION_ARG_BOUNDARY'; this macro does not control + it. + + This macro has a default definition which is right for most + systems. For little-endian machines, the default is to pad + upward. For big-endian machines, the default is to pad downward + for an argument of constant size shorter than an `int', and upward + otherwise. + +`FUNCTION_ARG_BOUNDARY (MODE, TYPE)' + If defined, a C expression that gives the alignment boundary, in + bits, of an argument with the specified mode and type. If it is + not defined, `PARM_BOUNDARY' is used for all arguments. + +`FUNCTION_ARG_REGNO_P (REGNO)' + A C expression that is nonzero if REGNO is the number of a hard + register in which function arguments are sometimes passed. This + does *not* include implicit arguments such as the static chain and + the structure-value address. On many machines, no registers can be + used for this purpose since all function arguments are pushed on + the stack.