--- gcc/gcc.info-10 2018/04/24 16:59:07 1.1.1.4 +++ gcc/gcc.info-10 2018/04/24 17:00:57 1.1.1.5 @@ -1,13 +1,13 @@ -Info file gcc.info, produced by Makeinfo, -*- Text -*- from input +This is Info file gcc.info, produced by Makeinfo-1.47 from the 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 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 @@ -21,8 +21,8 @@ one. 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. +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 @@ -40,132 +40,129 @@ Addressing Modes 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. + 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. + 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. + 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. + 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. + 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 + 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. + 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. + 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. + 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. + `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'. + 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. + 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. + 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. + 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 + 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. + 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. + 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. + 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. + 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. + 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 @@ -174,47 +171,45 @@ Parameters for Delayed Branch Optimizati ========================================== `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. + 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. + 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. + 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. + 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. + 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 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. + 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 @@ -223,16 +218,16 @@ Parameters for Delayed Branch Optimizati 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. + 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 @@ -241,10 +236,10 @@ 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. +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 @@ -255,10 +250,10 @@ machine-specific information by defining 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. + 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' @@ -267,25 +262,24 @@ machine-specific information by defining 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 + 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'. @@ -301,24 +295,24 @@ numbers. This means that in a cross-com 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). + 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. + 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. +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 @@ -337,23 +331,22 @@ side effects. `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. + 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 + 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. + 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 + 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). @@ -363,9 +356,9 @@ folding will not happen for floating poi `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. + 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 @@ -373,13 +366,13 @@ folding will not happen for floating poi 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. + 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. + 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 @@ -397,13 +390,12 @@ Miscellaneous Parameters elements of a jump-table should have. `CASE_VECTOR_PC_RELATIVE' - Define this macro if jump-tables should contain relative - addresses. + 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. + 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 @@ -411,32 +403,32 @@ Miscellaneous Parameters `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. + 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. + 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'. + 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. + 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 @@ -444,35 +436,32 @@ Miscellaneous Parameters `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. + 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.) + 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. + 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. + 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.) + 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. + 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 @@ -481,37 +470,36 @@ Miscellaneous Parameters `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. + 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). + 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. + 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: + 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. + 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. + "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. @@ -520,18 +508,18 @@ Miscellaneous Parameters 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. + 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. + (`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. + 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 @@ -548,30 +536,29 @@ Miscellaneous Parameters 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. + 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. + 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. + 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)'. @@ -587,65 +574,63 @@ 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. + 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. + 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. + 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'. + 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 + 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'. + 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. + 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'. + 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 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 + 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'. + 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. + 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 @@ -653,8 +638,8 @@ Output of Assembler Code 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. + 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'. @@ -671,13 +656,13 @@ Output of Assembler Code 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). + 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 + 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. @@ -688,9 +673,9 @@ Output of Assembler Code `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. + `"#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' @@ -700,9 +685,8 @@ Output of Assembler Code 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. + 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 @@ -710,36 +694,34 @@ Output of Assembler Code 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). + 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'. + 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. + 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 + 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. + 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 @@ -749,25 +731,25 @@ Output of Assembler Code `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. + 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. + 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. + 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. + 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 @@ -776,26 +758,26 @@ Output of Assembler Code `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. + 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. + 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. + 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 @@ -804,7 +786,7 @@ Output of Assembler Code `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 + 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. @@ -817,34 +799,33 @@ Output of Assembler Code `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'). + 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. + 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. + 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. + 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'. + 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 @@ -856,46 +837,46 @@ Output of Assembler Code `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: + 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'). + `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. + 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. + 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. + 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. + 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. + 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 @@ -903,83 +884,80 @@ Output of Assembler Code 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. + 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. + 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. + 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. + 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, + 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. + 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, + 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'. + 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'. + 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. + 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. + 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 @@ -987,49 +965,48 @@ Output of Assembler Code `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'. + 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. + 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'. + 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. + 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. + 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 + 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. + 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 @@ -1040,33 +1017,33 @@ Output of Assembler Code 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. + 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. + 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'. + 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'. + 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'. + 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 @@ -1077,72 +1054,71 @@ Output of Assembler Code 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. + 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. + 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 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. + 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. + 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. + 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. + 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. + 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'. + 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. + 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. + 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 @@ -1152,8 +1128,8 @@ Output of Assembler Code `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: + syntax in the assembler for grouping arithmetic expressions. The + following definitions are correct for most assemblers: #define ASM_OPEN_PAREN "(" #define ASM_CLOSE_PAREN ")"