--- gcc/internals-6 2018/04/24 16:38:23 1.1.1.1 +++ gcc/internals-6 2018/04/24 16:40:21 1.1.1.3 @@ -1,544 +1,1017 @@ -Info file internals, produced by Makeinfo, -*- Text -*- -from input file internals.texinfo. - - +Info file internals, produced by Makeinfo, -*- Text -*- from input +file internals.texinfo. This file documents the internals of the GNU compiler. Copyright (C) 1988 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 +that the section entitled ``GNU CC General Public License'' is +included exactly as in the original, and provided that the entire +resulting derived work is distributed under the terms of a permission +notice identical to this one. + +Permission is granted to copy and distribute translations of this +manual into another language, under the above conditions for modified +versions, except that the section entitled ``GNU CC General Public +License'' and this permission notice may be included in translations +approved by the Free Software Foundation instead of in the original +English. -Permission is granted to copy and distribute modified versions of this -manual under the conditions for verbatim copying, provided also that the -section entitled ``GNU CC General Public License'' is included exactly as -in the original, and provided that the entire resulting derived work is -distributed under the terms of a permission notice identical to this one. -Permission is granted to copy and distribute translations of this manual -into another language, under the above conditions for modified versions, -except that the section entitled ``GNU CC General Public License'' and -this permission notice may be included in translations approved by the -Free Software Foundation instead of in the original English. + +File: internals, Node: Registers, Next: Register Classes, Prev: Storage Layout, Up: Machine Macros +Register Usage +============== +`FIRST_PSEUDO_REGISTER' + Number of hardware registers known to the compiler. They + receive numbers 0 through `FIRST_PSEUDO_REGISTER-1'; thus, the + first pseudo register's number really is assigned the number + `FIRST_PSEUDO_REGISTER'. + +`FIXED_REGISTERS' + An initializer that says which registers are used for fixed + purposes all throughout the compiled code and are therefore not + available for general allocation. These would include the stack + pointer, the frame pointer (except on machines where that can be + used as a general register when no frame pointer is needed), the + program counter on machines where that is considered one of the + addressable registers, and any other numbered register with a + standard use. + + This information is expressed as a sequence of numbers, + separated by commas and surrounded by braces. The Nth number is + 1 if register N is fixed, 0 otherwise. + + The table initialized from this macro, and the table initialized + by the following one, may be overridden at run time either + automatically, by the actions of the macro + `CONDITIONAL_REGISTER_USAGE', or by the user with the command + options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. + +`CALL_USED_REGISTERS' + Like `FIXED_REGISTERS' but has 1 for each register that is + clobbered (in general) by function calls as well as for fixed + registers. This macro therefore identifies the registers that + are not available for general allocation of values that must + live across function calls. + + If a register has 0 in `CALL_USED_REGISTERS', the compiler + automatically saves it on function entry and restores it on + function exit, if the register is used within the function. + +`CONDITIONAL_REGISTER_USAGE' + Zero or more C statements that may conditionally modify two + variables `fixed_regs' and `call_used_regs' (both of type `char + []') after they have been initialized from the two preceding + macros. + + This is necessary in case the fixed or call-clobbered registers + depend on target flags. + + You need not define this macro if it has no work to do. + + If the usage of an entire class of registers depends on the + target flags, you may indicate this to gcc by using this macro + to modify `fixed_regs' and `call_used_regs' to 1 for each of the + registers in the classes which should not be used by gcc. Also + define the macro `REG_CLASS_FROM_LETTER' to return `NO_REGS' if + it is called with a letter for a class that shouldn't be used. + + (However, if this class is not included in `GENERAL_REGS' and + all of the insn patterns whose constraints permit this class are + controlled by target switches, then GCC will automatically avoid + using these registers when the target switches are opposed to + them.) + +`OVERLAPPING_REGNO_P (REGNO)' + If defined, this is a C expression whose value is REGNO is + nonzero if hard register number REGNO is an overlapping + register. This means a hard register which overlaps a hard + register with a different number. (Such overlap is undesirable, + but occasionally it allows a machine to be supported which + otherwise could not be.) This macro must return nonzero for + *all* the registers which overlap each other. GNU CC can use an + overlapping register only in certain limited ways. It can be + used for allocation within a basic block, and may be spilled for + reloading; that is all. + + If this macro is not defined, it means that none of the hard + registers overlap each other. This is the usual situation. + +`INSN_CLOBBERS_REGNO_P (INSN, REGNO)' + If defined, this is a C expression whose value should be nonzero + if the insn INSN has the effect of mysteriously clobbering the + contents of hard register number REGNO. By ``mysterious'' we + mean that the insn's RTL expression doesn't describe such an + effect. + + If this macro is not defined, it means that no insn clobbers + registers mysteriously. This is the usual situation; all else + being equal, it is best for the RTL expression to show all the + activity. + +`PRESERVE_DEATH_INFO_REGNO_P (REGNO)' + If defined, this is a C expression whose value is nonzero if + accurate `REG_DEAD' notes are needed for hard register number + REGNO at the time of outputting the assembler code. When this + is so, a few optimizations that take place after register + allocation and could invalidate the death notes are not done + when this register is involved. + + You would arrange to preserve death info for a register when + some of the code in the machine description which is executed to + write the assembler code looks at the the death notes. This is + necessary only when the actual hardware feature which GNU CC + thinks of as a register is not actually a register of the usual + sort. (It might, for example, be a hardware stack.) + + If this macro is not defined, it means that no death notes need + to be preserved. This is the usual situation. + +`HARD_REGNO_REGS (REGNO, MODE)' + A C expression for the number of consecutive hard registers, + starting at register number REGNO, required to hold a value of + mode MODE. + + On a machine where all registers are exactly one word, a + suitable definition of this macro is + + #define HARD_REGNO_NREGS(REGNO, MODE) \ + ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \ + / UNITS_PER_WORD)) + +`HARD_REGNO_MODE_OK (REGNO, MODE)' + A C expression that is nonzero if it is permissible to store a + value of mode MODE in hard register number REGNO (or in several + registers starting with that one). For a machine where all + registers are equivalent, a suitable definition is + + #define HARD_REGNO_MODE_OK(REGNO, MODE) 1 + + It is not necessary for this macro to check for fixed register + numbers because the allocation mechanism considers them to be + always occupied. + + Many machines have special registers for floating point + arithmetic. Often people assume that floating point machine + modes are allowed only in floating point registers. This is not + true. Any registers that can hold integers can safely *hold* a + floating point machine mode, whether or not floating arithmetic + can be done on it in those registers. + + The true significance of special floating registers is rather + than non-floating-point machine modes *may not* go in those + registers. This is true if the floating registers normalize any + value stored in them, because storing a non-floating value there + would garble it. If the floating registers do not automatically + normalize, if you can store any bit pattern in one and retrieve + it unchanged without a trap, then any machine mode may go in a + floating register and this macro should say so. + + Sometimes there are floating registers that are especially slow + to access, so that it is better to store a value in a stack + frame than in such a register if floating point arithmetic is + not being done. As long as the floating registers are not in + class `GENERAL_REGS', they will not be used unless some insn's + constraint asks for one. + + It is obligatory to support floating point `move' instructions + into and out of general registers, because unions and structures + (which have modes `SImode' or `DImode') can be in those + registers and they may have floating point members. + +`MODES_TIEABLE_P (MODE1, MODE2)' + A C expression that is nonzero if it is desirable to choose + register allocation so as to avoid move instructions between a + value of mode MODE1 and a value of mode MODE2. + + If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, + MODE2)' are ever different for any R, then `MODES_TIEABLE_P + (MODE1, MODE2)' must be zero. + +`PC_REGNUM' + If the program counter has a register number, define this as + that register number. Otherwise, do not define it. + +`STACK_POINTER_REGNUM' + The register number of the stack pointer register, which must + also be a fixed register according to `FIXED_REGISTERS'. On + many machines, the hardware determines which register this is. + +`FRAME_POINTER_REGNUM' + The register number of the frame pointer register, which is used + to access automatic variables in the stack frame. On some + machines, the hardware determines which register this is. On + other machines, you can choose any register you wish for this + purpose. + +`FRAME_POINTER_REQUIRED' + A C expression which is nonzero if a function must have and use + a frame pointer. This expression is evaluated in the reload + pass, in the function `reload', and it can in principle examine + the current function and decide according to the facts, but on + most machines the constant 0 or the constant 1 suffices. Use 0 + when the machine allows code to be generated with no frame + pointer, and doing so saves some time or space. Use 1 when + there is no possible advantage to avoiding a frame pointer. + + In certain cases, the compiler does not know how to do without a + frame pointer. The compiler recognizes those cases and + automatically gives the function a frame pointer regardless of + what `FRAME_POINTER_REQUIRED' says. You don't need to worry + about them. + + In a function that does not require a frame pointer, the frame + pointer register can be allocated for ordinary usage, unless you + mark it as a fixed register. See `FIXED_REGISTERS' for more + information. + +`ARG_POINTER_REGNUM' + The register number of the arg pointer register, which is used + to access the function's argument list. On some machines, this + is the same as the frame pointer register. On some machines, + the hardware determines which register this is. On other + machines, you can choose any register you wish for this purpose. + If this is not the same register as the frame pointer register, + then you must mark it as a fixed register according to + `FIXED_REGISTERS'. + +`STATIC_CHAIN_REGNUM' + The register number used for passing a function's static chain + pointer. This is needed for languages such as Pascal and Algol + where functions defined within other functions can access the + local variables of the outer functions; it is not currently used + because C does not provide this feature, but you must define the + macro. + + The static chain register need not be a fixed register. + +`STRUCT_VALUE_REGNUM' + When a function's value's mode is `BLKmode', the value is not + returned according to `FUNCTION_VALUE'. Instead, the caller + passes the address of a block of memory in which the value + should be stored. + + If this value is passed in a register, then + `STRUCT_VALUE_REGNUM' should be the number of that register. + +`STRUCT_VALUE' + If the structure value address is not passed in a register, + define `STRUCT_VALUE' as an expression returning an RTX for the + place where the address is passed. If it returns a `mem' RTX, + the address is passed as an ``invisible'' first argument. + +`STRUCT_VALUE_INCOMING_REGNUM' + On some architectures the place where the structure value + address is found by the called function is not the same place + that the caller put it. This can be due to register windows, or + it could be because the function prologue moves it to a + different place. + + If the incoming location of the structure value address is in a + register, define this macro as the register number. + +`STRUCT_VALUE_INCOMING' + If the incoming location is not a register, define + `STRUCT_VALUE_INCOMING' as an expression for an RTX for where + the called function should find the value. If it should find + the value on the stack, define this to create a `mem' which + refers to the frame pointer. If the value is a `mem', the + compiler assumes it is for an invisible first argument, and + leaves space for it when finding the first real argument. + +`REG_ALLOC_ORDER' + If defined, an initializer for a vector of integers, containing + the numbers of hard registers in the order in which the GNU CC + should prefer to use them (from most preferred to least). + + If this macro is not defined, registers are used lowest numbered + first (all else being equal). + + One use of this macro is on the 360, where the highest numbered + registers must always be saved and the save-multiple-registers + instruction supports only sequences of consecutive registers. + This macro is defined to cause the highest numbered allocatable + registers to be used first. -  -File: internals, Node: Misc, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros - -Miscellaneous Parameters -======================== +File: internals, Node: Register Classes, Next: Stack Layout, Prev: Registers, Up: Machine Macros -`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 with - no error message. - -`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. - -`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. - -`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. - - 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'. - -`CONST_COST (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. +Register Classes +================ - CODE is the expression code---redundant, since it can be obtained with - `GET_CODE (X)'. +On many machines, the numbered registers are not all equivalent. For +example, certain registers may not be allowed for indexed addressing; +certain registers may not be allowed in some instructions. These +machine restrictions are described to the compiler using "register +classes". + +You define a number of register classes, giving each one a name and +saying which of the registers belong to it. Then you can specify +register classes that are allowed as operands to particular +instruction patterns. + +In general, each register will belong to several classes. In fact, +one class must be named `ALL_REGS' and contain all the registers. +Another class must be named `NO_REGS' and contain no registers. +Often the union of two classes will be another class; however, this +is not required. + +One of the classes must be named `GENERAL_REGS'. There is nothing +terribly special about the name, but the operand constraint letters +`r' and `g' specify this class. If `GENERAL_REGS' is the same as +`ALL_REGS', just define it as a macro which expands to `ALL_REGS'. + +The way classes other than `GENERAL_REGS' are specified in operand +constraints is through machine-dependent operand constraint letters. +You can define such letters to correspond to various classes, then +use them in operand constraints. + +You should define a class for the union of two classes whenever some +instruction allows both classes. For example, if an instruction +allows either a floating-point (coprocessor) register or a general +register for a certain operand, you should define a class +`FLOAT_OR_GENERAL_REGS' which includes both of them. Otherwise you +will get suboptimal code. + +You must also specify certain redundant information about the +register classes: for each class, which classes contain it and which +ones are contained in it; for each pair of classes, the largest class +contained in their union. + +Register classes used for input-operands of bitwise-and or shift +instructions have a special requirement: each such class must have, +for each fixed-point machine mode, a subclass whose registers can +transfer that mode to or from memory. For example, on some machines, +the operations for single-byte values (`QImode') are limited to +certain registers. When this is so, each register class that is used +in a bitwise-and or shift instruction must have a subclass consisting +of registers from which single-byte values can be loaded or stored. +This is so that `PREFERRED_RELOAD_CLASS' can always have a possible +value to return. + +`enum reg_class' + An enumeral type that must be defined with all the register + class names as enumeral values. `NO_REGS' must be first. + `ALL_REGS' must be the last register class, followed by one more + enumeral value, `LIM_REG_CLASSES', which is not a register class + but rather tells how many classes there are. + + Each register class has a number, which is the value of casting + the class name to type `int'. The number serves as an index in + many of the tables described below. + +`N_REG_CLASSES' + The number of distinct register classes, defined as follows: + + #define N_REG_CLASSES (int) LIM_REG_CLASSES + +`REG_CLASS_NAMES' + An initializer containing the names of the register classes as C + string constants. These names are used in writing some of the + debugging dumps. + +`REG_CLASS_CONTENTS' + An initializer containing the contents of the register classes, + as integers which are bit masks. The Nth integer specifies the + contents of class N. The way the integer MASK is interpreted is + that register R is in the class if `MASK & (1 << R)' is 1. + + When the machine has more than 32 registers, an integer does not + suffice. Then the integers are replaced by sub-initializers, + braced groupings containing several integers. Each + sub-initializer must be suitable as an initializer for the type + `HARD_REG_SET' which is defined in `hard-reg-set.h'. + +`REGNO_REG_CLASS (REGNO)' + A C expression whose value is a register class containing hard + register REGNO. In general there is more that one such class; + choose a class which is "minimal", meaning that no smaller class + also contains the register. + +`BASE_REG_CLASS' + A macro whose definition is the name of the class to which a + valid base register must belong. A base register is one used in + an address which is the register value plus a displacement. + +`INDEX_REG_CLASS' + A macro whose definition is the name of the class to which a + valid index register must belong. An index register is one used + in an address where its value is either multiplied by a scale + factor or added to another register (as well as added to a + displacement). + +`REG_CLASS_FROM_LETTER (CHAR)' + A C expression which defines the machine-dependent operand + constraint letters for register classes. If CHAR is such a + letter, the value should be the register class corresponding to + it. Otherwise, the value should be `NO_REGS'. + +`REGNO_OK_FOR_BASE_P (NUM)' + A C expression which is nonzero if register number NUM is + suitable for use as a base register in operand addresses. It + may be either a suitable hard register or a pseudo register that + has been allocated such a hard register. + +`REGNO_OK_FOR_INDEX_P (NUM)' + A C expression which is nonzero if register number NUM is + suitable for use as an index register in operand addresses. It + may be either a suitable hard register or a pseudo register that + has been allocated such a hard register. + + The difference between an index register and a base register is + that the index register may be scaled. If an address involves + the sum of two registers, neither one of them scaled, then + either one may be labeled the ``base'' and the other the + ``index''; but whichever labeling is used must fit the machine's + constraints of which registers may serve in each capacity. The + compiler will try both labelings, looking for one that is valid, + and will reload one or both registers only if neither labeling + works. + +`PREFERRED_RELOAD_CLASS (X, CLASS)' + A C expression that places additional restrictions on the + register class to use when it is necessary to copy value X into + a register in class CLASS. The value is a register class; + perhaps CLASS, or perhaps another, smaller class. On many + machines, the definition + + #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS + + is safe. + + Sometimes returning a more restrictive class makes better code. + For example, on the 68000, when X is an integer constant that is + in range for a `moveq' instruction, the value of this macro is + always `DATA_REGS' as long as CLASS includes the data registers. + Requiring a data register guarantees that a `moveq' will be used. + + If X is a `const_double', by returning `NO_REGS' you can force X + into a memory constant. This is useful on certain machines + where immediate floating values cannot be loaded into certain + kinds of registers. + + In a shift instruction or a bitwise-and instruction, the mode of + X, the value being reloaded, may not be the same as the mode of + the instruction's operand. (They will both be fixed-point + modes, however.) In such a case, CLASS may not be a safe value + to return. CLASS is certainly valid for the instruction, but it + may not be valid for reloading X. This problem can occur on + machines such as the 68000 and 80386 where some registers can + handle full-word values but cannot handle single-byte values. + + On such machines, this macro must examine the mode of X and + return a subclass of CLASS which can handle loads and stores of + that mode. On the 68000, where address registers cannot handle + `QImode', if X has `QImode' then you must return `DATA_REGS'. + If CLASS is `ADDR_REGS', then there is no correct value to + return; but the shift and bitwise-and instructions don't use + `ADDR_REGS', so this fatal case never arises. + +`CLASS_MAX_NREGS (CLASS, MODE)' + A C expression for the maximum number of consecutive registers + of class CLASS needed to hold a value of mode MODE. + + This is closely related to the macro `HARD_REGNO_NREGS'. In + fact, the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' + should be the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' + for all REGNO values in the class CLASS. + + This macro helps control the handling of multiple-word values in + the reload pass. + +Two other special macros describe which constants fit which +constraint letters. + +`CONST_OK_FOR_LETTER_P (VALUE, C)' + A C expression that defines the machine-dependent operand + constraint letters that specify particular ranges of integer + values. If C is one of those letters, the expression should + check that VALUE, an integer, is in the appropriate range and + return 1 if so, 0 otherwise. If C is not one of those letters, + the value should be 0 regardless of VALUE. + +`CONST_DOUBLE_OK_FOR_LETTER_P (VALUE, C)' + A C expression that defines the machine-dependent operand + constraint letters that specify particular ranges of floating + values. If C is one of those letters, the expression should + check that VALUE, an RTX of code `const_double', is in the + appropriate range and return 1 if so, 0 otherwise. If C is not + one of those letters, the value should be 0 regardless of VALUE. -`DOLLARS_IN_IDENTIFIERS' - Define this if the character `$' should be allowed in identifier names.  -File: internals, Node: Condition Code, Next: Assembler Format, Prev: Misc, Up: Machine Macros +File: internals, Node: Stack Layout, Next: Library Names, Prev: Register Classes, Up: Machine Macros -Condition Code Information -========================== +Describing Stack Layout +======================= + +`STACK_GROWS_DOWNWARD' + Define this macro if pushing a word onto the stack moves the + stack pointer to a smaller address. + + When we say, ``define this macro if ...,'' it means that the + compiler checks this macro only with `#ifdef' so the precise + definition used does not matter. + +`FRAME_GROWS_DOWNWARD' + Define this macro if the addresses of local variable slots are + at negative offsets from the frame pointer. + +`STARTING_FRAME_OFFSET' + Offset from the frame pointer to the first local variable slot + to be allocated. + + If `FRAME_GROWS_DOWNWARD', the next slot's offset is found by + subtracting the length of the first slot from + `STARTING_FRAME_OFFSET'. Otherwise, it is found by adding the + length of the first slot to the value `STARTING_FRAME_OFFSET'. + +`PUSH_ROUNDING (NPUSHED)' + A C expression that is the number of bytes actually pushed onto + the stack when an instruction attempts to push NPUSHED bytes. + + If the target machine does not have a push instruction, do not + define this macro. That directs GNU CC to use an alternate + strategy: to allocate the entire argument block and then store + the arguments into it. + + On some machines, the definition + + #define PUSH_ROUNDING(BYTES) (BYTES) + + will suffice. But on other machines, instructions that appear + to push one byte actually push two bytes in an attempt to + maintain alignment. Then the definition should be + + #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) + +`FIRST_PARM_OFFSET (FUNDECL)' + Offset from the argument pointer register to the first + argument's address. On some machines it may depend on the data + type of the function. (In the next version of GNU CC, the + argument will be changed to the function data type rather than + its declaration.) + +`RETURN_POPS_ARGS (FUNTYPE)' + A C expression that should be 1 if a function pops its own + arguments on returning, or 0 if the function pops no arguments + and the caller must therefore pop them all after the function + returns. + + FUNTYPE is a C variable whose value is a tree node that + describes the function in question. Normally it is a node of + type `FUNCTION_TYPE' that describes the data type of the function. + From this it is possible to obtain the data types of the value + and arguments (if known). + + When a call to a library function is being considered, FUNTYPE + will contain an identifier node for the library function. Thus, + if you need to distinguish among various library functions, you + can do so by their names. Note that ``library function'' in + this context means a function used to perform arithmetic, whose + name is known specially in the compiler and was not mentioned in + the C code being compiled. + + On the Vax, all functions always pop their arguments, so the + definition of this macro is 1. On the 68000, using the standard + calling convention, no functions pop their arguments, so the + value of the macro is always 0 in this case. But an alternative + calling convention is available in which functions that take a + fixed number of arguments pop them but other functions (such as + `printf') pop nothing (the caller pops all). When this + convention is in use, FUNTYPE is examined to determine whether a + function takes a fixed number of arguments. + +`FUNCTION_VALUE (VALTYPE, FUNC)' + A C expression to create an RTX representing the place where a + function returns a value of data type VALTYPE. VALTYPE is a + tree node representing a data type. Write `TYPE_MODE (VALTYPE)' + to get the machine mode used to represent that type. On many + machines, only the mode is relevant. (Actually, on most + machines, scalar values are returned in the same place + regardless of mode). + + If the precise function being called is known, FUNC is a tree + node (`FUNCTION_DECL') for it; otherwise, FUNC is a null + pointer. This makes it possible to use a different + value-returning convention for specific functions when all their + calls are known. + +`FUNCTION_OUTGOING_VALUE (VALTYPE, FUNC)' + Define this macro if the target machine has ``register windows'' + so that the register in which a function returns its value is + not the same as the one in which the caller sees the value. + + For such machines, `FUNCTION_VALUE' computes the register in + which the caller will see the value, and + `FUNCTION_OUTGOING_VALUE' should be defined in a similar fashion + to tell the function where to put the value. + + If `FUNCTION_OUTGOING_VALUE' is not defined, `FUNCTION_VALUE' + serves both purposes. + +`LIBCALL_VALUE (MODE)' + A C expression to create an RTX representing the place where a + library function returns a value of mode MODE. If the precise + function being called is known, FUNC is a tree node + (`FUNCTION_DECL') for it; otherwise, FUNC is a null pointer. + This makes it possible to use a different value-returning + convention for specific functions when all their calls are known. + + Note that ``library function'' in this context means a compiler + support routine, used to perform arithmetic, whose name is known + specially by the compiler and was not mentioned in the C code + being compiled. + +`FUNCTION_VALUE_REGNO_P (REGNO)' + A C expression that is nonzero if REGNO is the number of a hard + register in which the values of called function may come back. + + A register whose use for returning values is limited to serving + as the second of a pair (for a value of type `double', say) need + not be recognized by this macro. So for most machines, this + definition suffices: + + #define FUNCTION_VALUE_REGNO_P(N) ((N) == 0) + + If the machine has register windows, so that the caller and the + called function use different registers for the return value, + this macro should recognize only the caller's register numbers. + +`FUNCTION_ARG (CUM, MODE, TYPE, NAMED)' + A C expression that controls whether a function argument is + passed in a register, and which register. + + The arguments are CUM, which summarizes all the previous + arguments; MODE, the machine mode of the argument; TYPE, the + data type of the argument as a tree node or 0 if that is not + known (which happens for C support library functions); and + NAMED, which is 1 for an ordinary argument and 0 for nameless + arguments that correspond to `...' in the called function's + prototype. + + The value of the expression should either be a `reg' RTX for the + hard register in which to pass the argument, or zero to pass the + argument on the stack. + + For the Vax and 68000, where normally all arguments are pushed, + zero suffices as a definition. + +`FUNCTION_INCOMING_ARG (CUM, MODE, TYPE, NAMED)' + Define this macro if the target machine has ``register + windows'', so that the register in which a function sees an + arguments is not necessarily the same as the one in which the + caller passed the argument. + + For such machines, `FUNCTION_ARG' computes the register in which + the caller passes the value, and `FUNCTION_INCOMING_ARG' should + be defined in a similar fashion to tell the function being + called where the arguments will arrive. + + If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves + both purposes. + +`FUNCTION_ARG_PARTIAL_NREGS (CUM, MODE, TYPE, NAMED)' + A C expression for the number of words, at the beginning of an + argument, must be put in registers. The value must be zero for + arguments that are passed entirely in registers or that are + entirely pushed on the stack. + + On some machines, certain arguments must be passed partially in + registers and partially in memory. On these machines, typically + the first N words of arguments are passed in registers, and the + rest on the stack. If a multi-word argument (a `double' or a + structure) crosses that boundary, its first few words must be + passed in registers and the rest must be pushed. This macro + tells the compiler when this occurs, and how many of the words + should go in registers. + + `FUNCTION_ARG' for these arguments should return the first + register to be used by the caller for this argument; likewise + `FUNCTION_INCOMING_ARG', for the called function. + +`CUMULATIVE_ARGS' + A C type for declaring a variable that is used as the first + argument of `FUNCTION_ARG' and other related values. For some + target machines, the type `int' suffices and can hold the number + of bytes of argument so far. + +`INIT_CUMULATIVE_ARGS (CUM, FNTYPE)' + A C statement (sans semicolon) for initializing the variable CUM + for the state at the beginning of the argument list. The + variable has type `CUMULATIVE_ARGS'. The value of FNTYPE is the + tree node for the data type of the function which will receive + the args, or 0 if the args are to a compiler support library + function. + +`FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)' + Update the summarizer variable CUM to advance past an argument + in the argument list. The values MODE, TYPE and NAMED describe + that argument. Once this is done, the variable CUM is suitable + for analyzing the *following* argument with `FUNCTION_ARG', etc. + +`FUNCTION_ARG_REGNO_P (REGNO)' + A C expression that is nonzero if REGNO is the number of a hard + register in which function arguments are sometimes passed. This + does *not* include implicit arguments such as the static chain + and the structure-value address. On many machines, no registers + can be used for this purpose since all function arguments are + pushed on the stack. + +`FUNCTION_ARG_PADDING (MODE, SIZE)' + If defined, a C expression which determines whether, and in + which direction, to pad out an argument with extra space. The + value should be of type `enum direction': either `upward' to pad + above the argument, `downward' to pad below, or `none' to + inhibit padding. + + The argument SIZE is an RTX which describes the size of the + argument, in bytes. It should be used only if MODE is + `BLKmode'. Otherwise, SIZE is 0. + + This macro does not control the *amount* of padding; that is + always just enough to reach the next multiple of `PARM_BOUNDARY'. + + This macro has a default definition which is right for most + systems. For little-endian machines, the default is to pad + upward. For big-endian machines, the default is to pad downward + for an argument of constant size shorter than an `int', and + upward otherwise. + +`FUNCTION_PROLOGUE (FILE, SIZE)' + A C compound statement that outputs the assembler code for entry + to a function. The prologue is responsible for setting up the + stack frame, initializing the frame pointer register, saving + registers that must be saved, and allocating SIZE additional + bytes of storage for the local variables. SIZE is an integer. + FILE is a stdio stream to which the assembler code should be + output. + + The label for the beginning of the function need not be output + by this macro. That has already been done when the macro is run. + + To determine which registers to save, the macro can refer to the + array `regs_ever_live': element R is nonzero if hard register R + is used anywhere within the function. This implies the function + prologue should save register R, but not if it is one of the + call-used registers. + + On machines where functions may or may not have frame-pointers, + the function entry code must vary accordingly; it must set up + the frame pointer if one is wanted, and not otherwise. To + determine whether a frame pointer is in wanted, the macro can + refer to the variable `frame_pointer_needed'. The variable's + value will be 1 at run time in a function that needs a frame + pointer. + +`FUNCTION_PROFILER (FILE, LABELNO)' + A C statement or compound statement to output to FILE some + assembler code to call the profiling subroutine `mcount'. + Before calling, the assembler code must load the address of a + counter variable into a register where `mcount' expects to find + the address. The name of this variable is `LP' followed by the + number LABELNO, so you would generate the name using `LP%d' in a + `fprintf'. + + The details of how the address should be passed to `mcount' are + determined by your operating system environment, not by GNU CC. + To figure them out, compile a small program for profiling using + the system's installed C compiler and look at the assembler code + that results. + +`EXIT_IGNORES_STACK' + Define this macro as a C expression that is nonzero if the + return instruction or the function epilogue ignores the value of + the stack pointer; in other words, if it is safe to delete an + instruction to adjust the stack pointer before a return from the + function. + + Note that this macro's value is relevant only for for which + frame pointers are maintained. It is never possible to delete a + final stack adjustment in a function that has no frame pointer, + and the compiler knows this regardless of `EXIT_IGNORES_STACK'. + +`FUNCTION_EPILOGUE (FILE, SIZE)' + A C compound statement that outputs the assembler code for exit + from a function. The epilogue is responsible for restoring the + saved registers and stack pointer to their values when the + function was called, and returning control to the caller. This + macro takes the same arguments as the macro `FUNCTION_PROLOGUE', + and the registers to restore are determined from + `regs_ever_live' and `CALL_USED_REGISTERS' in the same way. + + On some machines, there is a single instruction that does all + the work of returning from the function. On these machines, + give that instruction the name `return' and do not define the + macro `FUNCTION_EPILOGUE' at all. + + Do not define a pattern named `return' if you want the + `FUNCTION_EPILOGUE' to be used. If you want the target switches + to control whether return instructions or epilogues are used, + define a `return' pattern with a validity condition that tests + the target switches appropriately. If the `return' pattern's + validity condition is false, epilogues will be used. + + On machines where functions may or may not have frame-pointers, + the function exit code must vary accordingly. Sometimes the + code for these two cases is completely different. To determine + whether a frame pointer is in wanted, the macro can refer to the + variable `frame_pointer_needed'. The variable's value will be 1 + at run time in a function that needs a frame pointer. + + On some machines, some functions pop their arguments on exit + while others leave that for the caller to do. For example, the + 68020 when given `-mrtd' pops arguments in functions that take a + fixed number of arguments. + + Your definition of the macro `RETURN_POPS_ARGS' decides which + functions pop their own arguments. `FUNCTION_EPILOGUE' needs to + know what was decided. The variable + `current_function_pops_args' is nonzero if the function should + pop its own arguments. If so, use the variable + `current_function_args_size' as the number of bytes to pop. + +`FIX_FRAME_POINTER_ADDRESS (ADDR, DEPTH)' + A C compound statement to alter a memory address that uses the + frame pointer register so that it uses the stack pointer + register instead. This must be done in the instructions that + load parameter values into registers, when the reload pass + determines that a frame pointer is not necessary for the + function. ADDR will be a C variable name, and the updated + address should be stored in that variable. DEPTH will be the + current depth of stack temporaries (number of bytes of arguments + currently pushed). The change in offset between a + frame-pointer-relative address and a stack-pointer-relative + address must include DEPTH. + + Even if your machine description specifies there will always be + a frame pointer in the frame pointer register, you must still + define `FIX_FRAME_POINTER_ADDRESS', but the definition will + never be executed at run time, so it may be empty. -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 for the initial value of the `mdep' field. It defaults - to 0. - -`NOTICE_UPDATE_CC (EXP)' - A C compound statement to set the components of `cc_status' - appropriately for an 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.  -File: internals, Node: Assembler Format, Prev: Condition Code, Up: Machine Macros +File: internals, Node: Library Names, Next: Addressing Modes, Prev: Stack Layout, Up: Machine Macros -Output of Assembler Code +Library Subroutine Names ======================== -`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. - -`ASM_FILE_START' - A C string constant for text to be output at the start of each - assembler output file. Normally this is `"#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. - -`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. - -`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_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. - -`ASM_OUTPUT_LABEL (FILE, NAME)' - A C statement (sans semicolon) to output to the stdio stream FILE the - assembler definition of a label named NAME. Use the expression - `assemble_name (FILE, 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 (FILE, NAME)' - A C statement (sans semicolon) to output to the stdio stream FILE any - text necessary for declaring the name of a function which is being - defined. This macro is responsible for outputting the label - definition (perhaps using `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 (FILE, NAME)' - A C statement (sans semicolon) to output to the stdio stream FILE some - commands that will make the label NAME global; that is, available for - reference from other files. Use the expression `assemble_name (FILE, - 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 (FILE, NAME)' - A C statement (sans semicolon) to output to the stdio stream FILE any - text necessary for declaring the name of an external symbol which is - referenced in this compilation but not defined. - - 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 (FILE, NAME)' - A C statement to output to the stdio stream FILE 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_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM)' - A C statement to output to the stdio stream FILE 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 (FILE, "L%s%d:\n", PREFIX, NUM) - - -`ASM_OUTPUT_CASE_LABEL (FILE, 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_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_ADDR_DIFF_ELT (FILE, 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 - FILE 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 (FILE, "\t.word L%d-L%d\n", - VALUE, REL) - - -`ASM_OUTPUT_ADDR_VEC_ELT (FILE, 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 - FILE 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 (FILE, "\t.word L%d\n", VALUE) - - -`ASM_OUTPUT_DOUBLE (FILE, VALUE)' - A C statement to output to the stdio stream FILE an assembler - instruction to assemble a `double' constant whose value is VALUE. - VALUE will be a C expression of type `double'. - -`ASM_OUTPUT_FLOAT (FILE, VALUE)' - A C statement to output to the stdio stream FILE an assembler - instruction to assemble a `float' constant whose value is VALUE. - VALUE will be a C expression of type `float'. - -`ASM_OUTPUT_INT (FILE, EXP)' -`ASM_OUTPUT_SHORT (FILE, EXP)' -`ASM_OUTPUT_CHAR (FILE, EXP)' - A C statement to output to the stdio stream FILE 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 (EXP)' to output - this value as an assembler expression. - -`ASM_OUTPUT_BYTE (FILE, VALUE)' - A C statement to output to the stdio stream FILE an assembler - instruction to assemble a single byte containing the number VALUE. - -`ASM_OUTPUT_ASCII (FILE, PTR, LEN)' - A C statement to output to the stdio stream FILE 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 (FILE, NBYTES)' - A C statement to output to the stdio stream FILE an assembler - instruction to advance the location counter by NBYTES bytes. NBYTES - will be a C expression of type `int'. - -`ASM_OUTPUT_ALIGN (FILE, POWER)' - A C statement to output to the stdio stream FILE 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 (FILE, NAME, SIZE)' - A C statement (sans semicolon) to output to the stdio stream FILE the - assembler definition of a common-label named NAME whose size is SIZE - bytes. Use the expression `assemble_name (FILE, 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 (FILE, NAME, SIZE)' - A C statement (sans semicolon) to output to the stdio stream FILE the - assembler definition of a local-common-label named NAME whose size is - SIZE bytes. Use the expression `assemble_name (FILE, 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. - -`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 (FILE, 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 FILE. 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 - FILE, 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 the macro definition does nothing, the instruction is output in the - usual way. - -`PRINT_OPERAND (FILE, X, CODE)' - A C compound statement to output to stdio stream FILE 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_ADDRESS (FILE, X)' - A C compound statement to output to stdio stream FILE 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 ")" +`UDIVSI3_LIBCALL' + A C string constant giving the name of the function to call for + division of a full-word by a full-word. If you do not define + this macro, the default name is used, which is `_udivsi3', a + function defined in `gnulib'. + +`UMODSI3_LIBCALL' + A C string constant giving the name of the function to call for + the remainder in division of a full-word by a full-word. If you + do not define this macro, the default name is used, which is + `_umodsi3', a function defined in `gnulib'. + +`TARGET_MEM_FUNCTIONS' + Define this macro if GNU CC should generate calls to the System + V (and ANSI C) library functions `memcpy' and `memset' rather + than the BSD functions `bcopy' and `bzero'.  -File: internals, Node: Config, Prev: Machine Macros, Up: Top +File: internals, Node: Addressing Modes, Next: Misc, Prev: Library Names, Up: Machine Macros -The Configuration File -********************** +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. + +`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. + +`REG_OK_FOR_BASE_P (X)' + A C expression that is nonzero if X (asumed 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 (asumed 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. -The configuration file `config-MACHINE.h' contains macro definitions that -describe the machine and system on which the compiler is running. Most of -the values in it are actually the same on all machines that GNU CC runs on, -so most all configuration files are identical. But there are some macros -that vary: - -`FAILURE_EXIT_CODE' - A C expression for the status code to be returned when the compiler - exits after serious errors. - -`SUCCESS_EXIT_CODE' - A C expression for the status code to be returned when the compiler - exits without serious errors. -