--- gcc/internals-6 2018/04/24 16:38:23 1.1 +++ gcc/internals-6 2018/04/24 16:39:16 1.1.1.2 @@ -1,31 +1,738 @@ -Info file internals, produced by Makeinfo, -*- Text -*- -from input file internals.texinfo. + +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, 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. + +`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, provided it is not + marked 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. It must in any case be 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. + + 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. + `STRUCT_VALUE_REGNUM' is the register in which this address is passed. -This file documents the internals of the GNU compiler. + +File: internals, Node: Register Classes, Next: Stack Layout, Prev: Registers, Up: Machine Macros -Copyright (C) 1988 Free Software Foundation, Inc. +Register Classes +================ -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. +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. + +`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. + +`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. + +`INDEX_REG_CLASS' + A macro whose definition is the name of the class to which a valid + index register must belong. + +`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 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. CLASS is always safe as a value. In fact, + the definition + + #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS + + is always safe. However, 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. + +`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. -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. + +File: internals, Node: Stack Layout, Next: Library Names, Prev: Register Classes, Up: Machine Macros -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. +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' + Offset from the argument pointer register to the first argument's + address. + +`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 function values are sometimes returned. + + 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) + +`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)' + 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'. + +`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_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. + + 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. + +File: internals, Node: Library Names, Next: Addressing Modes, Prev: Stack Layout, Up: Machine Macros + +Library Subroutine Names +======================== - +`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: Addressing Modes, Next: Misc, Prev: Library Names, Up: Machine Macros + +Addressing Modes +================ + +`HAVE_POST_INCREMENT' + Define this macro if the machine supports post-increment addressing. + +`HAVE_PRE_INCREMENT' +`HAVE_POST_DECREMENT' +`HAVE_PRE_DECREMENT' + Similar for other kinds of addressing. + +`CONSTANT_ADDRESS_P (X)' + A C expression that is 1 if the RTX X is a constant whose value is an + integer. This includes integers whose values are not explicitly + known, such as `symbol_ref' and `label_ref' expressions and `const' + arithmetic expressions. + + On most machines, this can be defined as `CONSTANT_P (X)', but a few + machines are more restrictive in which constant addresses are supported. + +`MAX_REGS_PER_ADDRESS' + A number, the maximum number of registers that can appear in a valid + memory address. + +`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. + +`LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)' + A C compound statement that attempts to replace X with a valid memory + address for an operand of mode MODE. WIN will be a C statement label + elsewhere in the code; the macro definition may use + + GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN); + + to avoid further processing if the address has become legitimate. + + X will always be the result of a call to `break_out_memory_refs', and + OLDX will be the operand that was given to that function to produce X. + + The code generated by this macro should not alter the substructure of + X. If it transforms X into a more legitimate form, it should assign X + (which will always be a C variable) a new value. + + It is not necessary for this macro to come up with a legitimate + address. The compiler has standard ways of doing so in all cases. In + fact, it is safe for this macro to do nothing. But often a + machine-dependent strategy can generate better code. + +`GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)' + A C statement or compound statement with a conditional `goto LABEL;' + executed if memory address X (an RTX) can have different meanings + depending on the machine mode of the memory reference it is used for. + + Autoincrement and autodecrement addresses typically have + mode-dependent effects because the amount of the increment or + decrement is the size of the operand being addressed. Some machines + have other mode-dependent addresses. Many RISC machines have no + mode-dependent addresses. + + You may assume that ADDR is a valid address for the machine. + +`LEGITIMATE_CONSTANT_P (X)' + A C expression that is nonzero if X is a legitimate constant for an + immediate operand on the target machine. You can assume that either X + is a `const_double' or it satisfies `CONSTANT_P', so you need not + check these things. In fact, `1' is a suitable definition for this + macro on machines where any `const_double' is valid and anything + `CONSTANT_P' is valid.  File: internals, Node: Misc, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros @@ -97,7 +804,6 @@ Miscellaneous Parameters (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...) - and likewise for `HImode'. `SHIFT_COUNT_TRUNCATED' @@ -131,7 +837,6 @@ Miscellaneous Parameters #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 @@ -196,349 +901,4 @@ information by defining `CC_STATUS_MDEP' `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 - -Output of Assembler Code -======================== - -`ASM_SPEC' - A C string constant that tells the GNU CC driver program options to - pass to the assembler. It can also specify how to translate options - you give to GNU CC into options for GNU CC to pass to the assembler. - See the file `tm-sun3.h' for an example of this. - - Do not define this macro if it does not need to do anything. - -`LINK_SPEC' - A C string constant that tells the GNU CC driver program options to - pass to the linker. It can also specify how to translate options you - give to GNU CC into options for GNU CC to pass to the linker. - - Do not define this macro if it does not need to do anything. - -`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 ")" - - - -File: internals, Node: Config, Prev: Machine Macros, Up: Top - -The Configuration File -********************** - -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. - - + \ No newline at end of file