diff options
Diffstat (limited to 'gcc-1.40/gcc.info-10')
| -rw-r--r-- | gcc-1.40/gcc.info-10 | 1161 |
1 files changed, 1161 insertions, 0 deletions
diff --git a/gcc-1.40/gcc.info-10 b/gcc-1.40/gcc.info-10 new file mode 100644 index 0000000..7a22672 --- /dev/null +++ b/gcc-1.40/gcc.info-10 @@ -0,0 +1,1161 @@ +Info file gcc.info, produced by Makeinfo, -*- Text -*- from input +file gcc.texinfo. + + This file documents the use and the internals of the GNU compiler. + + Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc. + + Permission is granted to make and distribute verbatim copies of +this manual provided the copyright notice and this permission notice +are preserved on all copies. + + Permission is granted to copy and distribute modified versions of +this manual under the conditions for verbatim copying, provided also +that the sections entitled "GNU General Public License" and "Protect +Your Freedom--Fight `Look And Feel'" are included exactly as in the +original, and provided that the entire resulting derived work is +distributed under the terms of a permission notice identical to this +one. + + Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that the sections entitled "GNU General Public +License" and "Protect Your Freedom--Fight `Look And Feel'" and this +permission notice may be included in translations approved by the +Free Software Foundation instead of in the original English. + + +File: gcc.info, Node: Addressing Modes, Next: Delayed Branch, Prev: Library Calls, Up: Machine Macros + +Addressing Modes +================ + +`HAVE_POST_INCREMENT' + Define this macro if the machine supports post-increment + addressing. + +`HAVE_PRE_INCREMENT' +`HAVE_POST_DECREMENT' +`HAVE_PRE_DECREMENT' + Similar for other kinds of addressing. + +`CONSTANT_ADDRESS_P (X)' + A C expression that is 1 if the RTX X is a constant whose value + is an integer. This includes integers whose values are not + explicitly known, such as `symbol_ref' and `label_ref' + expressions and `const' arithmetic expressions. + + On most machines, this can be defined as `CONSTANT_P (X)', but a + few machines are more restrictive in which constant addresses + are supported. + +`MAX_REGS_PER_ADDRESS' + A number, the maximum number of registers that can appear in a + valid memory address. Note that it is up to you to specify a + value equal to the maximum number that + `go_if_legitimate_address' would ever accept. + +`GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)' + A C compound statement with a conditional `goto LABEL;' executed + if X (an RTX) is a legitimate memory address on the target + machine for a memory operand of mode MODE. + + It usually pays to define several simpler macros to serve as + subroutines for this one. Otherwise it may be too complicated + to understand. + + This macro must exist in two variants: a strict variant and a + non-strict one. The strict variant is used in the reload pass. + It must be defined so that any pseudo-register that has not been + allocated a hard register is considered a memory reference. In + contexts where some kind of register is required, a + pseudo-register with no hard register must be rejected. + + The non-strict variant is used in other passes. It must be + defined to accept all pseudo-registers in every context where + some kind of register is required. + + Compiler source files that want to use the strict variant of + this macro define the macro `REG_OK_STRICT'. You should use an + `#ifdef REG_OK_STRICT' conditional to define the strict variant + in that case and the non-strict variant otherwise. + + Typically among the subroutines used to define + `GO_IF_LEGITIMATE_ADDRESS' are subroutines to check for + acceptable registers for various purposes (one for base + registers, one for index registers, and so on). Then only these + subroutine macros need have two variants; the higher levels of + macros may be the same whether strict or not. + + Normally, constant addresses which are the sum of a `symbol_ref' + and an integer are stored inside a `const' RTX to mark them as + constant. Therefore, there is no need to recognize such sums as + legitimate addresses. + + Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle + constant sums that are not marked with `const'. It assumes + that a naked `plus' indicates indexing. If so, then you *must* + reject such naked constant sums as illegitimate addresses, so + that none of them will be given to `PRINT_OPERAND_ADDRESS'. + +`REG_OK_FOR_BASE_P (X)' + A C expression that is nonzero if X (assumed to be a `reg' RTX) + is valid for use as a base register. For hard registers, it + should always accept those which the hardware permits and reject + the others. Whether the macro accepts or rejects pseudo + registers must be controlled by `REG_OK_STRICT' as described + above. This usually requires two variant definitions, of which + `REG_OK_STRICT' controls the one actually used. + +`REG_OK_FOR_INDEX_P (X)' + A C expression that is nonzero if X (assumed to be a `reg' RTX) + is valid for use as an index register. + + The difference between an index register and a base register is + that the index register may be scaled. If an address involves + the sum of two registers, neither one of them scaled, then + either one may be labeled the "base" and the other the "index"; + but whichever labeling is used must fit the machine's + constraints of which registers may serve in each capacity. The + compiler will try both labelings, looking for one that is valid, + and will reload one or both registers only if neither labeling + works. + +`LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)' + A C compound statement that attempts to replace X with a valid + memory address for an operand of mode MODE. WIN will be a C + statement label elsewhere in the code; the macro definition may + use + + GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); + + to avoid further processing if the address has become legitimate. + + X will always be the result of a call to + `break_out_memory_refs', and OLDX will be the operand that was + given to that function to produce X. + + The code generated by this macro should not alter the + substructure of X. If it transforms X into a more legitimate + form, it should assign X (which will always be a C variable) a + new value. + + It is not necessary for this macro to come up with a legitimate + address. The compiler has standard ways of doing so in all + cases. In fact, it is safe for this macro to do nothing. But + often a machine-dependent strategy can generate better code. + +`GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)' + A C statement or compound statement with a conditional `goto + LABEL;' executed if memory address X (an RTX) can have different + meanings depending on the machine mode of the memory reference + it is used for. + + Autoincrement and autodecrement addresses typically have + mode-dependent effects because the amount of the increment or + decrement is the size of the operand being addressed. Some + machines have other mode-dependent addresses. Many RISC + machines have no mode-dependent addresses. + + You may assume that ADDR is a valid address for the machine. + +`LEGITIMATE_CONSTANT_P (X)' + A C expression that is nonzero if X is a legitimate constant for + an immediate operand on the target machine. You can assume that + either X is a `const_double' or it satisfies `CONSTANT_P', so + you need not check these things. In fact, `1' is a suitable + definition for this macro on machines where any `const_double' + is valid and anything `CONSTANT_P' is valid. + + +File: gcc.info, Node: Delayed Branch, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros + +Parameters for Delayed Branch Optimization +========================================== + +`HAVE_DELAYED_BRANCH' + Define this macro if the target machine has delayed branches, + that is, a branch does not take effect immediately, and the + actual branch instruction may be followed by one or more + instructions that will be issued before the PC is actually + changed. + + If defined, this allows a special scheduling pass to be run + after the second jump optimization to attempt to reorder + instructions to exploit this. Defining this macro also requires + the definition of certain other macros described below. + +`DBR_SLOTS_AFTER (INSN)' + This macro must be defined if `HAVE_DELAYED_BRANCH' is defined. + Its definition should be a C expression returning the number of + available delay slots following the instruction(s) output by the + pattern for INSN. The definition of "slot" is + machine-dependent, and may denote instructions, bytes, or + whatever. + +`DBR_INSN_SLOTS (INSN)' + This macro must be defined if `HAVE_DELAYED_BRANCH' is defined. + It should be a C expression returning the number of slots + (typically the number of machine instructions) consumed by INSN. + + You may assume that INSN is truly an insn, not a note, label, + barrier, dispatch table, `use', or `clobber'. + +`DBR_INSN_ELIGIBLE_P (INSN, DINSN)' + A C expression whose value is non-zero if it is legitimate to + put INSN in the delay slot following DINSN. + + You do not need to take account of data flow considerations in + the definition of this macro, because the delayed branch + optimizer always does that. This macro is needed only when + certain insns may not be placed in certain delay slots for + reasons not evident from the RTL expressions themselves. If + there are no such problems, you don't need to define this macro. + + You may assume that INSN is truly an insn, not a note, label, + barrier, dispatch table, `use', or `clobber'. You may assume + that DINSN is a jump insn with a delay slot. + +`DBR_OUTPUT_SEQEND(FILE)' + A C statement, to be executed after all slot-filler instructions + have been output. If necessary, call `dbr_sequence_length' to + determine the number of slots filled in a sequence (zero if not + currently outputting a sequence), to decide how many no-ops to + output, or whatever. + + Don't define this macro if it has nothing to do, but it is + helpful in reading assembly output if the extent of the delay + sequence is made explicit (e.g. with white space). + + Note that output routines for instructions with delay slots must + be prepared to deal with not being output as part of a sequence + (i.e. when the scheduling pass is not run, or when no slot + fillers could be found.) The variable `final_sequence' is null + when not processing a sequence, otherwise it contains the + `sequence' rtx being output. + + +File: gcc.info, Node: Condition Code, Next: Cross-compilation, Prev: Delayed Branch, Up: Machine Macros + +Condition Code Information +========================== + + 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'. + +`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. + +`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)'. + + If there are insn 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'. + + +File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Condition Code, Up: Machine Macros + +Cross Compilation and Floating-Point Format +=========================================== + + While all modern machines use 2's complement representation for +integers, there are a variety of representations for floating point +numbers. This means that in a cross-compiler the representation of +floating point numbers in the compiled program may be different from +that used in the machine doing the compilation. + + Because different representation systems may offer different +amounts of range and precision, the cross compiler cannot safely use +the host machine's floating point arithmetic. Therefore, floating +point constants must be represented in the target machine's format. +This means that the cross compiler cannot use `atof' to parse a +floating point constant; it must have its own special routine to use +instead. Also, constant folding must emulate the target machine's +arithmetic (or must not be done at all). + + The macros in the following table should be defined only if you +are cross compiling between different floating point formats. + + Otherwise, don't define them. Then default definitions will be set +up which use `double' as the data type, `==' to test for equality, etc. + + You don't need to worry about how many times you use an operand of +any of these macros. The compiler never uses operands which have +side effects. + +`REAL_VALUE_TYPE' + A macro for the C data type to be used to hold a floating point + value in the target machine's format. Typically this would be a + `struct' containing an array of `int'. + +`REAL_VALUES_EQUAL (X, Y)' + A macro for a C expression which compares for equality the two + values, X and Y, both of type `REAL_VALUE_TYPE'. + +`REAL_VALUES_LESS (X, Y)' + A macro for a C expression which tests whether X is less than Y, + both values being of type `REAL_VALUE_TYPE' and interpreted as + floating point numbers in the target machine's representation. + +`REAL_VALUE_LDEXP (X, SCALE)' + A macro for a C expression which performs the standard library + function `ldexp', but using the target machine's floating point + representation. Both X and the value of the expression have + type `REAL_VALUE_TYPE'. The second argument, SCALE, is an + integer. + +`REAL_VALUE_ATOF (STRING)' + A macro for a C expression which converts STRING, an expression + of type `char *', into a floating point number in the target + machine's representation. The value has type `REAL_VALUE_TYPE'. + + Define the following additional macros if you want to make +floating point constant folding work while cross compiling. If you +don't define them, cross compilation is still possible, but constant +folding will not happen for floating point values. + +`REAL_ARITHMETIC (OUTPUT, CODE, X, Y)' + A macro for a C statement which calculates an arithmetic + operation of the two floating point values X and Y, both of type + `REAL_VALUE_TYPE' in the target machine's representation, to + produce a result of the same type and representation which is + stored in OUTPUT (which will be a variable). + + The operation to be performed is specified by CODE, a tree code + which will always be one of the following: `PLUS_EXPR', + `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'. + + The expansion of this macro is responsible for checking for + overflow. If overflow happens, the macro expansion should + execute the statement `return 0;', which indicates the inability + to perform the arithmetic operation requested. + +`REAL_VALUE_NEGATE (X)' + A macro for a C expression which returns the negative of the + floating point value X. Both X and the value of the expression + have type `REAL_VALUE_TYPE' and are in the target machine's + floating point representation. + + There is no way for this macro to report overflow, since + overflow can't happen in the negation operation. + +`REAL_VALUE_TO_INT (LOW, HIGH, X)' + A macro for a C expression which converts a floating point value + X into a double-precision integer which is then stored into LOW + and HIGH, two variables of type INT. + +`REAL_VALUE_FROM_INT (X, LOW, HIGH)' + A macro for a C expression which converts a double-precision + integer found in LOW and HIGH, two variables of type INT, into a + floating point value which is then stored into X. + + +File: gcc.info, Node: Misc, Next: Assembler Format, Prev: Cross-compilation, Up: Machine Macros + +Miscellaneous Parameters +======================== + +`CASE_VECTOR_MODE' + An alias for a machine mode name. This is the machine mode that + elements of a jump-table should have. + +`CASE_VECTOR_PC_RELATIVE' + Define this macro if jump-tables should contain relative + addresses. + +`CASE_DROPS_THROUGH' + Define this if control falls through a `case' insn when the + index value is out of range. This means the specified + default-label is actually ignored by the `case' insn proper. + +`IMPLICIT_FIX_EXPR' + An alias for a tree code that should be used by default for + conversion of floating point values to fixed point. Normally, + `FIX_ROUND_EXPR' is used. + +`FIXUNS_TRUNC_LIKE_FIX_TRUNC' + Define this macro if the same instructions that convert a + floating point number to a signed fixed point number also + convert validly to an unsigned one. + +`EASY_DIV_EXPR' + An alias for a tree code that is the easiest kind of division to + compile code for in the general case. It may be + `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or + `ROUND_DIV_EXPR'. These four division operators differ in how + they round the result to an integer. `EASY_DIV_EXPR' is used + when it is permissible to use any of those kinds of division and + the choice should be made on the basis of efficiency. + +`DEFAULT_SIGNED_CHAR' + An expression whose value is 1 or 0, according to whether the + type `char' should be signed or unsigned by default. The user + can always override this default with the options + `-fsigned-char' and `-funsigned-char'. + +`SCCS_DIRECTIVE' + Define this if the preprocessor should ignore `#sccs' directives + and print no error message. + +`HAVE_VPRINTF' + Define this if the library function `vprintf' is available on + your system. + +`MOVE_MAX' + The maximum number of bytes that a single instruction can move + quickly from memory to memory. + +`INT_TYPE_SIZE' + A C expression for the size in bits of the type `int' on the + target machine. If you don't define this, the default is one + word. + +`SHORT_TYPE_SIZE' + A C expression for the size in bits of the type `short' on the + target machine. If you don't define this, the default is half a + word. (If this would be less than one storage unit, it is + rounded up to one unit.) + +`LONG_TYPE_SIZE' + A C expression for the size in bits of the type `long' on the + target machine. If you don't define this, the default is one + word. + +`LONG_LONG_TYPE_SIZE' + A C expression for the size in bits of the type `long long' on + the target machine. If you don't define this, the default is + two words. + +`CHAR_TYPE_SIZE' + A C expression for the size in bits of the type `char' on the + target machine. If you don't define this, the default is one + quarter of a word. (If this would be less than one storage + unit, it is rounded up to one unit.) + +`FLOAT_TYPE_SIZE' + A C expression for the size in bits of the type `float' on the + target machine. If you don't define this, the default is one + word. + +`DOUBLE_TYPE_SIZE' + A C expression for the size in bits of the type `double' on the + target machine. If you don't define this, the default is two + words. + +`LONG_DOUBLE_TYPE_SIZE' + A C expression for the size in bits of the type `long double' on + the target machine. If you don't define this, the default is + two words. + +`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 slow (requires more than one instruction). + +`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'. + +`SHIFT_COUNT_TRUNCATED' + Define this macro if shift instructions ignore all but the + lowest few bits of the shift count. It implies that a + sign-extend or zero-extend instruction for the shift count can + be omitted. + +`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' + A C expression which is nonzero if on this machine it is safe to + "convert" an integer of INPREC bits to one of OUTPREC bits + (where OUTPREC is smaller than INPREC) by merely operating on it + as if it had only OUTPREC bits. + + On many machines, this expression can be 1. + +`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. + +`PROMOTE_PROTOTYPES' + Define this macro if an argument declared as `char' or `short' + in a prototype should actually be passed as an `int'. In + addition to avoiding errors in certain cases of mismatch, it + also makes for better code on certain machines. + +`STORE_FLAG_VALUE' + A C expression for the value stored by a store-flag instruction + (`sCOND') when the condition is true. This is usually 1 or -1; + it is required to be an odd number or a negative number. + + Do not define `STORE_FLAG_VALUE' if the machine has no + store-flag instructions. + +`Pmode' + An alias for the machine mode for pointers. Normally the + definition can be + + #define Pmode SImode + +`FUNCTION_MODE' + An alias for the machine mode used for memory references to + functions being called, in `call' RTL expressions. On most + machines this should be `QImode'. + +`INSN_MACHINE_INFO' + This macro should expand into a C structure type to use for the + machine-dependent info field specified with the optional last + argument in `define_insn' and `define_peephole' patterns. For + example, it might expand into `struct machine_info'; then it + would be up to you to define this structure in the `tm.h' file. + + You do not need to define this macro if you do not write the + optional last argument in any of the patterns in the machine + description. + +`DEFAULT_MACHINE_INFO' + This macro should expand into a C initializer to use to + initialize the machine-dependent info for one insn pattern. It + is used for patterns that do not specify the machine-dependent + info. + + If you do not define this macro, zero is used. + +`CONST_COSTS (X, 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. + + CODE is the expression code--redundant, since it can be obtained + with `GET_CODE (X)'. + +`DOLLARS_IN_IDENTIFIERS' + Define this to be nonzero if the character `$' should be allowed + by default in identifier names. + + +File: gcc.info, Node: Assembler Format, Prev: Misc, Up: Machine Macros + +Output of Assembler Code +======================== + +`ASM_SPEC' + A C string constant that tells the GNU CC driver program options + to pass to the assembler. It can also specify how to translate + options you give to GNU CC into options for GNU CC to pass to + the assembler. See the file `tm-sun3.h' for an example of this. + + Do not define this macro if it does not need to do anything. + +`LINK_SPEC' + A C string constant that tells the GNU CC driver program options + to pass to the linker. It can also specify how to translate + options you give to GNU CC into options for GNU CC to pass to + the linker. + + Do not define this macro if it does not need to do anything. + +`LIB_SPEC' + Another C string constant used much like `LINK_SPEC'. The + difference between the two is that `LIBS_SPEC' is used at the + end of the command given to the linker. + + If this macro is not defined, a default is provided that loads + the standard C library from the usual place. See `gcc.c'. + +`LIBG_SPEC' + Another C string constant used much like `LINK_SPEC'. This + controls whether to link `libg.a' when debugging. Some systems + expect this; others do not have any `libg.a'. + + If this macro is not defined, a default is provided that loads + the `libg.a' provided `-g' is specified. See `gcc.c'. + +`STARTFILE_SPEC' + Another C string constant used much like `LINK_SPEC'. The + difference between the two is that `STARTFILE_SPEC' is used at + the very beginning of the command given to the linker. + + If this macro is not defined, a default is provided that loads + the standard C startup file from the usual place. See `gcc.c'. + +`STANDARD_EXEC_PREFIX' + Define this macro as a C string constant if you wish to override + the standard choice of `/usr/local/lib/gcc-' as the default + prefix to try when searching for the executable files of the + compiler. + + The prefix specified by the `-B' option, if any, is tried before + the default prefix. After the default prefix, if the executable + is not found that way, `/usr/lib/gcc-' is tried next; then the + directories in your search path for shell commands are searched. + +`STANDARD_STARTFILE_PREFIX' + Define this macro as a C string constant if you wish to override + the standard choice of `/usr/local/lib/' as the default prefix + to try when searching for startup files such as `crt0.o'. + + In this search, all the prefixes tried for executable files are + tried first. Then comes the default startfile prefix specified + by this macro, followed by the prefixes `/lib/' and `/usr/lib/' + as last resorts. + +`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 `tm-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 `tm-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_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. + +`TEXT_SECTION_ASM_OP' + A C string constant for the assembler operation that should + precede instructions and read-only data. Normally `".text"' is + right. + +`DATA_SECTION_ASM_OP' + A C string constant for the assembler operation to identify the + following data as writable initialized data. Normally `".data"' + is right. + +`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'. + +`SELECT_SECTION (EXP)' + 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. Select the section + by calling `text_section' or one of the alternatives for other + sections. + + Do not define this macro if you use only the standard two + sections and put all read-only variables and constants in 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 use only the standard two + sections and put all constants in the text section. + +`REGISTER_NAMES' + A C initializer containing the assembler's names for the machine + registers, each one as a C string constant. This is what + translates register numbers in the compiler into assembler + language. + +`DBX_REGISTER_NUMBER (REGNO)' + A C expression that returns the DBX register number for the + compiler register number REGNO. In simple cases, the value of + this expression may be REGNO itself. But sometimes there are + some registers that the compiler knows about and DBX does not, + or vice versa. In such cases, some register may need to have + one number in the compiler and another for DBX. + +`DBX_DEBUGGING_INFO' + Define this macro if GNU CC should produce debugging output for + DBX in response to the `-g' option. + +`SDB_DEBUGGING_INFO' + Define this macro if GNU CC should produce debugging output for + SDB in response to the `-g' option. + +`PUT_SDB_OP' + Define these macros to override the assembler syntax for the + special SDB assembler directives. See `sdbout.c' for a list of + these macros and their arguments. If the standard syntax is + used, you need not define them yourself. + +`SDB_GENERATE_FAKE' + Define this macro to override the usual method of constructing a + dummy name for anonymous structure and union types. See + `sdbout.c' for more information. + +`DBX_NO_XREFS' + Define this macro if DBX on your system does not support the + construct `xsTAGNAME'. On some systems, this construct is used + to describe a forward reference to a structure named TAGNAME. + On other systems, this construct is not supported at all. + +`DBX_CONTIN_LENGTH' + A symbol name in DBX-format debugging information is normally + continued (split into two separate `.stabs' directives) when it + exceeds a certain length (by default, 80 characters). On some + operating systems, DBX requires this splitting; on others, + splitting must not be done. You can inhibit splitting by + defining this macro with the value zero. You can override the + default splitting-length by defining this macro as an expression + for the length you desire. + +`DBX_CONTIN_CHAR' + Normally continuation is indicated by adding a `\' character to + the end of a `.stabs' string when a continuation follows. To + use a different character instead, define this macro as a + character constant for the character you want to use. Do not + define this macro if backslash is correct for your system. + +`DBX_STATIC_STAB_DATA_SECTION' + Define this macro if it is necessary to go to the data section + before outputting the `.stabs' pseudo-op for a non-global static + variable. + +`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_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_LABELREF (STREAM, NAME)' + A C statement to output to the stdio stream STREAM a reference + in assembler syntax to a label named NAME. The character `_' + should be added 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_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 `ASM_OUTPUT_LABELREF', + should produce the same output that `ASM_OUTPUT_INTERNAL_LABEL' + would produce with the same PREFIX and NUM. + +`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. These + labels are used for internal purposes, and there is no reason + for them to appear in the symbol table of the object file. On + many systems, the letter `L' at the beginning of a label has + this effect. The usual definition of this macro is as follows: + + fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) + +`ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)' + Define this if the label before a jump-table needs to be output + specially. The first three arguments are the same as for + `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the + jump-table which follows (a `jump_insn' containing an `addr_vec' + or `addr_diff_vec'). + + This feature is used on system V to output a `swbeg' statement + for the table. + + If this macro is not defined, these labels are output with + `ASM_OUTPUT_INTERNAL_LABEL'. + +`ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' + Define this if something special must be output at the end of a + jump-table. The definition should be a C statement to be + executed after the assembler code for the table is written. It + should write the appropriate code to stdio stream STREAM. The + argument TABLE is the jump-table insn, and NUM is the + label-number of the preceding label. + + If this macro is not defined, nothing special is output at the + end of the jump-table. + +`ASM_OUTPUT_ALIGN_CODE (FILE)' + A C expression to output text to align the location counter in + the way that is desirable at a point in the code that is reached + only by jumping. + + This macro need not be defined if you don't want any special + alignment to be done at such a time. Most machine descriptions + do not currently define the macro. + +`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. + + This string will be used as the 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. + +`ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' + A C expression to output to STREAM some assembler code which + will push hard register number REGNO onto the stack. The code + need not be optimal, since this macro is used only when profiling. + +`ASM_OUTPUT_REG_POP (STREAM, REGNO)' + A C expression to output to STREAM some assembler code which + will pop hard register number REGNO off of the stack. The code + need not be optimal, since this macro is used only when profiling. + +`ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' + This macro should be provided on machines where the addresses in + a dispatch table are relative to the table's own address. + + The definition should be a C statement to output to the stdio + stream STREAM an assembler pseudo-instruction to generate a + difference between two labels. VALUE and REL are the numbers of + two internal labels. The definitions of these labels are output + using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in + the same way here. For example, + + fprintf (STREAM, "\t.word L%d-L%d\n", + VALUE, REL) + +`ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' + This macro should be provided on machines where the addresses in + a dispatch table are absolute. + + The definition should be a C statement to output to the stdio + stream STREAM an assembler pseudo-instruction to generate a + reference to a label. VALUE is the number of an internal label + whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. + For example, + + fprintf (STREAM, "\t.word L%d\n", VALUE) + +`ASM_OUTPUT_DOUBLE (STREAM, VALUE)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a `double' constant whose value is + VALUE. VALUE will be a C expression of type `double'. + +`ASM_OUTPUT_FLOAT (STREAM, VALUE)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a `float' constant whose value is VALUE. + vALUE will be a C expression of type `float'. + +`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 a `int', `short' or `char' constant + 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. + +`ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)' + A C statement to output to the stdio stream STREAM an assembler + instruction to assemble a `long long' constant whose value is + EXP. The argument EXP will be an RTL expression which + represents a constant value. It may be a `const_double' RTX, or + it may be an ordinary single-precision constant. In the latter + case, you should zero-extend it. + +`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_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_SKIP (STREAM, NBYTES)' + A C statement to output to the stdio stream STREAM an assembler + instruction to advance the location counter by NBYTES bytes. + NBYTES will be a C expression of type `int'. + +`ASM_OUTPUT_ALIGN (STREAM, POWER)' + A C statement to output to the stdio stream STREAM an assembler + instruction to advance the location counter to a multiple of 2 + to the POWER bytes. POWER will be a C expression of type `int'. + +`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_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_SOURCE_FILENAME (STREAM, NAME)' + A C statment to output DBX or SDB 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 debugging + information for the debugger in use is appropriate. + +`ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)' + A C statment 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. + +`TARGET_BELL' + A C constant expression for the integer value for escape + sequence `\a'. + +`TARGET_BS' +`TARGET_TAB' +`TARGET_NEWLINE' + C constant expressions for the integer values for escape + sequences `\b', `\t' and `\n'. + +`TARGET_VT' +`TARGET_FF' +`TARGET_CR' + C constant expressions for the integer values for escape + sequences `\v', `\f' and `\r'. + +`ASM_OUTPUT_OPCODE (STREAM, PTR)' + Define this macro if you are using an unusual assembler that + requires different names for the machine instructions. + + The definition is a C statement or statements which output an + assembler instruction opcode to the stdio stream STREAM. The + macro-operand PTR is a variable of type `char *' which points to + the opcode name in its "internal" form--the form that is written + in the machine description. The definition should output the + opcode name to STREAM, performing any translation you desire, + and increment the variable PTR to point at the end of the opcode + so that it will not be output twice. + + In fact, your macro definition may process less than the entire + opcode name, or more than the opcode name; but if you want to + process text that includes `%'-sequences to substitute operands, + you must take care of the substitution yourself. Just be sure + to increment PTR over whatever text should not be output normally. + + If you need to look at the operand values, they can be found as + the elements of `recog_operand'. + + If the macro definition does nothing, the instruction is output + in the usual way. + +`FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)' + If defined, a C statement to be executed just prior to the + output of assembler code for INSN, to modify the extracted + operands so they will be output differently. + + Here the argument OPVEC is the vector containing the operands + extracted from INSN, and NOPERANDS is the number of elements of + the vector which contain meaningful data for this insn. The + contents of this vector are what will be used to convert the + insn template into assembler code, so you can change the + assembler output by changing the contents of the vector. + + This macro is useful when various assembler syntaxes share a + single file of instruction patterns; by defining this macro + differently, you can cause a large class of instructions to be + output differently (such as with rearranged operands). + Naturally, variations in assembler syntax affecting individual + insn patterns ought to be handled by writing conditional output + routines in those patterns. + + If this macro is not defined, it is equivalent to a null + statement. + +`PRINT_OPERAND (STREAM, X, CODE)' + A C compound statement to output to stdio stream STREAM the + assembler syntax for an instruction operand X. X is an RTL + expression. + + CODE is a value that can be used to specify one of several ways + of printing the operand. It is used when identical operands + must be printed differently depending on the context. CODE + comes from the `%' specification that was used to request + printing of the operand. If the specification was just `%DIGIT' + then CODE is 0; if the specification was `%LTR DIGIT' then CODE + is the ASCII code for LTR. + + If X is a register, this macro should print the register's name. + The names can be found in an array `reg_names' whose type is + `char *[]'. `reg_names' is initialized from `REGISTER_NAMES'. + + When the machine description has a specification `%PUNCT' (a `%' + followed by a punctuation character), this macro is called with + a null pointer for X and the punctuation character for CODE. + +`PRINT_OPERAND_PUNCT_VALID_P (CODE)' + A C expression which evaluates to true if CODE is a valid + punctuation character for use in the `PRINT_OPERAND' macro. If + `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no + punctuation characters (except for the standard one, `%') are + used in this way. + +`PRINT_OPERAND_ADDRESS (STREAM, X)' + A C compound statement to output to stdio stream STREAM the + assembler syntax for an instruction operand that is a memory + reference whose address is X. X is an RTL expression. + +`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 ")" + +
\ No newline at end of file |