--- gcc/gcc.info-19 2018/04/24 18:00:27 1.1.1.1 +++ gcc/gcc.info-19 2018/04/24 18:06:28 1.1.1.2 @@ -1,9 +1,12 @@ -This is Info file gcc.info, produced by Makeinfo-1.49 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 + + 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 @@ -25,1672 +28,1087 @@ permission notice, may be included in tr Software Foundation instead of in the original English.  -File: gcc.info, Node: Index, Prev: Config, Up: Top +File: gcc.info, Node: Condition Code, Next: Costs, Prev: Addressing Modes, Up: Target Macros + +Condition Code Status +===================== + + The file `conditions.h' defines a variable `cc_status' to describe +how the condition code was computed (in case the interpretation of the +condition code depends on the instruction that it was set by). This +variable contains the RTL expressions on which the condition code is +currently based, and several standard flags. + + Sometimes additional machine-specific flags must be defined in the +machine description header file. It can also add additional +machine-specific information by defining `CC_STATUS_MDEP'. + +`CC_STATUS_MDEP' + C code for a data type which is used for declaring the `mdep' + component of `cc_status'. It defaults to `int'. + + This macro is not used on machines that do not use `cc0'. + +`CC_STATUS_MDEP_INIT' + A C expression to initialize the `mdep' field to "empty". The + default definition does nothing, since most machines don't use the + field anyway. If you want to use the field, you should probably + define this macro to initialize it. + + This macro is not used on machines that do not use `cc0'. + +`NOTICE_UPDATE_CC (EXP, INSN)' + A C compound statement to set the components of `cc_status' + appropriately for an insn INSN whose body is EXP. It is this + macro's responsibility to recognize insns that set the condition + code as a byproduct of other activity as well as those that + explicitly set `(cc0)'. + + This macro is not used on machines that do not use `cc0'. + + If there are insns that do not set the condition code but do alter + other machine registers, this macro must check to see whether they + invalidate the expressions that the condition code is recorded as + reflecting. For example, on the 68000, insns that store in address + registers do not set the condition code, which means that usually + `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns. + But suppose that the previous insn set the condition code based + on location `a4@(102)' and the current insn stores a new value in + `a4'. Although the condition code is not changed by this, it will + no longer be true that it reflects the contents of `a4@(102)'. + Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this case + to say that nothing is known about the condition code value. + + The definition of `NOTICE_UPDATE_CC' must be prepared to deal with + the results of peephole optimization: insns whose patterns are + `parallel' RTXs containing various `reg', `mem' or constants which + are just the operands. The RTL structure of these insns is not + sufficient to indicate what the insns actually do. What + `NOTICE_UPDATE_CC' should do when it sees one is just to run + `CC_STATUS_INIT'. + + A possible definition of `NOTICE_UPDATE_CC' is to call a function + that looks at an attribute (*note Insn Attributes::.) named, for + example, `cc'. This avoids having detailed information about + patterns in two places, the `md' file and in `NOTICE_UPDATE_CC'. + +`EXTRA_CC_MODES' + A list of names to be used for additional modes for condition code + values in registers (*note Jump Patterns::.). These names are + added to `enum machine_mode' and all have class `MODE_CC'. By + convention, they should start with `CC' and end with `mode'. + + You should only define this macro if your machine does not use + `cc0' and only if additional modes are required. + +`EXTRA_CC_NAMES' + A list of C strings giving the names for the modes listed in + `EXTRA_CC_MODES'. For example, the Sparc defines this macro and + `EXTRA_CC_MODES' as + + #define EXTRA_CC_MODES CC_NOOVmode, CCFPmode + #define EXTRA_CC_NAMES "CC_NOOV", "CCFP" + + This macro is not required if `EXTRA_CC_MODES' is not defined. + +`SELECT_CC_MODE (OP, X, Y)' + Returns a mode from class `MODE_CC' to be used when comparison + operation code OP is applied to rtx X and Y. For example, on the + Sparc, `SELECT_CC_MODE' is defined as (see *note Jump Patterns::. + for a description of the reason for this definition) + + #define SELECT_CC_MODE(OP,X,Y) \ + (GET_MODE_CLASS (GET_MODE (X)) == MODE_FLOAT \ + ? ((OP == EQ || OP == NE) ? CCFPmode : CCFPEmode) \ + : ((GET_CODE (X) == PLUS || GET_CODE (X) == MINUS \ + || GET_CODE (X) == NEG) \ + ? CC_NOOVmode : CCmode)) + + This macro is not required if `EXTRA_CC_MODES' is not defined. + + +File: gcc.info, Node: Costs, Next: Sections, Prev: Condition Code, Up: Target Macros + +Describing Relative Costs of Operations +======================================= + + These macros let you describe the relative speed of various +operations on the target machine. + +`CONST_COSTS (X, CODE, OUTER_CODE)' + A part of a C `switch' statement that describes the relative costs + of constant RTL expressions. It must contain `case' labels for + expression codes `const_int', `const', `symbol_ref', `label_ref' + and `const_double'. Each case must ultimately reach a `return' + statement to return the relative cost of the use of that kind of + constant value in an expression. The cost may depend on the + precise value of the constant, which is available for examination + in X, and the rtx code of the expression in which it is contained, + found in OUTER_CODE. + + CODE is the expression code--redundant, since it can be obtained + with `GET_CODE (X)'. + +`RTX_COSTS (X, CODE, OUTER_CODE)' + Like `CONST_COSTS' but applies to nonconstant RTL expressions. + This can be used, for example, to indicate how costly a multiply + instruction is. In writing this macro, you can use the construct + `COSTS_N_INSNS (N)' to specify a cost equal to N fast + instructions. OUTER_CODE is the code of the expression in which X + is contained. + + This macro is optional; do not define it if the default cost + assumptions are adequate for the target machine. + +`ADDRESS_COST (ADDRESS)' + An expression giving the cost of an addressing mode that contains + ADDRESS. If not defined, the cost is computed from the ADDRESS + expression and the `CONST_COSTS' values. + + For most CISC machines, the default cost is a good approximation + of the true cost of the addressing mode. However, on RISC + machines, all instructions normally have the same length and + execution time. Hence all addresses will have equal costs. + + In cases where more than one form of an address is known, the form + with the lowest cost will be used. If multiple forms have the + same, lowest, cost, the one that is the most complex will be used. + + For example, suppose an address that is equal to the sum of a + register and a constant is used twice in the same basic block. + When this macro is not defined, the address will be computed in a + register and memory references will be indirect through that + register. On machines where the cost of the addressing mode + containing the sum is no higher than that of a simple indirect + reference, this will produce an additional instruction and + possibly require an additional register. Proper specification of + this macro eliminates this overhead for such machines. + + Similar use of this macro is made in strength reduction of loops. + + ADDRESS need not be valid as an address. In such a case, the cost + is not relevant and can be any value; invalid addresses need not be + assigned a different cost. + + On machines where an address involving more than one register is as + cheap as an address computation involving only one register, + defining `ADDRESS_COST' to reflect this can cause two registers to + be live over a region of code where only one would have been if + `ADDRESS_COST' were not defined in that manner. This effect should + be considered in the definition of this macro. Equivalent costs + should probably only be given to addresses with different numbers + of registers on machines with lots of registers. + + This macro will normally either not be defined or be defined as a + constant. + +`REGISTER_MOVE_COST (FROM, TO)' + A C expression for the cost of moving data from a register in class + FROM to one in class TO. The classes are expressed using the + enumeration values such as `GENERAL_REGS'. A value of 4 is the + default; other values are interpreted relative to that. + + It is not required that the cost always equal 2 when FROM is the + same as TO; on some machines it is expensive to move between + registers if they are not general registers. + + If reload sees an insn consisting of a single `set' between two + hard registers, and if `REGISTER_MOVE_COST' applied to their + classes returns a value of 2, reload does not check to ensure that + the constraints of the insn are met. Setting a cost of other than + 2 will allow reload to verify that the constraints are met. You + should do this if the `movM' pattern's constraints do not allow + such copying. + +`MEMORY_MOVE_COST (M)' + A C expression for the cost of moving data of mode M between a + register and memory. A value of 2 is the default; this cost is + relative to those in `REGISTER_MOVE_COST'. + + If moving between registers and memory is more expensive than + between two registers, you should define this macro to express the + relative cost. + +`BRANCH_COST' + A C expression for the cost of a branch instruction. A value of 1 + is the default; other values are interpreted relative to that. + + Here are additional macros which do not specify precise relative +costs, but only that certain actions are more expensive than GNU CC +would ordinarily expect. + +`SLOW_BYTE_ACCESS' + Define this macro as a C expression which is nonzero if accessing + less than a word of memory (i.e. a `char' or a `short') is no + faster than accessing a word of memory, i.e., if such access + require more than one instruction or if there is no difference in + cost between byte and (aligned) word loads. + + When this macro is not defined, the compiler will access a field by + finding the smallest containing object; when it is defined, a + fullword load will be used if alignment permits. Unless bytes + accesses are faster than word accesses, using word accesses is + preferable since it may eliminate subsequent memory access if + subsequent accesses occur to other fields in the same word of the + structure, but to different bytes. + +`SLOW_ZERO_EXTEND' + Define this macro if zero-extension (of a `char' or `short' to an + `int') can be done faster if the destination is a register that is + known to be zero. + + If you define this macro, you must have instruction patterns that + recognize RTL structures like this: + + (set (strict_low_part (subreg:QI (reg:SI ...) 0)) ...) + + and likewise for `HImode'. + +`SLOW_UNALIGNED_ACCESS' + Define this macro to be the value 1 if unaligned accesses have a + cost many times greater than aligned accesses, for example if they + are emulated in a trap handler. + + When this macro is non-zero, the compiler will act as if + `STRICT_ALIGNMENT' were non-zero when generating code for block + moves. This can cause significantly more instructions to be + produced. Therefore, do not set this macro non-zero if unaligned + accesses only add a cycle or two to the time for a memory access. + + If the value of this macro is always zero, it need not be defined. + +`DONT_REDUCE_ADDR' + Define this macro to inhibit strength reduction of memory + addresses. (On some machines, such strength reduction seems to do + harm rather than good.) + +`MOVE_RATIO' + The number of scalar move insns which should be generated instead + of a string move insn or a library call. Increasing the value + will always make code faster, but eventually incurs high cost in + increased code size. + + If you don't define this, a reasonable default is used. + +`NO_FUNCTION_CSE' + Define this macro if it is as good or better to call a constant + function address than to call an address kept in a register. -Index -***** +`NO_RECURSIVE_FUNCTION_CSE' + Define this macro if it is as good or better for a function to call + itself with an explicit address than to call an address kept in a + register. + +`ADJUST_COST (INSN, LINK, DEP_INSN, COST)' + A C statement (sans semicolon) to update the integer variable COST + based on the relationship between INSN that is dependent on + DEP_INSN through the dependence LINK. The default is to make no + adjustment to COST. This can be used for example to specify to + the scheduler that an output- or anti-dependence does not incur + the same cost as a data-dependence. + + +File: gcc.info, Node: Sections, Next: PIC, Prev: Costs, Up: Target Macros + +Dividing the Output into Sections (Texts, Data, ...) +==================================================== + + An object file is divided into sections containing different types of +data. In the most common case, there are three sections: the "text +section", which holds instructions and read-only data; the "data +section", which holds initialized writable data; and the "bss section", +which holds uninitialized data. Some systems have other kinds of +sections. + + The compiler must tell the assembler when to switch sections. These +macros control what commands to output to tell the assembler this. You +can also define additional sections. + +`TEXT_SECTION_ASM_OP' + A C expression whose value is a string containing the assembler + operation that should precede instructions and read-only data. + Normally `".text"' is right. + +`DATA_SECTION_ASM_OP' + A C expression whose value is a string containing the assembler + operation to identify the following data as writable initialized + data. Normally `".data"' is right. + +`SHARED_SECTION_ASM_OP' + if defined, a C expression whose value is a string containing the + assembler operation to identify the following data as shared data. + If not defined, `DATA_SECTION_ASM_OP' will be used. + +`INIT_SECTION_ASM_OP' + if defined, a C expression whose value is a string containing the + assembler operation to identify the following data as + initialization code. If not defined, GNU CC will assume such a + section does not exist. + +`EXTRA_SECTIONS' + A list of names for sections other than the standard two, which are + `in_text' and `in_data'. You need not define this macro on a + system with no other sections (that GCC needs to use). + +`EXTRA_SECTION_FUNCTIONS' + One or more functions to be defined in `varasm.c'. These + functions should do jobs analogous to those of `text_section' and + `data_section', for your additional sections. Do not define this + macro if you do not define `EXTRA_SECTIONS'. + +`READONLY_DATA_SECTION' + On most machines, read-only variables, constants, and jump tables + are placed in the text section. If this is not the case on your + machine, this macro should be defined to be the name of a function + (either `data_section' or a function defined in `EXTRA_SECTIONS') + that switches to the section to be used for read-only items. + + If these items should be placed in the text section, this macro + should not be defined. + +`SELECT_SECTION (EXP, RELOC)' + A C statement or statements to switch to the appropriate section + for output of EXP. You can assume that EXP is either a `VAR_DECL' + node or a constant of some sort. RELOC indicates whether the + initial value of EXP requires link-time relocations. Select the + section by calling `text_section' or one of the alternatives for + other sections. + + Do not define this macro if you put all read-only variables and + constants in the read-only data section (usually the text section). + +`SELECT_RTX_SECTION (MODE, RTX)' + A C statement or statements to switch to the appropriate section + for output of RTX in mode MODE. You can assume that RTX is some + kind of constant in RTL. The argument MODE is redundant except in + the case of a `const_int' rtx. Select the section by calling + `text_section' or one of the alternatives for other sections. + + Do not define this macro if you put all constants in the read-only + data section. + +`JUMP_TABLES_IN_TEXT_SECTION' + Define this macro if jump tables (for `tablejump' insns) should be + output in the text section, along with the assembler instructions. + Otherwise, the readonly data section is used. + + This macro is irrelevant if there is no separate readonly data + section. + +`ENCODE_SECTION_INFO (DECL)' + Define this macro if references to a symbol must be treated + differently depending on something about the variable or function + named by the symbol (such as what section it is in). + + The macro definition, if any, is executed immediately after the + rtl for DECL has been created and stored in `DECL_RTL (DECL)'. + The value of the rtl will be a `mem' whose address is a + `symbol_ref'. + + The usual thing for this macro to do is to record a flag in the + `symbol_ref' (such as `SYMBOL_REF_FLAG') or to store a modified + name string in the `symbol_ref' (if one bit is not enough + information). + +`STRIP_NAME_ENCODING (VAR, SYM_NAME)' + Decode SYM_NAME and store the real name part in VAR, sans the + characters that encode section info. Define this macro if + `ENCODE_SECTION_INFO' alters the symbol's name string. + + +File: gcc.info, Node: PIC, Next: Assembler Format, Prev: Sections, Up: Target Macros + +Position Independent Code +========================= + + This section describes macros that help implement generation of +position independent code. Simply defining these macros is not enough +to generate valid PIC; you must also add support to the macros +`GO_IF_LEGITIMATE_ADDRESS' and `PRINT_OPERAND_ADDRESS', as well as +`LEGITIMIZE_ADDRESS'. You must modify the definition of `movsi' to do +something appropriate when the source operand contains a symbolic +address. You may also need to alter the handling of switch statements +so that they use relative addresses. + +`PIC_OFFSET_TABLE_REGNUM' + The register number of the register used to address a table of + static data addresses in memory. In some cases this register is + defined by a processor's "application binary interface" (ABI). + When this macro is defined, RTL is generated for this register + once, as with the stack pointer and frame pointer registers. If + this macro is not defined, it is up to the machine-dependent files + to allocate such a register (if necessary). + +`FINALIZE_PIC' + By generating position-independent code, when two different + programs (A and B) share a common library (libC.a), the text of + the library can be shared whether or not the library is linked at + the same address for both programs. In some of these + environments, position-independent code requires not only the use + of different addressing modes, but also special code to enable the + use of these addressing modes. + + The `FINALIZE_PIC' macro serves as a hook to emit these special + codes once the function is being compiled into assembly code, but + not before. (It is not done before, because in the case of + compiling an inline function, it would lead to multiple PIC + prologues being included in functions which used inline functions + and were compiled to assembly language.) + +`LEGITIMATE_PIC_OPERAND_P (X)' + A C expression that is nonzero if X is a legitimate immediate + operand on the target machine when generating position independent + code. You can assume that X satisfies `CONSTANT_P', so you need + not check this. You can also assume FLAG_PIC is true, so you need + not check it either. You need not define this macro if all + constants (including `SYMBOL_REF') can be immediate operands when + generating position independent code. + + +File: gcc.info, Node: Assembler Format, Next: Debugging Info, Prev: PIC, Up: Target Macros + +Defining the Output Assembler Language +====================================== + + This section describes macros whose principal purpose is to describe +how to write instructions in assembler language-rather than what the +instructions do. * 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. -* absM2 instruction pattern: Standard Names. -* abs and attributes: Expressions. -* ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry. -* addM3 instruction pattern: Standard Names. -* addr_diff_vec, length of: Insn Lengths. -* addr_vec, length of: Insn Lengths. -* aligned attribute: Variable Attributes. -* allocate_stack instruction pattern: Standard Names. -* alloca and SunOs: Installation. -* alloca vs variable-length arrays: Variable Length. -* alloca, for SunOs: Sun Install. -* alloca, for Unos: Unos Install. -* andM3 instruction pattern: Standard Names. -* and and attributes: Expressions. -* and, canonicalization of: Insn Canonicalizations. -* ARG_POINTER_REGNUM and virtual registers: Regs and Memory. -* ashiftrt and attributes: Expressions. -* ashift and attributes: Expressions. -* ashlM3 instruction pattern: Standard Names. -* ashrM3 instruction pattern: Standard Names. -* asm_operands, RTL sharing: Sharing. -* asm_operands, usage: Assembler. -* asm expressions: Extended Asm. -* bCOND instruction pattern: Standard Names. -* bcopy, implicit usage: Library Calls. -* BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields. -* BLKmode, and function return values: Calls. -* bzero, implicit usage: Library Calls. -* call_insn and /u: Flags. -* call_pop instruction pattern: Standard Names. -* call_value_pop instruction pattern: Standard Names. -* call_value instruction pattern: Standard Names. -* call instruction pattern: Standard Names. -* call usage: Calls. -* casesi instruction pattern: Standard Names. -* cc0, RTL sharing: Sharing. -* cmpM instruction pattern: Standard Names. -* cmpstrM instruction pattern: Standard Names. -* code_label and /i: Flags. -* compare, canonicalization of: Insn Canonicalizations. -* cond and attributes: Expressions. -* const_double, RTL sharing: Sharing. -* const_int and attribute tests: Expressions. -* const_int and attributes: Expressions. -* const_int, RTL sharing: Sharing. -* const_string and attributes: Expressions. -* const applied to function: Function Attributes. -* define_insn example: Example. -* divM3 instruction pattern: Standard Names. -* divmodM4 instruction pattern: Standard Names. -* div and attributes: Expressions. -* EDOM, implicit usage: Library Calls. -* ENCODE_SECTION_INFO and address validation: Addressing Modes. -* ENCODE_SECTION_INFO usage: Instruction Output. -* eq and attributes: Expressions. -* errno, implicit usage: Library Calls. -* extendMN instruction pattern: Standard Names. -* extv instruction pattern: Standard Names. -* extzv instruction pattern: Standard Names. -* ffsM2 instruction pattern: Standard Names. -* FIRST_PARM_OFFSET and virtual registers: Regs and Memory. -* fixMN2 instruction pattern: Standard Names. -* fixunsMN2 instruction pattern: Standard Names. -* fixuns_truncMN2 instruction pattern: Standard Names. -* fix_truncMN2 instruction pattern: Standard Names. -* floatMN2 instruction pattern: Standard Names. -* floatunsMN2 instruction pattern: Standard Names. -* float as function value type: Incompatibilities. -* format attribute: Function Attributes. -* FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory. -* FRAME_POINTER_REGNUM and virtual registers: Regs and Memory. -* fscanf, and constant strings: Incompatibilities. -* ftruncM2 instruction pattern: Standard Names. -* FUNCTION_EPILOGUE and trampolines: Trampolines. -* FUNCTION_PROLOGUE and trampolines: Trampolines. -* genflags, crash on Sun 4: Installation Problems. -* geu and attributes: Expressions. -* ge and attributes: Expressions. -* gprof: Debugging Options. -* gtu and attributes: Expressions. -* gt and attributes: Expressions. -* HImode, in insn: Insns. -* if_then_else and attributes: Expressions. -* if_then_else usage: Side Effects. -* indirect_jump instruction pattern: Standard Names. -* insn and /i: Flags. -* insn and /s: Flags. -* insn and /u: Flags. -* insv instruction pattern: Standard Names. -* integrated, in insn: Flags. -* integrated, in reg: Flags. -* in_struct, in code_label: Flags. -* in_struct, in insn: Flags. -* in_struct, in insn: Flags. -* in_struct, in label_ref: Flags. -* in_struct, in mem: Flags. -* in_struct, in reg: Flags. -* in_struct, in subreg: Flags. -* iorM3 instruction pattern: Standard Names. -* ior and attributes: Expressions. -* ior, canonicalization of: Insn Canonicalizations. -* label_ref and /s: Flags. -* label_ref, RTL sharing: Sharing. -* leu and attributes: Expressions. -* le and attributes: Expressions. -* load_multiple instruction pattern: Standard Names. -* long long data types: Long Long. -* longjmp and automatic variables: Dialect Options. -* longjmp and automatic variables: Interface. -* 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. -* mode attribute: Variable Attributes. -* mod and attributes: Expressions. -* movM instruction pattern: Standard Names. -* movstrM instruction pattern: Standard Names. -* movstrictM instruction pattern: Standard Names. -* mulM3 instruction pattern: Standard Names. -* mulhisi3 instruction pattern: Standard Names. -* mulqihi3 instruction pattern: Standard Names. -* mulsidi3 instruction pattern: Standard Names. -* mult and attributes: Expressions. -* mult, canonicalization of: Insn Canonicalizations. -* MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments. -* negM2 instruction pattern: Standard Names. -* neg and attributes: Expressions. -* neg, canonicalization of: Insn Canonicalizations. -* ne and attributes: Expressions. -* nop instruction pattern: Standard Names. -* not and attributes: Expressions. -* not, canonicalization of: Insn Canonicalizations. -* one_cmplM2 instruction pattern: Standard Names. -* packed attribute: Variable Attributes. -* pc and attributes: Insn Lengths. -* pc, RTL sharing: Sharing. -* plus and attributes: Expressions. -* plus, canonicalization of: Insn Canonicalizations. -* prof: Debugging Options. -* PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout. -* QImode, in insn: Insns. -* qsort, and global register variables: Global Reg Vars. -* REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments. -* reg and /i: Flags. -* reg and /s: Flags. -* reg and /u: Flags. -* reg and /v: Flags. -* reg, RTL sharing: Sharing. -* reload_in instruction pattern: Standard Names. -* reload_out instruction pattern: Standard Names. -* restore_stack_block instruction pattern: Standard Names. -* restore_stack_function instruction pattern: Standard Names. -* restore_stack_nonlocal instruction pattern: Standard Names. -* return instruction pattern: Standard Names. -* rotlM3 instruction pattern: Standard Names. -* rotrM3 instruction pattern: Standard Names. -* sCOND instruction pattern: Standard Names. -* save_stack_block instruction pattern: Standard Names. -* save_stack_function instruction pattern: Standard Names. -* save_stack_nonlocal instruction pattern: Standard Names. -* scanf, and constant strings: Incompatibilities. -* scratch, RTL sharing: Sharing. -* setjmp incompatibilities: Incompatibilities. -* sign_extract, canonicalization of: Insn Canonicalizations. -* sqrtM2 instruction pattern: Standard Names. -* sscanf, and constant strings: Incompatibilities. -* STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory. -* STACK_POINTER_OFFSET and virtual registers: Regs and Memory. -* STACK_POINTER_REGNUM and virtual registers: Regs and Memory. -* STARTING_FRAME_OFFSET and virtual registers: Regs and Memory. -* subM3 instruction pattern: Standard Names. -* subreg and /s: Flags. -* subreg and /u: Flags. -* subreg, in strict_low_part: RTL Declarations. -* subreg, special reload handling: Regs and Memory. -* SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections. -* symbol_ref and /u: Flags. -* symbol_ref and /v: Flags. -* symbol_ref, RTL sharing: Sharing. -* tablejump instruction pattern: Standard Names. -* tcov: Debugging Options. -* truncMN instruction pattern: Standard Names. -* tstM instruction pattern: Standard Names. -* udivM3 instruction pattern: Standard Names. -* udivmodM4 instruction pattern: Standard Names. -* umaxM3 instruction pattern: Standard Names. -* uminM3 instruction pattern: Standard Names. -* umodM3 instruction pattern: Standard Names. -* umulhisi3 instruction pattern: Standard Names. -* umulqihi3 instruction pattern: Standard Names. -* umulsidi3 instruction pattern: Standard Names. -* unchanging, in call_insn: Flags. -* unchanging, in insn: Flags. -* unchanging, in reg and mem: Flags. -* unchanging, in subreg: Flags. -* unchanging, in symbol_ref: Flags. -* used, in symbol_ref: Flags. -* volatile applied to function: Function Attributes. -* volatil, in insn: Flags. -* volatil, in mem: Flags. -* volatil, in reg: Flags. -* volatil, in symbol_ref: Flags. -* WORDS_BIG_ENDIAN, effect on subreg: Regs and Memory. -* xorM3 instruction pattern: Standard Names. -* xor, canonicalization of: Insn Canonicalizations. -* zero_extendMN instruction pattern: Standard Names. -* zero_extract, canonicalization of: Insn Canonicalizations. -* libgcc.a: Library Calls. -* stdarg.h and register arguments: Register Arguments. -* stdarg.h and RT PC: RT Options. -* tm.h macros: Target Macros. -* varargs.h and RT PC: RT Options. -* VAXCRTL: VMS Misc. -* xm-MACHINE.h: Config. -* ! in constraint: Multi-Alternative. -* # in constraint: Modifiers. -* % in constraint: Modifiers. -* % in template: Output Template. -* & in constraint: Modifiers. -* * in constraint: Modifiers. -* + in constraint: Modifiers. -* /i in RTL dump: Flags. -* /s in RTL dump: Flags. -* /s in RTL dump: Flags. -* /u in RTL dump: Flags. -* /v in RTL dump: Flags. -* 0 in constraint: Simple Constraints. -* < in constraint: Simple Constraints. -* = in constraint: Modifiers. -* > in constraint: Simple Constraints. -* ? in constraint: Multi-Alternative. -* d in constraint: Simple Constraints. -* E in constraint: Simple Constraints. -* F in constraint: Simple Constraints. -* g in constraint: Simple Constraints. -* G in constraint: Simple Constraints. -* H in constraint: Simple Constraints. -* i in constraint: Simple Constraints. -* I in constraint: Simple Constraints. -* m in constraint: Simple Constraints. -* n in constraint: Simple Constraints. -* o in constraint: Simple Constraints. -* p in constraint: Simple Constraints. -* Q, in constraint: Simple Constraints. -* r in constraint: Simple Constraints. -* store_multiple instruction pattern: Standard Names. -* s in constraint: Simple Constraints. -* V in constraint: Simple Constraints. -* X in constraint: Simple Constraints. -* _ in variables in macros: Naming Types. -* abort: Portability. -* abs: Arithmetic. -* absolute value: Arithmetic. -* access to operands: Accessors. -* accessors: Accessors. -* ACCUMULATE_OUTGOING_ARGS: Stack Arguments. -* ADDITIONAL_REGISTER_NAMES: Instruction Output. -* address: RTL Template. -* address constraints: Simple Constraints. -* address of a label: Labels as Values. -* addressing modes: Addressing Modes. -* ADDRESS_COST: Costs. -* address_operand: Simple Constraints. -* addr_diff_vec: Side Effects. -* addr_vec: Side Effects. -* ADJUST_COST: Costs. -* ADJUST_INSN_LENGTH: Insn Lengths. -* aggregates as return values: Aggregate Return. -* alignment: Alignment. -* Alliant: Interoperation. -* ALLOCATE_TRAMPOLINE: Trampolines. -* ALL_REGS: Register Classes. -* alternate keywords: Alternate Keywords. -* AMD29K options: AMD29K Options. -* analysis, data flow: Passes. -* and: Arithmetic. -* ANSI support: Dialect Options. -* apostrophes: Incompatibilities. -* ARGS_GROW_DOWNWARD: Frame Layout. -* argument passing: Interface. -* arguments in frame (88k): M88K Options. -* arguments in registers: Register Arguments. -* arguments on stack: Stack Arguments. -* ARG_POINTER_REGNUM: Frame Registers. -* arg_pointer_rtx: Frame Registers. -* arithmetic libraries: Interface. -* arithmetic shift: Arithmetic. -* arithmetic simplifications: Passes. -* arithmetic, in RTL: Arithmetic. -* arrays of length zero: Zero Length. -* arrays of variable length: Variable Length. -* arrays, non-lvalue: Subscripting. -* ashift: Arithmetic. -* ashiftrt: Arithmetic. -* ASM_APP_OFF: File Framework. -* ASM_APP_ON: File Framework. -* ASM_BYTE_OP: Data Output. -* ASM_CLOSE_PAREN: Data Output. -* ASM_COMMENT_START: File Framework. -* ASM_DECLARE_FUNCTION_NAME: Label Output. -* ASM_DECLARE_FUNCTION_SIZE: Label Output. -* ASM_DECLARE_OBJECT_NAME: Label Output. -* ASM_FILE_END: File Framework. -* ASM_FILE_START: File Framework. -* ASM_FINAL_SPEC: Driver. -* ASM_FORMAT_PRIVATE_NAME: Label Output. -* asm_fprintf: Instruction Output. -* ASM_GENERATE_INTERNAL_LABEL: Label Output. -* ASM_GLOBALIZE_LABEL: Label Output. -* ASM_IDENTIFY_GCC: File Framework. -* asm_input: Side Effects. -* asm_noperands: Insns. -* ASM_NO_SKIP_IN_TEXT: Alignment Output. -* ASM_OPEN_PAREN: Data Output. -* ASM_OUTPUT_ADDR_DIFF_ELT: Dispatch Tables. -* ASM_OUTPUT_ADDR_VEC_ELT: Dispatch Tables. -* ASM_OUTPUT_ALIGN: Alignment Output. -* ASM_OUTPUT_ALIGNED_COMMON: Uninitialized Data. -* ASM_OUTPUT_ALIGNED_LOCAL: Uninitialized Data. -* ASM_OUTPUT_ALIGN_CODE: Alignment Output. -* ASM_OUTPUT_ASCII: Data Output. -* ASM_OUTPUT_BYTE: Data Output. -* ASM_OUTPUT_CASE_END: Dispatch Tables. -* ASM_OUTPUT_CASE_LABEL: Dispatch Tables. -* ASM_OUTPUT_CHAR: Data Output. -* ASM_OUTPUT_COMMON: Uninitialized Data. -* ASM_OUTPUT_CONSTRUCTOR: Macros for Initialization. -* ASM_OUTPUT_DESTRUCTOR: Macros for Initialization. -* ASM_OUTPUT_DOUBLE: Data Output. -* ASM_OUTPUT_DOUBLE_INT: Data Output. -* ASM_OUTPUT_EXTERNAL: Label Output. -* ASM_OUTPUT_EXTERNAL_LIBCALL: Label Output. -* ASM_OUTPUT_FLOAT: Data Output. -* ASM_OUTPUT_IDENT: File Framework. -* ASM_OUTPUT_INT: Data Output. -* ASM_OUTPUT_INTERNAL_LABEL: Label Output. -* ASM_OUTPUT_LABEL: Label Output. -* ASM_OUTPUT_LABELREF: Label Output. -* ASM_OUTPUT_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: DBX Options. -* ASM_STABN_OP: DBX Options. -* ASM_STABS_OP: DBX Options. -* assembler format: File Framework. -* assembler instructions: Extended Asm. -* assembler instructions in RTL: Assembler. -* assembler names for identifiers: Asm Labels. -* assembler syntax, 88k: M88K Options. -* assemble_name: Label Output. -* assembly code, invalid: Bug Criteria. -* assigning attribute values to insns: Tagging Insns. -* asterisk in template: Output Statement. -* atof: Cross-compilation. -* attr: Tagging Insns. -* attribute expressions: Expressions. -* attribute of variables: Variable Attributes. -* attribute specifications: Attr Example. -* attribute specifications example: Attr Example. -* attributes, defining: Defining Attributes. -* autoincrement addressing, availability: Portability. -* autoincrement/decrement addressing: Simple Constraints. -* autoincrement/decrement analysis: Passes. -* backslash: Output Template. -* backtrace for bug reports: Bug Reporting. -* barrier: Insns. -* BASE_REG_CLASS: Register Classes. -* basic blocks: Passes. -* bcmp: Config. -* BIGGEST_ALIGNMENT: Storage Layout. -* BIGGEST_FIELD_ALIGNMENT: Storage Layout. -* Bison parser generator: Installation. -* bit fields: Bit Fields. -* bit shift overflow (88k): M88K Options. -* BITFIELD_NBYTES_LIMITED: Storage Layout. -* BITS_BIG_ENDIAN: Storage Layout. -* BITS_PER_UNIT: Storage Layout. -* BITS_PER_WORD: Storage Layout. -* bitwise complement: Arithmetic. -* bitwise exclusive-or: Arithmetic. -* bitwise inclusive-or: Arithmetic. -* bitwise logical-and: Arithmetic. -* BLKmode: Machine Modes. -* BLOCK_PROFILER: Profiling. -* BRANCH_COST: Costs. -* break_out_memory_refs: Addressing Modes. -* bug criteria: Bug Criteria. -* bug report mailing lists: Bug Lists. -* bugs: Bugs. -* bugs, known: Trouble. -* BYTES_BIG_ENDIAN: Storage Layout. -* BYTE_LOADS_SIGN_EXTEND: Misc. -* BYTE_LOADS_ZERO_EXTEND: Misc. -* byte_mode: Machine Modes. -* bzero: Config. -* C language extensions: Extensions. -* C language, traditional: Dialect Options. -* C statements for assembler output: Output Statement. -* call: Side Effects. -* call-clobbered register: Register Basics. -* call-saved register: Register Basics. -* call-used register: Register Basics. -* CALLER_SAVE_PROFITABLE: Caller Saves. -* calling conventions: Stack and Calling. -* calling functions in RTL: Calls. -* call_insn: Insns. -* CALL_USED_REGISTERS: Register Basics. -* call_used_regs: Register Basics. -* canonicalization of instructions: Insn Canonicalizations. -* CAN_ELIMINATE: Elimination. -* case labels in initializers: Labeled Elements. -* case ranges: Case Ranges. -* case sensitivity and VMS: VMS Misc. -* CASE_DROPS_THROUGH: Misc. -* CASE_VALUES_THRESHOLD: Misc. -* CASE_VECTOR_MODE: Misc. -* CASE_VECTOR_PC_RELATIVE: Misc. -* cast to a union: Cast to Union. -* casts as lvalues: Lvalues. -* cc0: Regs and Memory. -* cc0_rtx: Regs and Memory. -* CC1PLUS_SPEC: Driver. -* CC1_SPEC: Driver. -* CCmode: Machine Modes. -* cc_status: Condition Code. -* CC_STATUS_MDEP: Condition Code. -* CC_STATUS_MDEP_INIT: Condition Code. -* change_address: Standard Names. -* CHAR_TYPE_SIZE: Type Layout. -* CHECK_FLOAT_VALUE: Storage Layout. -* class definitions, register: Register Classes. -* class preference constraints: Class Preferences. -* classes of RTX codes: Accessors. -* CLASS_MAX_NREGS: Register Classes. -* clobber: Side Effects. -* code generation conventions: Code Gen Options. -* code generation RTL sequences: Expander Definitions. -* code motion: Passes. -* codes, RTL expression: RTL Objects. -* code_label: Insns. -* CODE_LABEL_NUMBER: Insns. -* 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. -* COMPILER_PATH: Environment Variables. -* 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. -* CONDITIONAL_REGISTER_USAGE: Register Basics. -* conditions, in patterns: Patterns. -* configuration file: Config. -* conflicting types: Disappointments. -* CONST0_RTX: Constants. -* const0_rtx: Constants. -* CONST1_RTX: Constants. -* const1_rtx: Constants. -* CONST2_RTX: Constants. -* const2_rtx: Constants. -* constant attributes: Constant Attributes. -* constant folding: Passes. -* constant folding and floating point: Cross-compilation. -* constant propagation: Passes. -* constants in constraints: Simple Constraints. -* CONSTANT_ADDRESS_P: Addressing Modes. -* CONSTANT_ALIGNMENT: Storage Layout. -* CONSTANT_P: Addressing Modes. -* CONSTANT_POOL_ADDRESS_P: Flags. -* constm1_rtx: Constants. -* constraint modifier characters: Modifiers. -* constraint, matching: Simple Constraints. -* constraints: Constraints. -* constructor expressions: Constructors. -* constructors, output of: Initialization. -* CONST_CALL_P: Flags. -* CONST_COSTS: Costs. -* const_double: Constants. -* CONST_DOUBLE_CHAIN: Constants. -* CONST_DOUBLE_LOW: Constants. -* CONST_DOUBLE_MEM: Constants. -* CONST_DOUBLE_OK_FOR_LETTER_P: Register Classes. -* const_int: Constants. -* CONST_OK_FOR_LETTER_P: Register Classes. -* const_string: Constants. -* const_true_rtx: Constants. -* contributors: Contributors. -* controlling register usage: Register Basics. -* controlling the compilation driver: Driver. -* conventions, run-time: Interface. -* conversions: Conversions. -* Convex options: Convex Options. -* copy_rtx_if_shared: Sharing. -* core dump: Bug Criteria. -* costs of instructions: Costs. -* COSTS_N_INSNS: Costs. -* CPLUS_INCLUDE_PATH: Environment Variables. -* CPP_PREDEFINES: Run-time Target. -* CPP_SPEC: Driver. -* cross compilation and floating point: Cross-compilation. -* cross compiling: Target Options. -* cross-compiler, installation: Cross-Compiler. -* cross-jumping: Passes. -* CUMULATIVE_ARGS: Register Arguments. -* current_function_epilogue_delay_list: Function Entry. -* current_function_outgoing_args_size: Stack Arguments. -* current_function_pops_args: Function Entry. -* current_function_pretend_args_size: Function Entry. -* C_INCLUDE_PATH: Environment Variables. -* data flow analysis: Passes. -* DATA_ALIGNMENT: Storage Layout. -* data_section: Sections. -* DATA_SECTION_ASM_OP: Sections. -* DBR_OUTPUT_SEQEND: Instruction Output. -* dbr_sequence_length: Instruction Output. -* DBX: Interoperation. -* DBX_CONTIN_CHAR: DBX Options. -* DBX_CONTIN_LENGTH: DBX Options. -* DBX_DEBUGGING_INFO: DBX Options. -* DBX_FUNCTION_FIRST: DBX Options. -* DBX_LBRAC_FIRST: DBX Options. -* DBX_MEMPARM_STABS_LETTER: DBX Options. -* DBX_NO_XREFS: DBX Options. -* DBX_OUTPUT_ENUM: DBX Hooks. -* DBX_OUTPUT_FUNCTION_END: DBX Hooks. -* DBX_OUTPUT_LBRAC: DBX Hooks. -* DBX_OUTPUT_MAIN_SOURCE_DIRECTORY: File Names and DBX. -* DBX_OUTPUT_MAIN_SOURCE_FILENAME: File Names and DBX. -* DBX_OUTPUT_MAIN_SOURCE_FILE_END: File Names and DBX. -* DBX_OUTPUT_RBRAC: DBX Hooks. -* DBX_OUTPUT_SOURCE_FILENAME: File Names and DBX. -* DBX_OUTPUT_STANDARD_TYPES: DBX Hooks. -* DBX_REGISTER_NUMBER: All Debuggers. -* DBX_REGPARM_STABS_CODE: DBX Options. -* DBX_REGPARM_STABS_LETTER: DBX Options. -* DBX_STATIC_CONST_VAR_CODE: DBX Options. -* DBX_STATIC_STAB_DATA_SECTION: DBX Options. -* DBX_TYPE_DECL_STABS_CODE: DBX Options. -* DBX_WORKING_DIRECTORY: File Names and DBX. -* DCmode: Machine Modes. -* De Morgan's law: Insn Canonicalizations. -* dead code: Passes. -* dead_or_set_p: Peephole Definitions. -* deallocating variable length arrays: Variable Length. -* death notes: Obsolete Register Macros. -* DEBUGGER_ARG_OFFSET: All Debuggers. -* DEBUGGER_AUTO_OFFSET: All Debuggers. -* debugging information generation: Passes. -* debugging information options: Debugging Options. -* debugging, 88k OCS: M88K Options. -* debug_rtx: Bug Reporting. -* DEBUG_SYMS_TEXT: DBX Options. -* declaration scope: Incompatibilities. -* declarations inside expressions: Statement Exprs. -* declarations, RTL: RTL Declarations. -* declaring attributes of functions: Function Attributes. -* DEFAULT_CALLER_SAVES: Caller Saves. -* DEFAULT_GDB_EXTENSIONS: DBX Options. -* DEFAULT_MAIN_RETURN: Misc. -* DEFAULT_SHORT_ENUMS: Type Layout. -* DEFAULT_SIGNED_CHAR: Type Layout. -* define_asm_attributes: Tagging Insns. -* define_attr: Defining Attributes. -* define_delay: Delay Slots. -* define_expand: Expander Definitions. -* define_function_unit: Function Units. -* define_insn: Patterns. -* define_peephole: Expander Definitions. -* define_split: Insn Splitting. -* defining attributes and their values: Defining Attributes. -* defining jump instruction patterns: Jump Patterns. -* defining peephole optimizers: Peephole Definitions. -* defining RTL sequences for code generation: Expander Definitions. -* delay slots, defining: Delay Slots. -* delayed branch scheduling: Passes. -* DELAY_SLOTS_FOR_EPILOGUE: Function Entry. -* dependencies for make as output: Environment Variables. -* dependencies, make: Preprocessor Options. -* DEPENDENCIES_OUTPUT: Environment Variables. -* Dependent Patterns: Dependent Patterns. -* destructors, output of: Initialization. -* DFmode: Machine Modes. -* dialect options: Dialect Options. -* digits in constraint: Simple Constraints. -* DImode: Machine Modes. -* directory options: Directory Options. -* disabling certain registers: Register Basics. -* dispatch table: Dispatch Tables. -* div: Arithmetic. -* DIVDI3_LIBCALL: Library Calls. -* divide instruction, 88k: M88K Options. -* division: Arithmetic. -* division: Arithmetic. -* division: Arithmetic. -* DIVSI3_LIBCALL: Library Calls. -* dollar signs in identifier names: Dollar Signs. -* DOLLARS_IN_IDENTIFIERS: Misc. -* DONE: Expander Definitions. -* DONT_REDUCE_ADDR: Costs. -* double-word arithmetic: Long Long. -* DOUBLE_TYPE_SIZE: Type Layout. -* downward funargs: Nested Functions. -* driver: Driver. -* DWARF_DEBUGGING_INFO: SDB and DWARF. -* DYNAMIC_CHAIN_ADDRESS: Frame Layout. -* EASY_DIV_EXPR: Misc. -* ELIGIBLE_FOR_EPILOGUE_DELAY: Function Entry. -* ELIMINABLE_REGS: Elimination. -* empty constraints: No Constraints. -* EMPTY_FIELD_BOUNDARY: Storage Layout. -* ENCODE_SECTION_INFO: Sections. -* ENDFILE_SPEC: Driver. -* endianness: Portability. -* enum machine_mode: Machine Modes. -* enum reg_class: Register Classes. -* environment variables: Environment Variables. -* epilogue: Function Entry. -* eq: Comparisons. -* equal: Comparisons. -* eq_attr: Expressions. -* error: Storage Layout. -* exclamation point: Multi-Alternative. -* exclusive-or, bitwise: Arithmetic. -* EXECUTABLE_SUFFIX: Config. -* exit status and VMS: VMS Misc. -* EXIT_BODY: Misc. -* EXIT_IGNORE_STACK: Function Entry. -* expander definitions: Expander Definitions. -* EXPAND_BUILTIN_SAVEREGS: Varargs. -* explicit register variables: Explicit Reg Vars. -* expression codes: RTL Objects. -* expressions containing statements: Statement Exprs. -* expressions, compound, as lvalues: Lvalues. -* expressions, conditional, as lvalues: Lvalues. -* expressions, constructor: Constructors. -* expr_list: Insns. -* extended asm: Extended Asm. -* extensible constraints: Simple Constraints. -* extensions, ?:: Conditionals. -* extensions, ?:: Lvalues. -* extensions, C language: Extensions. -* extern int target_flags: Run-time Target. -* external declaration scope: Incompatibilities. -* EXTRA_CC_MODES: Condition Code. -* EXTRA_CC_NAMES: Condition Code. -* EXTRA_CONSTRAINT: Register Classes. -* EXTRA_SECTIONS: Sections. -* EXTRA_SECTION_FUNCTIONS: Sections. -* FAIL: Expander Definitions. -* FAILURE_EXIT_CODE: Config. -* 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. -* FINALIZE_PIC: PIC. -* FINAL_PRESCAN_INSN: Instruction Output. -* FINAL_REG_PARM_STACK_SPACE: Stack Arguments. -* final_scan_insn: Function Entry. -* final_sequence: Instruction Output. -* FIRST_INSN_ADDRESS: Insn Lengths. -* FIRST_PARM_OFFSET: Frame Layout. -* FIRST_PSEUDO_REGISTER: Register Basics. -* FIRST_STACK_REG: Stack Registers. -* FIRST_VIRTUAL_REGISTER: Regs and Memory. -* fix: Conversions. -* fix: Conversions. -* fixed register: Register Basics. -* FIXED_REGISTERS: Register Basics. -* fixed_regs: Register Basics. -* FIXUNS_TRUNC_LIKE_FIX_TRUNC: Misc. -* flags in RTL expression: Flags. -* float: Conversions. -* FLOATIFY: Library Calls. -* floating point format and cross compilation: Cross-compilation. -* FLOAT_ARG_TYPE: Library Calls. -* float_extend: Conversions. -* FLOAT_STORE_FLAG_VALUE: Misc. -* float_truncate: Conversions. -* FLOAT_TYPE_SIZE: Type Layout. -* FLOAT_VALUE_TYPE: Library Calls. -* force_reg: Standard Names. -* frame layout: Frame Layout. -* FRAME_GROWS_DOWNWARD: Frame Layout. -* frame_pointer_needed: Function Entry. -* FRAME_POINTER_REGNUM: Frame Registers. -* FRAME_POINTER_REQUIRED: Elimination. -* frame_pointer_rtx: Frame Registers. -* function attributes: Function Attributes. -* function call conventions: Interface. -* function entry and exit: Function Entry. -* function pointers, arithmetic: Pointer Arith. -* function prototype declarations: Function Prototypes. -* function units, for scheduling: Function Units. -* function, size of pointer to: Pointer Arith. -* function-call insns: Calls. -* functions that have no side effects: Function Attributes. -* functions that never return: Function Attributes. -* functions, leaf: Leaf Functions. -* 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. -* ge: Comparisons. -* gencodes: Passes. -* genconfig: Passes. -* generalized lvalues: Lvalues. -* general_operand: RTL Template. -* GENERAL_REGS: Register Classes. -* generating assembler output: Output Statement. -* generating insns: RTL Template. -* genflags: Passes. -* GEN_ERRNO_RTX: Library Calls. -* get_attr: Expressions. -* get_attr_length: Insn Lengths. -* GET_CLASS_NARROWEST_MODE: Machine Modes. -* GET_CODE: RTL Objects. -* get_frame_size: Elimination. -* get_insns: Insns. -* get_last_insn: Insns. -* GET_MODE: Machine Modes. -* GET_MODE_ALIGNMENT: Machine Modes. -* GET_MODE_BITSIZE: Machine Modes. -* GET_MODE_CLASS: Machine Modes. -* GET_MODE_MASK: Machine Modes. -* GET_MODE_NAME: Machine Modes. -* GET_MODE_NUNITS: Machine Modes. -* GET_MODE_SIZE: Machine Modes. -* GET_MODE_UNIT_SIZE: Machine Modes. -* GET_MODE_WIDER_MODE: Machine Modes. -* GET_RTX_CLASS: Accessors. -* GET_RTX_FORMAT: Accessors. -* GET_RTX_LENGTH: Accessors. -* geu: Comparisons. -* global offset table: Code Gen Options. -* global register after longjmp: Global Reg Vars. -* global register allocation: Passes. -* global register variables: Global Reg Vars. -* GLOBALDEF: Global Declarations. -* GLOBALREF: Global Declarations. -* GLOBALVALUEDEF: Global Declarations. -* GLOBALVALUEREF: Global Declarations. -* GNU CC and portability: Portability. -* GNU CC command options: Invoking GCC. -* GNU extensions to the C language: Extensions. -* goto with computed label: Labels as Values. -* GO_IF_LEGITIMATE_ADDRESS: Addressing Modes. -* GO_IF_MODE_DEPENDENT_ADDRESS: Addressing Modes. -* gp-relative references (MIPS): MIPS Options. -* greater than: Comparisons. -* greater than: Comparisons. -* greater than: Comparisons. -* grouping options: Invoking GCC. -* gt: Comparisons. -* gtu: Comparisons. -* HANDLE_PRAGMA: Misc. -* hard registers: Regs and Memory. -* hardware models and configurations, specifying: Submodel Options. -* HARD_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_PUTENV: Config. -* HAVE_VPRINTF: Config. -* header files and VMS: Include Files and VMS. -* high: Constants. -* HImode: Machine Modes. -* HOST_BITS_PER_CHAR: Config. -* HOST_BITS_PER_INT: Config. -* HOST_BITS_PER_LONG: Config. -* HOST_BITS_PER_SHORT: Config. -* HOST_FLOAT_FORMAT: Config. -* HOST_WORDS_BIG_ENDIAN: Config. -* HPPA Options: HPPA Options. -* i386 Options: i386 Options. -* IBM RS/6000 Options: RS/6000 Options. -* IBM RT options: RT Options. -* IBM RT PC: Interoperation. -* identifier names, dollar signs in: Dollar Signs. -* identifiers, names in assembler code: Asm Labels. -* identifying source, compiler (88k): M88K Options. -* IEEE_FLOAT_FORMAT: Storage Layout. -* if_then_else: Comparisons. -* immediate_operand: RTL Template. -* IMMEDIATE_PREFIX: Instruction Output. -* IMPLICIT_FIX_EXPR: Misc. -* include files and VMS: Include Files and VMS. -* INCLUDE_DEFAULTS: Driver. -* inclusive-or, bitwise: Arithmetic. -* incompatibilities of GNU CC: Incompatibilities. -* increment operators: Bug Criteria. -* INDEX_REG_CLASS: Register Classes. -* initialization routines: Initialization. -* initializations in expressions: Constructors. -* initializers with labeled elements: Labeled Elements. -* initializers, non-constant: Initializers. -* INITIALIZE_TRAMPOLINE: Trampolines. -* INITIAL_ELIMINATION_OFFSET: Elimination. -* INITIAL_FRAME_POINTER_OFFSET: Elimination. -* INIT_CUMULATIVE_ARGS: Register Arguments. -* INIT_CUMULATIVE_INCOMING_ARGS: Register Arguments. -* INIT_SECTION_ASM_OP: Sections. -* INIT_SECTION_ASM_OP: Macros for Initialization. -* 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. -* insns: Insns. -* insns, generating: RTL Template. -* insns, recognizing: RTL Template. -* INSN_ANNULLED_BRANCH_P: Flags. -* INSN_CACHE_DEPTH: Trampolines. -* INSN_CACHE_LINE_WIDTH: Trampolines. -* INSN_CACHE_SIZE: Trampolines. -* INSN_CLOBBERS_REGNO_P: Obsolete Register Macros. -* INSN_CODE: Insns. -* INSN_DELETED_P: Flags. -* INSN_FROM_TARGET_P: Flags. -* insn_list: Insns. -* INSN_UID: Insns. -* installation trouble: Trouble. -* installing GNU CC: Installation. -* installing GNU CC on the 3b1: 3b1 Install. -* installing GNU CC on the Sun: Sun Install. -* installing GNU CC on Unos: Unos Install. -* installing GNU CC on VMS: VMS Install. -* instruction attributes: Insn Attributes. -* instruction combination: Passes. -* instruction patterns: Patterns. -* instruction recognizer: Passes. -* instruction scheduling: Passes. -* instruction scheduling: Passes. -* instruction splitting: Insn Splitting. -* integrated: Flags. -* INTEGRATE_THRESHOLD: Misc. -* integrating function code: Inline. -* Intel 386 Options: i386 Options. -* Interdependence of Patterns: Dependent Patterns. -* interfacing to GNU CC output: Interface. -* INTIFY: Library Calls. -* introduction: Top. -* INT_TYPE_SIZE: Type Layout. -* invalid assembly code: Bug Criteria. -* invalid input: Bug Criteria. -* in_data: Sections. -* in_struct: Flags. -* in_text: Sections. -* 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. -* JUMP_LABEL: Insns. -* JUMP_TABLES_IN_TEXT_SECTION: Sections. -* keywords, alternate: Alternate Keywords. -* known causes of trouble: Trouble. -* labeled elements in initializers: Labeled Elements. -* labels as values: Labels as Values. -* LABEL_NUSES: Insns. -* LABEL_OUTSIDE_LOOP_P: Flags. -* LABEL_PRESERVE_P: Flags. -* label_ref: Constants. -* language dialect options: Dialect Options. -* large bit shifts (88k): M88K Options. -* large return values: Aggregate Return. -* LAST_STACK_REG: Stack Registers. -* LAST_VIRTUAL_REGISTER: Regs and Memory. -* ldexp: Cross-compilation. -* le: Comparisons. -* leaf functions: Leaf Functions. -* leaf_function: Leaf Functions. -* leaf_function_p: Standard Names. -* LEAF_REGISTERS: Leaf Functions. -* LEAF_REG_REMAP: Leaf Functions. -* left rotate: Arithmetic. -* left shift: Arithmetic. -* left shift: Arithmetic. -* LEGITIMATE_CONSTANT_P: Addressing Modes. -* LEGITIMATE_PIC_OPERAND_P: PIC. -* LEGITIMIZE_ADDRESS: Addressing Modes. -* length-zero arrays: Zero Length. -* less than: Comparisons. -* less than or equal: Comparisons. -* leu: Comparisons. -* LIBCALL_VALUE: Scalar Return. -* LIBGCC_NEEDS_DOUBLE: Library Calls. -* Libraries: Link Options. -* library subroutine names: Library Calls. -* LIBRARY_PATH: Environment Variables. -* LIB_SPEC: Driver. -* LIMIT_RELOAD_CLASS: Register Classes. -* link options: Link Options. -* LINK_LIBGCC_SPECIAL: Driver. -* LINK_SPEC: Driver. -* 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. -* LOCAL_INCLUDE_DIR: Driver. -* LOCAL_LABEL_PREFIX: Instruction Output. -* logical shift: Arithmetic. -* logical-and, bitwise: Arithmetic. -* LOG_LINKS: Insns. -* longjmp: Global Reg Vars. -* LONGJMP_RESTORE_FROM_STACK: Elimination. -* LONG_DOUBLE_TYPE_SIZE: Type Layout. -* LONG_LONG_TYPE_SIZE: Type Layout. -* LONG_TYPE_SIZE: Type Layout. -* loop optimization: Passes. -* lo_sum: Arithmetic. -* lshift: Arithmetic. -* lshiftrt: Arithmetic. -* lt: Comparisons. -* ltu: Comparisons. -* lvalues, generalized: Lvalues. -* M680x0 options: M680x0 Options. -* M88k options: M88K Options. -* machine dependent options: Submodel Options. -* machine description macros: Target Macros. -* machine descriptions: Machine Desc. -* machine mode conversions: Conversions. -* machine modes: Machine Modes. -* macro with variable arguments: Macro Varargs. -* macros containing asm: Extended Asm. -* macros, inline alternative: Inline. -* macros, local labels: Local Labels. -* macros, local variables in: Naming Types. -* macros, statements in expressions: Statement Exprs. -* macros, target description: Target Macros. -* macros, types of arguments: Typeof. -* make: Preprocessor Options. -* make_safe_from: Expander Definitions. -* matching constraint: Simple Constraints. -* matching operands: Output Template. -* match_dup: RTL Template. -* match_operand: RTL Template. -* match_operator: RTL Template. -* match_op_dup: RTL Template. -* match_parallel: RTL Template. -* match_par_dup: RTL Template. -* match_scratch: RTL Template. -* math libraries: Interface. -* math, in RTL: Arithmetic. -* MAX_BITS_PER_WORD: Storage Layout. -* MAX_FIXED_MODE_SIZE: Storage Layout. -* MAX_OFILE_ALIGNMENT: Storage Layout. -* MAX_REGS_PER_ADDRESS: Addressing Modes. -* MAYBE_REG_PARM_STACK_SPACE: Stack Arguments. -* mcount: Profiling. -* MD_CALL_PROTOTYPES: Config. -* MD_EXEC_PREFIX: Driver. -* MD_STARTFILE_PREFIX: Driver. -* MD_STARTFILE_PREFIX_1: Driver. -* mem: Regs and Memory. -* memory reference, nonoffsettable: Simple Constraints. -* memory references in constraints: Simple Constraints. -* MEMORY_MOVE_COST: Costs. -* MEM_IN_STRUCT_P: Flags. -* MEM_VOLATILE_P: Flags. -* messages, warning: Warning Options. -* middle-operands, omitted: Conditionals. -* minus: Arithmetic. -* MIPS options: MIPS Options. -* mod: Arithmetic. -* MODDI3_LIBCALL: Library Calls. -* mode classes: Machine Modes. -* MODES_TIEABLE_P: Values in Registers. -* MODE_CC: Machine Modes. -* MODE_COMPLEX_FLOAT: Machine Modes. -* MODE_COMPLEX_INT: Machine Modes. -* MODE_FLOAT: Machine Modes. -* MODE_FUNCTION: Machine Modes. -* MODE_INT: Machine Modes. -* MODE_PARTIAL_INT: Machine Modes. -* MODE_RANDOM: Machine Modes. -* modifiers in constraints: Modifiers. -* MODSI3_LIBCALL: Library Calls. -* MOVE_MAX: Misc. -* MOVE_RATIO: Costs. -* MULDI3_LIBCALL: Library Calls. -* MULSI3_LIBCALL: Library Calls. -* mult: Arithmetic. -* MULTIBYTE_CHARS: Config. -* multiple alternative constraints: Multi-Alternative. -* multiplication: Arithmetic. -* multiprecision arithmetic: Long Long. -* name augmentation: VMS Misc. -* named patterns and conditions: Patterns. -* 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. -* NEXT_INSN: Insns. -* NEXT_OBJC_RUNTIME: Library Calls. -* nil: RTL Objects. -* no constraints: No Constraints. -* no-op move instructions: Passes. -* non-constant initializers: Initializers. -* non-static inline function: Inline. -* nongcc_SI_type: Library Calls. -* nonoffsettable memory reference: Simple Constraints. -* NON_SAVING_SETJMP: Register Basics. -* not: Arithmetic. -* not equal: Comparisons. -* not using constraints: No Constraints. -* note: Insns. -* NOTE_INSN_BLOCK_BEG: Insns. -* NOTE_INSN_BLOCK_END: Insns. -* NOTE_INSN_DELETED: Insns. -* NOTE_INSN_FUNCTION_END: Insns. -* NOTE_INSN_LOOP_BEG: Insns. -* NOTE_INSN_LOOP_CONT: Insns. -* NOTE_INSN_LOOP_END: Insns. -* NOTE_INSN_LOOP_VTOP: Insns. -* NOTE_INSN_SETJMP: Insns. -* NOTE_LINE_NUMBER: Insns. -* NOTE_SOURCE_FILE: Insns. -* NOTICE_UPDATE_CC: Condition Code. -* NO_DOLLAR_IN_LABEL: Misc. -* NO_FUNCTION_CSE: Costs. -* NO_MD_PROTOTYPES: Config. -* NO_RECURSIVE_FUNCTION_CSE: Costs. -* NO_REGS: Register Classes. -* NO_STAB_H: Config. -* NO_SYS_SIGLIST: Config. -* NUM_MACHINE_MODES: Machine Modes. -* N_REG_CLASSES: Register Classes. -* OBJC_GEN_METHOD_LABEL: Label Output. -* OBJC_INCLUDE_PATH: Environment Variables. -* OBJC_INT_SELECTORS: Type Layout. -* OBJC_PROLOGUE: File Framework. -* OBJC_SELECTORS_WITHOUT_LABELS: Type Layout. -* OBJECT_FORMAT_COFF: Macros for Initialization. -* OBJECT_FORMAT_ROSE: Macros for Initialization. -* OBSTACK_CHUNK_ALLOC: Config. -* OBSTACK_CHUNK_FREE: Config. -* OBSTACK_CHUNK_SIZE: Config. -* obstack_free: 3b1 Install. -* OCS (88k): M88K Options. -* offsettable address: Simple Constraints. -* old-style function definitions: Function Prototypes. -* omitted middle-operands: Conditionals. -* ONLY_INT_FIELDS: Config. -* open coding: Inline. -* operand access: Accessors. -* operand constraints: Constraints. -* operand substitution: Output Template. -* operands: Patterns. -* OPTIMIZATION_OPTIONS: Run-time Target. -* optimize options: Optimize Options. -* optional hardware or system features: Run-time Target. -* options to control warnings: Warning Options. -* options, code generation: Code Gen Options. -* options, debugging: Debugging Options. -* options, dialect: Dialect Options. -* options, directory search: Directory Options. -* options, GNU CC command: Invoking GCC. -* options, grouping: Invoking GCC. -* options, linking: Link Options. -* options, optimization: Optimize Options. -* options, order: Invoking GCC. -* options, preprocessor: Preprocessor Options. -* order of options: Invoking GCC. -* order of register allocation: Allocation Order. -* Ordering of Patterns: Pattern Ordering. -* ORDER_REGS_FOR_LOCAL_ALLOC: Allocation Order. -* other directory, compilation in: Other Dir. -* OUTGOING_REG_PARM_STACK_SPACE: Stack Arguments. -* output file option: Overall Options. -* output of assembler code: File Framework. -* output statements: Output Statement. -* output templates: Output Template. -* output_addr_const: Data Output. -* output_asm_insn: Output Statement. -* overflow while constant folding: Cross-compilation. -* OVERLAPPING_REGNO_P: Obsolete Register Macros. -* OVERRIDE_OPTIONS: Run-time Target. -* parallel: Side Effects. -* parameter forward declaration: Variable Length. -* parameters, miscellaneous: Misc. -* PARM_BOUNDARY: Storage Layout. -* parser generator, Bison: Installation. -* parsing pass: Passes. -* passes and files of the compiler: Passes. -* passing arguments: Interface. -* PATTERN: Insns. -* pattern conditions: Patterns. -* pattern names: Standard Names. -* Pattern Ordering: Pattern Ordering. -* patterns: Patterns. -* pc: Regs and Memory. -* PCC_BITFIELD_TYPE_MATTERS: Storage Layout. -* PCC_STATIC_STRUCT_RETURN: Aggregate Return. -* pc_rtx: Regs and Memory. -* PDImode: Machine Modes. -* peephole optimization: Passes. -* peephole optimization, RTL representation: Side Effects. -* peephole optimizer definitions: Peephole Definitions. -* percent sign: Output Template. -* perform_...: Library Calls. -* PIC: Code Gen Options. -* PIC: PIC. -* PIC_OFFSET_TABLE_REGNUM: PIC. -* plus: Arithmetic. -* Pmode: Misc. -* pointer arguments: Function Attributes. -* POINTER_SIZE: Storage Layout. -* portability: Portability. -* position independent code: PIC. -* post_dec: Incdec. -* post_inc: Incdec. -* pragma: Misc. -* pragma, reason for not using: Function Attributes. -* predefined macros: Run-time Target. -* PREDICATE_CODES: Misc. -* PREFERRED_OUTPUT_RELOAD_CLASS: Register Classes. -* PREFERRED_RELOAD_CLASS: Register Classes. -* preprocessor options: Preprocessor Options. -* PRESERVE_DEATH_INFO_REGNO_P: Obsolete Register Macros. -* prev_cc0_setter: Jump Patterns. -* PREV_INSN: Insns. -* prev_nonnote_insn: Peephole Definitions. -* pre_dec: Incdec. -* pre_inc: Incdec. -* PRINT_OPERAND: Instruction Output. -* PRINT_OPERAND_ADDRESS: Instruction Output. -* PRINT_OPERAND_PUNCT_VALID_P: Instruction Output. -* product: Arithmetic. -* PROFILE_BEFORE_PROLOGUE: Profiling. -* profiling, code generation: Profiling. -* program counter: Regs and Memory. -* prologue: Function Entry. -* PROMOTE_FUNCTION_ARGS: Storage Layout. -* PROMOTE_FUNCTION_RETURN: Storage Layout. -* PROMOTE_MODE: Storage Layout. -* PROMOTE_PROTOTYPES: Stack Arguments. -* promotion of formal parameters: Function Prototypes. -* pseudo registers: Regs and Memory. -* PSImode: Machine Modes. -* PTRDIFF_TYPE: Type Layout. -* push address instruction: Simple Constraints. -* PUSH_ROUNDING: Stack Arguments. -* putenv: Config. -* PUT_CODE: RTL Objects. -* PUT_MODE: Machine Modes. -* PUT_REG_NOTE_KIND: Insns. -* PUT_SDB_...: SDB and DWARF. -* QImode: Machine Modes. -* question mark: Multi-Alternative. -* quotient: Arithmetic. -* r0-relative references (88k): M88K Options. -* ranges in case statements: Case Ranges. -* read-only strings: Incompatibilities. -* READONLY_DATA_SECTION: Sections. -* REAL_ARITHMETIC: Cross-compilation. -* REAL_INFINITY: Cross-compilation. -* REAL_NM_FILE_NAME: Macros for Initialization. -* REAL_VALUES_EQUAL: Cross-compilation. -* REAL_VALUES_LESS: Cross-compilation. -* REAL_VALUE_ATOF: Cross-compilation. -* REAL_VALUE_FIX: Cross-compilation. -* REAL_VALUE_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. -* recognizing insns: RTL Template. -* recog_operand: Instruction Output. -* reg: Regs and Memory. -* register allocation: Passes. -* register allocation order: Allocation Order. -* register allocation, stupid: Passes. -* register class definitions: Register Classes. -* register class preference constraints: Class Preferences. -* register class preference pass: Passes. -* register pairs: Values in Registers. -* register positions in frame (88k): M88K Options. -* register positions in frame (88k): M88K Options. -* Register Transfer Language (RTL): RTL. -* register usage: Registers. -* register use analysis: Passes. -* register variable after longjmp: Global Reg Vars. -* register-to-stack conversion: Passes. -* registers: Extended Asm. -* registers arguments: Register Arguments. -* registers for local variables: Local Reg Vars. -* registers in constraints: Simple Constraints. -* registers, global allocation: Explicit Reg Vars. -* registers, global variables in: Global Reg Vars. -* REGISTER_MOVE_COST: Costs. -* REGISTER_NAMES: Instruction Output. -* register_operand: RTL Template. -* REGISTER_PREFIX: Instruction Output. -* REGNO_OK_FOR_BASE_P: Register Classes. -* REGNO_OK_FOR_INDEX_P: Register Classes. -* REGNO_REG_CLASS: Register Classes. -* regs_ever_live: Function Entry. -* REG_ALLOC_ORDER: Allocation Order. -* REG_CC_SETTER: Insns. -* REG_CC_USER: Insns. -* REG_CLASS_CONTENTS: Register Classes. -* REG_CLASS_FROM_LETTER: Register Classes. -* REG_CLASS_NAMES: Register Classes. -* REG_DEAD: Insns. -* REG_DEP_ANTI: Insns. -* REG_DEP_OUTPUT: Insns. -* REG_EQUAL: Insns. -* REG_EQUIV: Insns. -* REG_FUNCTION_VALUE_P: Flags. -* REG_INC: Insns. -* REG_LABEL: Insns. -* REG_LEAF_ALLOC_ORDER: Leaf Functions. -* REG_LIBCALL: Insns. -* REG_LOOP_TEST_P: Flags. -* reg_names: Instruction Output. -* REG_NONNEG: Insns. -* REG_NOTES: Insns. -* REG_NOTE_KIND: Insns. -* REG_NO_CONFLICT: Insns. -* REG_OK_FOR_BASE_P: Addressing Modes. -* REG_OK_FOR_INDEX_P: Addressing Modes. -* REG_OK_STRICT: Addressing Modes. -* REG_PARM_STACK_SPACE: Stack Arguments. -* REG_RETVAL: Insns. -* REG_UNUSED: Insns. -* REG_USERVAR_P: Flags. -* REG_WAS_0: Insns. -* relative costs: Costs. -* RELATIVE_PREFIX_NOT_LINKDIR: Driver. -* reload pass: Regs and Memory. -* reloading: Passes. -* reload_completed: Standard Names. -* reload_in_progress: Standard Names. -* remainder: Arithmetic. -* reporting bugs: Bugs. -* representation of RTL: RTL. -* rest argument (in macro): Macro Varargs. -* rest_of_compilation: Passes. -* rest_of_decl_compilation: Passes. -* return: Side Effects. -* return value of main: VMS Misc. -* return values in registers: Scalar Return. -* returning aggregate values: Aggregate Return. -* returning structures and unions: Interface. -* RETURN_IN_MEMORY: Aggregate Return. -* RETURN_POPS_ARGS: Stack Arguments. -* right rotate: Arithmetic. -* right shift: Arithmetic. -* rotate: Arithmetic. -* rotate: Arithmetic. -* rotatert: Arithmetic. -* ROUND_TYPE_ALIGN: Storage Layout. -* ROUND_TYPE_SIZE: Storage Layout. -* RS/6000 Options: RS/6000 Options. -* RT options: RT Options. -* RT PC: Interoperation. -* RTL addition: Arithmetic. -* RTL comparison: Arithmetic. -* RTL comparison operations: Comparisons. -* RTL constant expression types: Constants. -* RTL constants: Constants. -* RTL declarations: RTL Declarations. -* RTL difference: Arithmetic. -* RTL expression: RTL Objects. -* RTL expressions for arithmetic: Arithmetic. -* RTL format: Accessors. -* RTL format characters: Accessors. -* RTL function-call insns: Calls. -* RTL generation: Passes. -* RTL insn template: RTL Template. -* RTL integers: RTL Objects. -* RTL memory expressions: Regs and Memory. -* RTL object types: RTL Objects. -* RTL postdecrement: Incdec. -* RTL postincrement: Incdec. -* RTL predecrement: Incdec. -* RTL preincrement: Incdec. -* RTL register expressions: Regs and Memory. -* RTL representation: RTL. -* RTL side effect expressions: Side Effects. -* RTL strings: RTL Objects. -* RTL structure sharing assumptions: Sharing. -* RTL subtraction: Arithmetic. -* RTL sum: Arithmetic. -* RTL vectors: RTL Objects. -* RTX (See RTL): RTL Objects. -* RTX_COSTS: Costs. -* RTX_INTEGRATED_P: Flags. -* RTX_UNCHANGING_P: Flags. -* run-time conventions: Interface. -* run-time options: Code Gen Options. -* run-time target specification: Run-time Target. -* saveable_obstack: Addressing Modes. -* scalars, returned as values: Scalar Return. -* SCCS_DIRECTIVE: Misc. -* scheduling, delayed branch: Passes. -* scheduling, instruction: Passes. -* scheduling, instruction: Passes. -* SCHED_GROUP_P: Flags. -* SCmode: Machine Modes. -* scope of a variable length array: Variable Length. -* scope of declaration: Disappointments. -* scope of external declarations: Incompatibilities. -* scratch: Regs and Memory. -* scratch operands: Regs and Memory. -* SDB_ALLOW_FORWARD_REFERENCES: SDB and DWARF. -* SDB_ALLOW_UNKNOWN_REFERENCES: SDB and DWARF. -* SDB_DEBUGGING_INFO: SDB and DWARF. -* SDB_DELIM: SDB and DWARF. -* SDB_GENERATE_FAKE: SDB and DWARF. -* search path: Directory Options. -* SECONDARY_INPUT_RELOAD_CLASS: Register Classes. -* SECONDARY_MEMORY_NEEDED: Register Classes. -* SECONDARY_OUTPUT_RELOAD_CLASS: Register Classes. -* SECONDARY_RELOAD_CLASS: Register Classes. -* SELECT_CC_MODE: Condition Code. -* SELECT_RTX_SECTION: Sections. -* SELECT_SECTION: Sections. -* separate directory, compilation in: Other Dir. -* sequence: Side Effects. -* sequential consistency on 88k: M88K Options. -* set: Side Effects. -* setjmp: Global Reg Vars. -* SETUP_INCOMING_VARARGS: Varargs. -* set_attr: Tagging Insns. -* set_attr_alternative: Tagging Insns. -* SET_DEST: Side Effects. -* SET_SRC: Side Effects. -* SFmode: Machine Modes. -* shared strings: Incompatibilities. -* shared VMS run time system: VMS Misc. -* SHARED_SECTION_ASM_OP: Sections. -* sharing of RTL components: Sharing. -* shift: Arithmetic. -* SHIFT_COUNT_TRUNCATED: Misc. -* SHORT_TYPE_SIZE: Type Layout. -* side effect in ?:: Conditionals. -* side effects, macro argument: Statement Exprs. -* signed division: Arithmetic. -* signed maximum: Arithmetic. -* signed minimum: Arithmetic. -* SIGNED_CHAR_SPEC: Driver. -* sign_extend: Conversions. -* sign_extract: Bit Fields. -* SImode: Machine Modes. -* simple constraints: Simple Constraints. -* simplifications, arithmetic: Passes. -* sizeof: Typeof. -* SIZE_TYPE: Type Layout. -* SLOW_BYTE_ACCESS: Costs. -* SLOW_UNALIGNED_ACCESS: Costs. -* SLOW_ZERO_EXTEND: Costs. -* smaller data references (88k): M88K Options. -* smaller data references (MIPS): MIPS Options. -* SMALL_REGISTER_CLASSES: Register Classes. -* smax: Arithmetic. -* smin: Arithmetic. -* SPARC options: Sparc Options. -* specified registers: Explicit Reg Vars. -* specifying compiler version and target machine: Target Options. -* specifying hardware config: Submodel Options. -* specifying machine version: Target Options. -* specifying registers for local variables: Local Reg Vars. -* speed of instructions: Costs. -* splitting instructions: Insn Splitting. -* sqrt: Arithmetic. -* square root: Arithmetic. -* stack arguments: Stack Arguments. -* stack frame layout: Frame Layout. -* STACK_BOUNDARY: Storage Layout. -* STACK_DYNAMIC_OFFSET: Frame Layout. -* STACK_GROWS_DOWNWARD: Frame Layout. -* STACK_PARMS_IN_REG_PARM_AREA: Stack Arguments. -* STACK_POINTER_OFFSET: Frame Layout. -* STACK_POINTER_REGNUM: Frame Registers. -* stack_pointer_rtx: Frame Registers. -* STACK_REGS: Stack Registers. -* stage1: Installation. -* standard pattern names: Standard Names. -* STANDARD_EXEC_PREFIX: Driver. -* STANDARD_INCLUDE_DIR: Driver. -* STANDARD_STARTFILE_PREFIX: Driver. -* STARTFILE_SPEC: Driver. -* STARTING_FRAME_OFFSET: Frame Layout. -* statements inside expressions: Statement Exprs. -* STATIC_CHAIN: Frame Registers. -* STATIC_CHAIN_INCOMING: Frame Registers. -* STATIC_CHAIN_INCOMING_REGNUM: Frame Registers. -* STATIC_CHAIN_REGNUM: Frame Registers. -* STDC_VALUE: Run-time Target. -* storage layout: Storage Layout. -* STORE_FLAG_VALUE: Misc. -* strcpy: Storage Layout. -* strength-reduction: Passes. -* STRICT_ALIGNMENT: Storage Layout. -* strict_low_part: RTL Declarations. -* string constants: Incompatibilities. -* STRIP_NAME_ENCODING: Sections. -* structure passing (88k): M88K Options. -* structure value address: Aggregate Return. -* structures: Incompatibilities. -* structures, constructor expression: Constructors. -* structures, returning: Interface. -* STRUCTURE_SIZE_BOUNDARY: Storage Layout. -* STRUCT_VALUE: Aggregate Return. -* STRUCT_VALUE_INCOMING: Aggregate Return. -* STRUCT_VALUE_INCOMING_REGNUM: Aggregate Return. -* STRUCT_VALUE_REGNUM: Aggregate Return. -* stupid register allocation: Passes. -* submodel options: Submodel Options. -* subreg: Regs and Memory. -* SUBREG_PROMOTED_UNSIGNED_P: Flags. -* SUBREG_PROMOTED_VAR_P: Flags. -* SUBREG_REG: Regs and Memory. -* SUBREG_WORD: Regs and Memory. -* subscripting: Subscripting. -* subscripting and function values: Subscripting. -* SUCCESS_EXIT_CODE: Config. -* Sun installation: Sun Install. -* suppressing warnings: Warning Options. -* SVr4: M88K Options. -* SWITCHES_NEED_SPACES: Driver. -* SWITCH_TAKES_ARG: Driver. -* symbolic label: Sharing. -* symbol_ref: Constants. -* SYMBOL_REF_FLAG: Flags. -* SYMBOL_REF_USED: Flags. -* syntax checking: Warning Options. -* SYSTEM_INCLUDE_DIR: Driver. -* sys_siglist: Config. -* tagging insns: Tagging Insns. -* tail recursion optimization: Passes. -* target description macros: Target Macros. -* target machine, specifying: Target Options. -* target options: Target Options. -* target specifications: Run-time Target. -* target-parameter-dependent code: Passes. -* TARGET_BELL: Type Layout. -* TARGET_BS: Type Layout. -* TARGET_CR: Type Layout. -* TARGET_EDOM: Library Calls. -* TARGET_FF: Type Layout. -* TARGET_FLOAT_FORMAT: Storage Layout. -* TARGET_MEM_FUNCTIONS: Library Calls. -* TARGET_NEWLINE: Type Layout. -* TARGET_OPTIONS: Run-time Target. -* TARGET_SWITCHES: Run-time Target. -* TARGET_TAB: Type Layout. -* TARGET_VERSION: Run-time Target. -* TARGET_VT: Type Layout. -* TCmode: Machine Modes. -* termination routines: Initialization. -* text_section: Sections. -* TEXT_SECTION_ASM_OP: Sections. -* TFmode: Machine Modes. -* thunks: Nested Functions. -* TImode: Machine Modes. -* TMPDIR: Environment Variables. -* top level of compiler: Passes. -* traditional C language: Dialect Options. -* TRADITIONAL_RETURN_FLOAT: Scalar Return. -* trampolines for nested functions: Trampolines. -* TRAMPOLINE_ALIGNMENT: Trampolines. -* TRAMPOLINE_SECTION: Trampolines. -* TRAMPOLINE_SIZE: Trampolines. -* TRAMPOLINE_TEMPLATE: Trampolines. -* TRANSFER_FROM_TRAMPOLINE: Trampolines. -* TRULY_NOOP_TRUNCATION: Misc. -* truncate: Conversions. -* type alignment: Alignment. -* typedef names as function parameters: Incompatibilities. -* typeof: Typeof. -* udiv: Arithmetic. -* UDIVDI3_LIBCALL: Library Calls. -* UDIVSI3_LIBCALL: Library Calls. -* Ultrix calling convention: Interoperation. -* umax: Arithmetic. -* umin: Arithmetic. -* umod: Arithmetic. -* UMODDI3_LIBCALL: Library Calls. -* UMODSI3_LIBCALL: Library Calls. -* unchanging: Flags. -* undefined behavior: Bug Criteria. -* undefined function value: Bug Criteria. -* underscores in variables in macros: Naming Types. -* underscores, avoiding (88k): M88K Options. -* union, casting to a: Cast to Union. -* unions: Incompatibilities. -* unions, returning: Interface. -* UNITS_PER_WORD: Storage Layout. -* UNKNOWN_FLOAT_FORMAT: Storage Layout. -* Unos installation: Unos Install. -* 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. -* USER_LABEL_PREFIX: Instruction Output. -* USE_C_ALLOCA: Config. -* USE_PROTOTYPES: Config. -* USG: Config. -* value after longjmp: Global Reg Vars. -* values, returned by functions: Scalar Return. -* varargs implementation: Varargs. -* variable alignment: Alignment. -* variable attributes: Variable Attributes. -* variable number of arguments: Macro Varargs. -* variable-length array scope: Variable Length. -* variable-length arrays: Variable Length. -* variables in specified registers: Explicit Reg Vars. -* variables, local, in macros: Naming Types. -* Vax calling convention: Interoperation. -* VAX options: VAX Options. -* VAX_FLOAT_FORMAT: Storage Layout. -* VIRTUAL_INCOMING_ARGS_REGNUM: Regs and Memory. -* VIRTUAL_OUTGOING_ARGS_REGNUM: Regs and Memory. -* VIRTUAL_STACK_DYNAMIC_REGNUM: Regs and Memory. -* VIRTUAL_STACK_VARS_REGNUM: Regs and Memory. -* VMS: Config. -* VMS and case sensitivity: VMS Misc. -* VMS and include files: Include Files and VMS. -* VMS installation: VMS Install. -* void pointers, arithmetic: Pointer Arith. -* void, size of pointer to: Pointer Arith. -* VOIDmode: Machine Modes. -* volatil: Flags. -* volatile memory references: Flags. -* voting between constraint alternatives: Class Preferences. -* vprintf: Config. -* warning messages: Warning Options. -* WCHAR_TYPE: Type Layout. -* WCHAR_TYPE_SIZE: Type Layout. -* which_alternative: Output Statement. -* whitespace: Incompatibilities. -* WORDS_BIG_ENDIAN: Storage Layout. -* word_mode: Machine Modes. -* WORD_SWITCH_TAKES_ARG: Driver. -* XCmode: Machine Modes. -* XCOFF_DEBUGGING_INFO: DBX Options. -* XEXP: Accessors. -* XFmode: Machine Modes. -* XINT: Accessors. -* xor: Arithmetic. -* XSTR: Accessors. -* XVEC: Accessors. -* XVECEXP: Accessors. -* XVECLEN: Accessors. -* XWINT: Accessors. -* zero division on 88k: M88K Options. -* zero-length arrays: Zero Length. -* zero_extend: Conversions. -* zero_extract: Bit Fields. -* \: Output Template. -* __bb_init_func: Profiling. -* __builtin_args_info: Varargs. -* __builtin_classify_type: Varargs. -* __builtin_next_arg: Varargs. -* __builtin_saveregs: Varargs. -* __CTOR_LIST__: Initialization. -* __DTOR_LIST__: Initialization. +* File Framework:: Structural information for the assembler file. +* Data Output:: Output of constants (numbers, strings, addresses). +* Uninitialized Data:: Output of uninitialized variables. +* Label Output:: Output and generation of labels. +* Initialization:: General principles of initialization + and termination routines. +* Macros for Initialization:: + Specific macros that control the handling of + initialization and termination routines. +* Instruction Output:: Output of actual instructions. +* Dispatch Tables:: Output of jump tables. +* Alignment Output:: Pseudo ops for alignment and skipping data. + + +File: gcc.info, Node: File Framework, Next: Data Output, Up: Assembler Format + +The Overall Framework of an Assembler File +------------------------------------------ + +`ASM_FILE_START (STREAM)' + A C expression which outputs to the stdio stream STREAM some + appropriate text to go at the start of an assembler file. + + Normally this macro is defined to output a line containing + `#NO_APP', which is a comment that has no effect on most + assemblers but tells the GNU assembler that it can save time by not + checking for certain assembler constructs. + + On systems that use SDB, it is necessary to output certain + commands; see `attasm.h'. + +`ASM_FILE_END (STREAM)' + A C expression which outputs to the stdio stream STREAM some + appropriate text to go at the end of an assembler file. + + If this macro is not defined, the default is to output nothing + special at the end of the file. Most systems don't require any + definition. + + On systems that use SDB, it is necessary to output certain + commands; see `attasm.h'. + +`ASM_IDENTIFY_GCC (FILE)' + A C statement to output assembler commands which will identify the + object file as having been compiled with GNU CC (or another GNU + compiler). + + If you don't define this macro, the string `gcc_compiled.:' is + output. This string is calculated to define a symbol which, on + BSD systems, will never be defined for any other reason. GDB + checks for the presence of this symbol when reading the symbol + table of an executable. + + On non-BSD systems, you must arrange communication with GDB in + some other fashion. If GDB is not used on your system, you can + define this macro with an empty body. + +`ASM_COMMENT_START' + A C string constant describing how to begin a comment in the target + assembler language. The compiler assumes that the comment will + end at the end of the line. + +`ASM_APP_ON' + A C string constant for text to be output before each `asm' + statement or group of consecutive ones. Normally this is + `"#APP"', which is a comment that has no effect on most assemblers + but tells the GNU assembler that it must check the lines that + follow for all valid assembler constructs. + +`ASM_APP_OFF' + A C string constant for text to be output after each `asm' + statement or group of consecutive ones. Normally this is + `"#NO_APP"', which tells the GNU assembler to resume making the + time-saving assumptions that are valid for ordinary compiler + output. + +`ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)' + A C statement to output COFF information or DWARF debugging + information which indicates that filename NAME is the current + source file to the stdio stream STREAM. + + This macro need not be defined if the standard form of output for + the file format in use is appropriate. + +`ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)' + A C statement to output DBX or SDB debugging information before + code for line number LINE of the current source file to the stdio + stream STREAM. + + This macro need not be defined if the standard form of debugging + information for the debugger in use is appropriate. + +`ASM_OUTPUT_IDENT (STREAM, STRING)' + A C statement to output something to the assembler file to handle a + `#ident' directive containing the text STRING. If this macro is + not defined, nothing is output for a `#ident' directive. + +`OBJC_PROLOGUE' + A C statement to output any assembler statements which are + required to precede any Objective C object definitions or message + sending. The statement is executed only when compiling an + Objective C program. + + +File: gcc.info, Node: Data Output, Next: Uninitialized Data, Prev: File Framework, Up: Assembler Format + +Output of Data +-------------- + +`ASM_OUTPUT_LONG_DOUBLE (STREAM, VALUE)' +`ASM_OUTPUT_DOUBLE (STREAM, VALUE)' +`ASM_OUTPUT_FLOAT (STREAM, VALUE)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a floating-point constant of `TFmode', + `DFmode' or `SFmode', respectively, whose value is VALUE. VALUE + will be a C expression of type `REAL_VALUE_TYPE'. Macros such as + `REAL_VALUE_TO_TARGET_DOUBLE' are useful for writing these + definitions. + +`ASM_OUTPUT_QUADRUPLE_INT (STREAM, EXP)' +`ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)' +`ASM_OUTPUT_INT (STREAM, EXP)' +`ASM_OUTPUT_SHORT (STREAM, EXP)' +`ASM_OUTPUT_CHAR (STREAM, EXP)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble an integer of 16, 8, 4, 2 or 1 bytes, + respectively, whose value is VALUE. The argument EXP will be an + RTL expression which represents a constant value. Use + `output_addr_const (STREAM, EXP)' to output this value as an + assembler expression. + + For sizes larger than `UNITS_PER_WORD', if the action of a macro + would be identical to repeatedly calling the macro corresponding to + a size of `UNITS_PER_WORD', once for each word, you need not define + the macro. + +`ASM_OUTPUT_BYTE (STREAM, VALUE)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a single byte containing the number VALUE. + +`ASM_BYTE_OP' + A C string constant giving the pseudo-op to use for a sequence of + single-byte constants. If this macro is not defined, the default + is `"byte"'. + +`ASM_OUTPUT_ASCII (STREAM, PTR, LEN)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a string constant containing the LEN bytes + at PTR. PTR will be a C expression of type `char *' and LEN a C + expression of type `int'. + + If the assembler has a `.ascii' pseudo-op as found in the Berkeley + Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'. + +`ASM_OUTPUT_POOL_PROLOGUE (FILE FUNNAME FUNDECL SIZE)' + A C statement to output assembler commands to define the start of + the constant pool for a function. FUNNAME is a string giving the + name of the function. Should the return type of the function be + required, it can be obtained via FUNDECL. SIZE is the size, in + bytes, of the constant pool that will be written immediately after + this call. + + If no constant-pool prefix is required, the usual case, this macro + need not be defined. + +`ASM_OUTPUT_SPECIAL_POOL_ENTRY (FILE, X, MODE, ALIGN, LABELNO, JUMPTO)' + A C statement (with or without semicolon) to output a constant in + the constant pool, if it needs special treatment. (This macro + need not do anything for RTL expressions that can be output + normally.) + + The argument FILE is the standard I/O stream to output the + assembler code on. X is the RTL expression for the constant to + output, and MODE is the machine mode (in case X is a `const_int'). + ALIGN is the required alignment for the value X; you should + output an assembler directive to force this much alignment. + + The argument LABELNO is a number to use in an internal label for + the address of this pool entry. The definition of this macro is + responsible for outputting the label definition at the proper + place. Here is how to do this: + + ASM_OUTPUT_INTERNAL_LABEL (FILE, "LC", LABELNO); + + When you output a pool entry specially, you should end with a + `goto' to the label JUMPTO. This will prevent the same pool entry + from being output a second time in the usual manner. + + You need not define this macro if it would do nothing. + +`ASM_OPEN_PAREN' +`ASM_CLOSE_PAREN' + These macros are defined as C string constant, describing the + syntax in the assembler for grouping arithmetic expressions. The + following definitions are correct for most assemblers: + + #define ASM_OPEN_PAREN "(" + #define ASM_CLOSE_PAREN ")" + + These macros are provided by `real.h' for writing the definitions of +`ASM_OUTPUT_DOUBLE' and the like: + +`REAL_VALUE_TO_TARGET_SINGLE (X, L)' +`REAL_VALUE_TO_TARGET_DOUBLE (X, L)' +`REAL_VALUE_TO_TARGET_LONG_DOUBLE (X, L)' + These translate X, of type `REAL_VALUE_TYPE', to the target's + floating point representation, and store its bit pattern in the + array of `long int' whose address is L. The number of elements in + the output array is determined by the size of the desired target + floating point data type: 32 bits of it go in each `long int' array + element. Each array element holds 32 bits of the result, even if + `long int' is wider than 32 bits on the host machine. + + The array element values are designed so that you can print them + out using `fprintf' in the order they should appear in the target + machine's memory. + +`REAL_VALUE_TO_DECIMAL (X, FORMAT, STRING)' + This macro converts X, of type `REAL_VALUE_TYPE', to a decimal + number and stores it as a string into STRING. You must pass, as + STRING, the address of a long enough block of space to hold the + result. + + The argument FORMAT is a `printf'-specification that serves as a + suggestion for how to format the output string. + + +File: gcc.info, Node: Uninitialized Data, Next: Label Output, Prev: Data Output, Up: Assembler Format + +Output of Uninitialized Variables +--------------------------------- + + Each of the macros in this section is used to do the whole job of +outputting a single uninitialized variable. + +`ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a common-label named NAME whose + size is SIZE bytes. The variable ROUNDED is the size rounded up + to whatever alignment the caller wants. + + Use the expression `assemble_name (STREAM, NAME)' to output the + name itself; before and after that, output the additional + assembler syntax for defining the name, and a newline. + + This macro controls how the assembler definitions of uninitialized + global variables are output. + +`ASM_OUTPUT_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)' + Like `ASM_OUTPUT_COMMON' except takes the required alignment as a + separate, explicit argument. If you define this macro, it is used + in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in + handling the required alignment of the variable. + +`ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)' + If defined, it is similar to `ASM_OUTPUT_COMMON', except that it + is used when NAME is shared. If not defined, `ASM_OUTPUT_COMMON' + will be used. + +`ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a local-common-label named NAME + whose size is SIZE bytes. The variable ROUNDED is the size + rounded up to whatever alignment the caller wants. + + Use the expression `assemble_name (STREAM, NAME)' to output the + name itself; before and after that, output the additional + assembler syntax for defining the name, and a newline. + + This macro controls how the assembler definitions of uninitialized + static variables are output. + +`ASM_OUTPUT_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)' + Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a + separate, explicit argument. If you define this macro, it is used + in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in + handling the required alignment of the variable. + +`ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)' + If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is + used when NAME is shared. If not defined, `ASM_OUTPUT_LOCAL' will + be used. + + +File: gcc.info, Node: Label Output, Next: Initialization, Prev: Uninitialized Data, Up: Assembler Format + +Output and Generation of Labels +------------------------------- + +`ASM_OUTPUT_LABEL (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM the assembler definition of a label named NAME. Use the + expression `assemble_name (STREAM, NAME)' to output the name + itself; before and after that, output the additional assembler + syntax for defining the name, and a newline. + +`ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name NAME of a + function which is being defined. This macro is responsible for + outputting the label definition (perhaps using + `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL' + tree node representing the function. + + If this macro is not defined, then the function name is defined in + the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). + +`ASM_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the size of a function + which is being defined. The argument NAME is the name of the + function. The argument DECL is the `FUNCTION_DECL' tree node + representing the function. + + If this macro is not defined, then the function size is not + defined. + +`ASM_DECLARE_OBJECT_NAME (STREAM, NAME, DECL)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name NAME of an + initialized variable which is being defined. This macro must + output the label definition (perhaps using `ASM_OUTPUT_LABEL'). + The argument DECL is the `VAR_DECL' tree node representing the + variable. + + If this macro is not defined, then the variable name is defined in + the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). + +`ASM_GLOBALIZE_LABEL (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM some commands that will make the label NAME global; that + is, available for reference from other files. Use the expression + `assemble_name (STREAM, NAME)' to output the name itself; before + and after that, output the additional assembler syntax for making + that name global, and a newline. + +`ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM any text necessary for declaring the name of an external + symbol named NAME which is referenced in this compilation but not + defined. The value of DECL is the tree node for the declaration. + + This macro need not be defined if it does not need to output + anything. The GNU assembler and most Unix assemblers don't + require anything. + +`ASM_OUTPUT_EXTERNAL_LIBCALL (STREAM, SYMREF)' + A C statement (sans semicolon) to output on STREAM an assembler + pseudo-op to declare a library function name external. The name + of the library function is given by SYMREF, which has type `rtx' + and is a `symbol_ref'. + + This macro need not be defined if it does not need to output + anything. The GNU assembler and most Unix assemblers don't + require anything. + +`ASM_OUTPUT_LABELREF (STREAM, NAME)' + A C statement (sans semicolon) to output to the stdio stream + STREAM a reference in assembler syntax to a label named NAME. + This should add `_' to the front of the name, if that is customary + on your operating system, as it is in most Berkeley Unix systems. + This macro is used in `assemble_name'. + +`ASM_OUTPUT_LABELREF_AS_INT (FILE, LABEL)' + Define this macro for systems that use the program `collect2'. + The definition should be a C statement to output a word containing + a reference to the label LABEL. + +`ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)' + A C statement to output to the stdio stream STREAM a label whose + name is made from the string PREFIX and the number NUM. + + It is absolutely essential that these labels be distinct from the + labels used for user-level functions and variables. Otherwise, + certain programs will have name conflicts with internal labels. + + It is desirable to exclude internal labels from the symbol table + of the object file. Most assemblers have a naming convention for + labels that should be excluded; on many systems, the letter `L' at + the beginning of a label has this effect. You should find out what + convention your system uses, and follow it. + + The usual definition of this macro is as follows: + + fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) + +`ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)' + A C statement to store into the string STRING a label whose name + is made from the string PREFIX and the number NUM. + + This string, when output subsequently by `assemble_name', should + produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce + with the same PREFIX and NUM. + + If the string begins with `*', then `assemble_name' will output + the rest of the string unchanged. It is often convenient for + `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way. If the + string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to + output the string, and may change it. (Of course, + `ASM_OUTPUT_LABELREF' is also part of your machine description, so + you should know what it does on your machine.) + +`ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)' + A C expression to assign to OUTVAR (which is a variable of type + `char *') a newly allocated string made from the string NAME and + the number NUMBER, with some suitable punctuation added. Use + `alloca' to get space for the string. + + The string will be used as an argument to `ASM_OUTPUT_LABELREF' to + produce an assembler label for an internal static variable whose + name is NAME. Therefore, the string must be such as to result in + valid assembler code. The argument NUMBER is different each time + this macro is executed; it prevents conflicts between + similarly-named internal static variables in different scopes. + + Ideally this string should not be a valid C identifier, to prevent + any conflict with the user's own symbols. Most assemblers allow + periods or percent signs in assembler symbols; putting at least + one of these between the name and the number will suffice. + +`OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)' + Define this macro to override the default assembler names used for + Objective C methods. + + The default name is a unique method number followed by the name of + the class (e.g. `_1_Foo'). For methods in categories, the name of + the category is also included in the assembler name (e.g. + `_1_Foo_Bar'). + + These names are safe on most systems, but make debugging difficult + since the method's selector is not present in the name. + Therefore, particular systems define other ways of computing names. + + BUF is an expression of type `char *' which gives you a buffer in + which to store the name; its length is as long as CLASS_NAME, + CAT_NAME and SEL_NAME put together, plus 50 characters extra. + + The argument IS_INST specifies whether the method is an instance + method or a class method; CLASS_NAME is the name of the class; + CAT_NAME is the name of the category (or NULL if the method is not + in a category); and SEL_NAME is the name of the selector. + + On systems where the assembler can handle quoted names, you can + use this macro to provide more human-readable names. + + +File: gcc.info, Node: Initialization, Next: Macros for Initialization, Prev: Label Output, Up: Assembler Format + +How Initialization Functions Are Handled +---------------------------------------- + + The compiled code for certain languages includes "constructors" +(also called "initialization routines")--functions to initialize data +in the program when the program is started. These functions need to be +called before the program is "started"--that is to say, before `main' +is called. + + Compiling some languages generates "destructors" (also called +"termination routines") that should be called when the program +terminates. + + To make the initialization and termination functions work, the +compiler must output something in the assembler code to cause those +functions to be called at the appropriate time. When you port the +compiler to a new system, you need to specify how to do this. + + There are two major ways that GCC currently supports the execution of +initialization and termination functions. Each way has two variants. +Much of the structure is common to all four variations. + + The linker must build two lists of these functions--a list of +initialization functions, called `__CTOR_LIST__', and a list of +termination functions, called `__DTOR_LIST__'. + + Each list always begins with an ignored function pointer (which may +hold 0, -1, or a count of the function pointers after it, depending on +the environment). This is followed by a series of zero or more function +pointers to constructors (or destructors), followed by a function +pointer containing zero. + + Depending on the operating system and its executable file format, +either `crtstuff.c' or `libgcc2.c' traverses these lists at startup +time and exit time. Constructors are called in forward order of the +list; destructors in reverse order. + + The best way to handle static constructors works only for object file +formats which provide arbitrarily-named sections. A section is set +aside for a list of constructors, and another for a list of destructors. +Traditionally these are called `.ctors' and `.dtors'. Each object file +that defines an initialization function also puts a word in the +constructor section to point to that function. The linker accumulates +all these words into one contiguous `.ctors' section. Termination +functions are handled similarly. + + To use this method, you need appropriate definitions of the macros +`ASM_OUTPUT_CONSTRUCTOR' and `ASM_OUTPUT_DESTRUCTOR'. Usually you can +get them by including `svr4.h'. + + When arbitrary sections are available, there are two variants, +depending upon how the code in `crtstuff.c' is called. On systems that +support an "init" section which is executed at program startup, parts +of `crtstuff.c' are compiled into that section. The program is linked +by the `gcc' driver like this: + + ld -o OUTPUT_FILE crtbegin.o ... crtend.o -lgcc + + The head of a function (`__do_global_ctors') appears in the init +section of `crtbegin.o'; the remainder of the function appears in the +init section of `crtend.o'. The linker will pull these two parts of +the section together, making a whole function. If any of the user's +object files linked into the middle of it contribute code, then that +code will be executed as part of the body of `__do_global_ctors'. + + To use this variant, you must define the `INIT_SECTION_ASM_OP' macro +properly. + + If no init section is available, do not define +`INIT_SECTION_ASM_OP'. Then `__do_global_ctors' is built into the text +section like all other functions, and resides in `libgcc.a'. When GCC +compiles any function called `main', it inserts a procedure call to +`__main' as the first executable code after the function prologue. The +`__main' function, also defined in `libgcc2.c', simply calls +`__do_global_ctors'. + + In file formats that don't support arbitrary sections, there are +again two variants. In the simplest variant, the GNU linker (GNU `ld') +and an `a.out' format must be used. In this case, +`ASM_OUTPUT_CONSTRUCTOR' is defined to produce a `.stabs' entry of type +`N_SETT', referencing the name `__CTOR_LIST__', and with the address of +the void function containing the initialization code as its value. The +GNU linker recognizes this as a request to add the value to a "set"; +the values are accumulated, and are eventually placed in the executable +as a vector in the format described above, with a leading (ignored) +count and a trailing zero element. `ASM_OUTPUT_DESTRUCTOR' is handled +similarly. Since no init section is available, the absence of +`INIT_SECTION_ASM_OP' causes the compilation of `main' to call `__main' +as above, starting the initialization process. + + The last variant uses neither arbitrary sections nor the GNU linker. +This is preferable when you want to do dynamic linking and when using +file formats which the GNU linker does not support, such as `ECOFF'. In +this case, `ASM_OUTPUT_CONSTRUCTOR' does not produce an `N_SETT' +symbol; initialization and termination functions are recognized simply +by their names. This requires an extra program in the linkage step, +called `collect2'. This program pretends to be the linker, for use +with GNU CC; it does its job by running the ordinary linker, but also +arranges to include the vectors of initialization and termination +functions. These functions are called via `__main' as described above. + + Choosing among these configuration options has been simplified by a +set of operating-system-dependent files in the `config' subdirectory. +These files define all of the relevant parameters. Usually it is +sufficient to include one into your specific machine-dependent +configuration file. These files are: + +`aoutos.h' + For operating systems using the `a.out' format. + +`next.h' + For operating systems using the `MachO' format. + +`svr3.h' + For System V Release 3 and similar systems using `COFF' format. + +`svr4.h' + For System V Release 4 and similar systems using `ELF' format. + +`vms.h' + For the VMS operating system. + + The following section describes the specific macros that control and +customize the handling of initialization and termination functions. + + +File: gcc.info, Node: Macros for Initialization, Next: Instruction Output, Prev: Initialization, Up: Assembler Format + +Macros Controlling Initialization Routines +------------------------------------------ + + Here are the macros that control how the compiler handles +initialization and termination functions: + +`INIT_SECTION_ASM_OP' + If defined, a C string constant for the assembler operation to + identify the following data as initialization code. If not + defined, GNU CC will assume such a section does not exist. When + you are using special sections for initialization and termination + functions, this macro also controls how `crtstuff.c' and + `libgcc2.c' arrange to run the initialization functions. + +`ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)' + Define this macro as a C statement to output on the stream STREAM + the assembler code to arrange to call the function named NAME at + initialization time. + + Assume that NAME is the name of a C function generated + automatically by the compiler. This function takes no arguments. + Use the function `assemble_name' to output the name NAME; this + performs any system-specific syntactic transformations such as + adding an underscore. + + If you don't define this macro, nothing special is output to + arrange to call the function. This is correct when the function + will be called in some other manner--for example, by means of the + `collect2' program, which looks through the symbol table to find + these functions by their names. + +`ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)' + This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination + functions rather than initialization functions. + + If your system uses `collect2' as the means of processing +constructors, then that program normally uses `nm' to scan an object +file for constructor functions to be called. On certain kinds of +systems, you can define these macros to make `collect2' work faster +(and, in some cases, make it work at all): + +`OBJECT_FORMAT_COFF' + Define this macro if the system uses COFF (Common Object File + Format) object files, so that `collect2' can assume this format + and scan object files directly for dynamic constructor/destructor + functions. + +`OBJECT_FORMAT_ROSE' + Define this macro if the system uses ROSE format object files, so + that `collect2' can assume this format and scan object files + directly for dynamic constructor/destructor functions. + + These macros are effective only in a native compiler; `collect2' as +part of a cross compiler always uses `nm'. +`REAL_NM_FILE_NAME' + Define this macro as a C string constant containing the file name + to use to execute `nm'. The default is to search the path + normally for `nm'.