X-Git-Url: https://oss.titaniummirror.com/gitweb/?a=blobdiff_plain;f=gcc%2Fdoc%2Fgccint.info-14;fp=gcc%2Fdoc%2Fgccint.info-14;h=0000000000000000000000000000000000000000;hb=6fed43773c9b0ce596dca5686f37ac3fc0fa11c0;hp=b451462356e2babd0039bb770d3f556e7c3a67fe;hpb=27b11d56b743098deb193d510b337ba22dc52e5c;p=msp430-gcc.git diff --git a/gcc/doc/gccint.info-14 b/gcc/doc/gccint.info-14 deleted file mode 100644 index b4514623..00000000 --- a/gcc/doc/gccint.info-14 +++ /dev/null @@ -1,1116 +0,0 @@ -This is doc/gccint.info, produced by makeinfo version 4.5 from -doc/gccint.texi. - -INFO-DIR-SECTION Programming -START-INFO-DIR-ENTRY -* gccint: (gccint). Internals of the GNU Compiler Collection. -END-INFO-DIR-ENTRY - This file documents the internals of the GNU compilers. - - Published by the Free Software Foundation -59 Temple Place - Suite 330 -Boston, MA 02111-1307 USA - - Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, -1999, 2000, 2001, 2002 Free Software Foundation, Inc. - - Permission is granted to copy, distribute and/or modify this document -under the terms of the GNU Free Documentation License, Version 1.1 or -any later version published by the Free Software Foundation; with the -Invariant Sections being "GNU General Public License" and "Funding Free -Software", the Front-Cover texts being (a) (see below), and with the -Back-Cover Texts being (b) (see below). A copy of the license is -included in the section entitled "GNU Free Documentation License". - - (a) The FSF's Front-Cover Text is: - - A GNU Manual - - (b) The FSF's Back-Cover Text is: - - You have freedom to copy and modify this GNU Manual, like GNU -software. Copies published by the Free Software Foundation raise -funds for GNU development. - - -File: gccint.info, Node: Type Layout, Next: Escape Sequences, Prev: Storage Layout, Up: Target Macros - -Layout of Source Language Data Types -==================================== - - These macros define the sizes and other characteristics of the -standard basic data types used in programs being compiled. Unlike the -macros in the previous section, these apply to specific features of C -and related languages, rather than to fundamental aspects of storage -layout. - -`INT_TYPE_SIZE' - A C expression for the size in bits of the type `int' on the - target machine. If you don't define this, the default is one word. - -`SHORT_TYPE_SIZE' - A C expression for the size in bits of the type `short' on the - target machine. If you don't define this, the default is half a - word. (If this would be less than one storage unit, it is rounded - up to one unit.) - -`LONG_TYPE_SIZE' - A C expression for the size in bits of the type `long' on the - target machine. If you don't define this, the default is one word. - -`ADA_LONG_TYPE_SIZE' - On some machines, the size used for the Ada equivalent of the type - `long' by a native Ada compiler differs from that used by C. In - that situation, define this macro to be a C expression to be used - for the size of that type. If you don't define this, the default - is the value of `LONG_TYPE_SIZE'. - -`MAX_LONG_TYPE_SIZE' - Maximum number for the size in bits of the type `long' on the - target machine. If this is undefined, the default is - `LONG_TYPE_SIZE'. Otherwise, it is the constant value that is the - largest value that `LONG_TYPE_SIZE' can have at run-time. This is - used in `cpp'. - -`LONG_LONG_TYPE_SIZE' - A C expression for the size in bits of the type `long long' on the - target machine. If you don't define this, the default is two - words. If you want to support GNU Ada on your machine, the value - of this macro must be at least 64. - -`CHAR_TYPE_SIZE' - A C expression for the size in bits of the type `char' on the - target machine. If you don't define this, the default is - `BITS_PER_UNIT'. - -`MAX_CHAR_TYPE_SIZE' - Maximum number for the size in bits of the type `char' on the - target machine. If this is undefined, the default is - `CHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the - largest value that `CHAR_TYPE_SIZE' can have at run-time. This is - used in `cpp'. - -`BOOL_TYPE_SIZE' - A C expression for the size in bits of the C++ type `bool' and C99 - type `_Bool' on the target machine. If you don't define this, and - you probably shouldn't, the default is `CHAR_TYPE_SIZE'. - -`FLOAT_TYPE_SIZE' - A C expression for the size in bits of the type `float' on the - target machine. If you don't define this, the default is one word. - -`DOUBLE_TYPE_SIZE' - A C expression for the size in bits of the type `double' on the - target machine. If you don't define this, the default is two - words. - -`LONG_DOUBLE_TYPE_SIZE' - A C expression for the size in bits of the type `long double' on - the target machine. If you don't define this, the default is two - words. - - Maximum number for the size in bits of the type `long double' on - the target machine. If this is undefined, the default is - `LONG_DOUBLE_TYPE_SIZE'. Otherwise, it is the constant value that - is the largest value that `LONG_DOUBLE_TYPE_SIZE' can have at - run-time. This is used in `cpp'. - - Define this macro to be 1 if the target machine uses 80-bit - floating-point values with 128-bit size and alignment. This is - used in `real.c'. - -`WIDEST_HARDWARE_FP_SIZE' - A C expression for the size in bits of the widest floating-point - format supported by the hardware. If you define this macro, you - must specify a value less than or equal to the value of - `LONG_DOUBLE_TYPE_SIZE'. If you do not define this macro, the - value of `LONG_DOUBLE_TYPE_SIZE' is the default. - -`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'. - -`DEFAULT_SHORT_ENUMS' - A C expression to determine whether to give an `enum' type only as - many bytes as it takes to represent the range of possible values - of that type. A nonzero value means to do that; a zero value - means all `enum' types should be allocated like `int'. - - If you don't define the macro, the default is 0. - -`SIZE_TYPE' - A C expression for a string describing the name of the data type - to use for size values. The typedef name `size_t' is defined - using the contents of the string. - - The string can contain more than one keyword. If so, separate - them with spaces, and write first any length keyword, then - `unsigned' if appropriate, and finally `int'. The string must - exactly match one of the data type names defined in the function - `init_decl_processing' in the file `c-decl.c'. You may not omit - `int' or change the order--that would cause the compiler to crash - on startup. - - If you don't define this macro, the default is `"long unsigned - int"'. - -`PTRDIFF_TYPE' - A C expression for a string describing the name of the data type - to use for the result of subtracting two pointers. The typedef - name `ptrdiff_t' is defined using the contents of the string. See - `SIZE_TYPE' above for more information. - - If you don't define this macro, the default is `"long int"'. - -`WCHAR_TYPE' - A C expression for a string describing the name of the data type - to use for wide characters. The typedef name `wchar_t' is defined - using the contents of the string. See `SIZE_TYPE' above for more - information. - - If you don't define this macro, the default is `"int"'. - -`WCHAR_TYPE_SIZE' - A C expression for the size in bits of the data type for wide - characters. This is used in `cpp', which cannot make use of - `WCHAR_TYPE'. - -`MAX_WCHAR_TYPE_SIZE' - Maximum number for the size in bits of the data type for wide - characters. If this is undefined, the default is - `WCHAR_TYPE_SIZE'. Otherwise, it is the constant value that is the - largest value that `WCHAR_TYPE_SIZE' can have at run-time. This is - used in `cpp'. - -`GCOV_TYPE_SIZE' - A C expression for the size in bits of the type used for gcov - counters on the target machine. If you don't define this, the - default is one `LONG_TYPE_SIZE' in case it is greater or equal to - 64-bit and `LONG_LONG_TYPE_SIZE' otherwise. You may want to - re-define the type to ensure atomicity for counters in - multithreaded programs. - -`WINT_TYPE' - A C expression for a string describing the name of the data type to - use for wide characters passed to `printf' and returned from - `getwc'. The typedef name `wint_t' is defined using the contents - of the string. See `SIZE_TYPE' above for more information. - - If you don't define this macro, the default is `"unsigned int"'. - -`INTMAX_TYPE' - A C expression for a string describing the name of the data type - that can represent any value of any standard or extended signed - integer type. The typedef name `intmax_t' is defined using the - contents of the string. See `SIZE_TYPE' above for more - information. - - If you don't define this macro, the default is the first of - `"int"', `"long int"', or `"long long int"' that has as much - precision as `long long int'. - -`UINTMAX_TYPE' - A C expression for a string describing the name of the data type - that can represent any value of any standard or extended unsigned - integer type. The typedef name `uintmax_t' is defined using the - contents of the string. See `SIZE_TYPE' above for more - information. - - If you don't define this macro, the default is the first of - `"unsigned int"', `"long unsigned int"', or `"long long unsigned - int"' that has as much precision as `long long unsigned int'. - -`TARGET_PTRMEMFUNC_VBIT_LOCATION' - The C++ compiler represents a pointer-to-member-function with a - struct that looks like: - - struct { - union { - void (*fn)(); - ptrdiff_t vtable_index; - }; - ptrdiff_t delta; - }; - - The C++ compiler must use one bit to indicate whether the function - that will be called through a pointer-to-member-function is - virtual. Normally, we assume that the low-order bit of a function - pointer must always be zero. Then, by ensuring that the - vtable_index is odd, we can distinguish which variant of the union - is in use. But, on some platforms function pointers can be odd, - and so this doesn't work. In that case, we use the low-order bit - of the `delta' field, and shift the remainder of the `delta' field - to the left. - - GCC will automatically make the right selection about where to - store this bit using the `FUNCTION_BOUNDARY' setting for your - platform. However, some platforms such as ARM/Thumb have - `FUNCTION_BOUNDARY' set such that functions always start at even - addresses, but the lowest bit of pointers to functions indicate - whether the function at that address is in ARM or Thumb mode. If - this is the case of your architecture, you should define this - macro to `ptrmemfunc_vbit_in_delta'. - - In general, you should not have to define this macro. On - architectures in which function addresses are always even, - according to `FUNCTION_BOUNDARY', GCC will automatically define - this macro to `ptrmemfunc_vbit_in_pfn'. - -`TARGET_VTABLE_USES_DESCRIPTORS' - Normally, the C++ compiler uses function pointers in vtables. This - macro allows the target to change to use "function descriptors" - instead. Function descriptors are found on targets for whom a - function pointer is actually a small data structure. Normally the - data structure consists of the actual code address plus a data - pointer to which the function's data is relative. - - If vtables are used, the value of this macro should be the number - of words that the function descriptor occupies. - - -File: gccint.info, Node: Escape Sequences, Next: Registers, Prev: Type Layout, Up: Target Macros - -Target Character Escape Sequences -================================= - - By default, GCC assumes that the C character escape sequences take on -their ASCII values for the target. If this is not correct, you must -explicitly define all of the macros below. - -`TARGET_BELL' - A C constant expression for the integer value for escape sequence - `\a'. - -`TARGET_ESC' - A C constant expression for the integer value of the target escape - character. As an extension, GCC evaluates the escape sequences - `\e' and `\E' to this. - -`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'. - - -File: gccint.info, Node: Registers, Next: Register Classes, Prev: Escape Sequences, Up: Target Macros - -Register Usage -============== - - This section explains how to describe what registers the target -machine has, and how (in general) they can be used. - - The description of which registers a specific instruction can use is -done with register classes; see *Note Register Classes::. For -information on using registers to access a stack frame, see *Note Frame -Registers::. For passing values in registers, see *Note Register -Arguments::. For returning values in registers, see *Note Scalar -Return::. - -* Menu: - -* Register Basics:: Number and kinds of registers. -* Allocation Order:: Order in which registers are allocated. -* Values in Registers:: What kinds of values each reg can hold. -* Leaf Functions:: Renumbering registers for leaf functions. -* Stack Registers:: Handling a register stack such as 80387. - - -File: gccint.info, Node: Register Basics, Next: Allocation Order, Up: Registers - -Basic Characteristics of Registers ----------------------------------- - - Registers have various characteristics. - -`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. - -`CALL_REALLY_USED_REGISTERS' - Like `CALL_USED_REGISTERS' except this macro doesn't require that - the entire set of `FIXED_REGISTERS' be included. - (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS'). - This macro is optional. If not specified, it defaults to the value - of `CALL_USED_REGISTERS'. - -`HARD_REGNO_CALL_PART_CLOBBERED (REGNO, MODE)' - A C expression that is nonzero if it is not permissible to store a - value of mode MODE in hard register number REGNO across a call - without some part of it being clobbered. For most machines this - macro need not be defined. It is only required for machines that - do not preserve the entire contents of a register across a call. - -`CONDITIONAL_REGISTER_USAGE' - Zero or more C statements that may conditionally modify five - variables `fixed_regs', `call_used_regs', `global_regs', - `reg_names', and `reg_class_contents', to take into account any - dependence of these register sets on target flags. The first three - of these are of type `char []' (interpreted as Boolean vectors). - `global_regs' is a `const char *[]', and `reg_class_contents' is a - `HARD_REG_SET'. Before the macro is called, `fixed_regs', - `call_used_regs', `reg_class_contents', and `reg_names' have been - initialized from `FIXED_REGISTERS', `CALL_USED_REGISTERS', - `REG_CLASS_CONTENTS', and `REGISTER_NAMES', respectively. - `global_regs' has been cleared, and any `-ffixed-REG', - `-fcall-used-REG' and `-fcall-saved-REG' command options have been - applied. - - 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.) - -`NON_SAVING_SETJMP' - If this macro is defined and has a nonzero value, it means that - `setjmp' and related functions fail to save the registers, or that - `longjmp' fails to restore them. To compensate, the compiler - avoids putting variables in registers in functions that use - `setjmp'. - -`INCOMING_REGNO (OUT)' - Define this macro if the target machine has register windows. - This C expression returns the register number as seen by the - called function corresponding to the register number OUT as seen - by the calling function. Return OUT if register number OUT is not - an outbound register. - -`OUTGOING_REGNO (IN)' - Define this macro if the target machine has register windows. - This C expression returns the register number as seen by the - calling function corresponding to the register number IN as seen - by the called function. Return IN if register number IN is not an - inbound register. - -`LOCAL_REGNO (REGNO)' - Define this macro if the target machine has register windows. - This C expression returns true if the register is call-saved but - is in the register window. Unlike most call-saved registers, such - registers need not be explicitly restored on function exit or - during non-local gotos. - - - -File: gccint.info, Node: Allocation Order, Next: Values in Registers, Prev: Register Basics, Up: Registers - -Order of Allocation of Registers --------------------------------- - - Registers are allocated in order. - -`REG_ALLOC_ORDER' - If defined, an initializer for a vector of integers, containing the - numbers of hard registers in the order in which GCC 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 machines where the highest numbered - registers must always be saved and the save-multiple-registers - instruction supports only sequences of consecutive registers. On - such machines, define `REG_ALLOC_ORDER' to be an initializer that - lists the highest numbered allocable register first. - -`ORDER_REGS_FOR_LOCAL_ALLOC' - A C statement (sans semicolon) to choose the order in which to - allocate hard registers for pseudo-registers local to a basic - block. - - Store the desired register order in the array `reg_alloc_order'. - Element 0 should be the register to allocate first; element 1, the - next register; and so on. - - The macro body should not assume anything about the contents of - `reg_alloc_order' before execution of the macro. - - On most machines, it is not necessary to define this macro. - - -File: gccint.info, Node: Values in Registers, Next: Leaf Functions, Prev: Allocation Order, Up: Registers - -How Values Fit in Registers ---------------------------- - - This section discusses the macros that describe which kinds of values -(specifically, which machine modes) each register can hold, and how many -consecutive registers are needed for a given mode. - -`HARD_REGNO_NREGS (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 - - You need not include code to check for the numbers of fixed - registers, because the allocation mechanism considers them to be - always occupied. - - On some machines, double-precision values must be kept in even/odd - register pairs. You can implement that by defining this macro to - reject odd register numbers for such modes. - - The minimum requirement for a mode to be OK in a register is that - the `movMODE' instruction pattern support moves between the - register and other hard register in the same class and that moving - a value into the register and back out not alter it. - - Since the same instruction used to move `word_mode' will work for - all narrower integer modes, it is not necessary on any machine for - `HARD_REGNO_MODE_OK' to distinguish between these modes, provided - you define patterns `movhi', etc., to take advantage of this. This - is useful because of the interaction between `HARD_REGNO_MODE_OK' - and `MODES_TIEABLE_P'; it is very desirable for all integer modes - to be tieable. - - 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. Integer move instructions can be used - to move the values. - - On some machines, though, the converse is true: fixed-point machine - modes may not go in floating registers. This is true if the - floating registers normalize any value stored in them, because - storing a non-floating value there would garble it. In this case, - `HARD_REGNO_MODE_OK' should reject fixed-point machine modes in - floating registers. But 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, so you can define this macro to say - so. - - The primary significance of special floating registers is rather - that they are the registers acceptable in floating point arithmetic - instructions. However, this is of no concern to - `HARD_REGNO_MODE_OK'. You handle it by writing the proper - constraints for those instructions. - - On some machines, the floating registers 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 pattern's - constraint asks for one. - -`MODES_TIEABLE_P (MODE1, MODE2)' - A C expression that is nonzero if a value of mode MODE1 is - accessible in mode MODE2 without copying. - - If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, - MODE2)' are always the same for any R, then `MODES_TIEABLE_P - (MODE1, MODE2)' should be nonzero. If they differ for any R, you - should define this macro to return zero unless some other - mechanism ensures the accessibility of the value in a narrower - mode. - - You should define this macro to return nonzero in as many cases as - possible since doing so will allow GCC to perform better register - allocation. - -`AVOID_CCMODE_COPIES' - Define this macro if the compiler should avoid copies to/from - `CCmode' registers. You should only define this macro if support - for copying to/from `CCmode' is incomplete. - - -File: gccint.info, Node: Leaf Functions, Next: Stack Registers, Prev: Values in Registers, Up: Registers - -Handling Leaf Functions ------------------------ - - On some machines, a leaf function (i.e., one which makes no calls) -can run more efficiently if it does not make its own register window. -Often this means it is required to receive its arguments in the -registers where they are passed by the caller, instead of the registers -where they would normally arrive. - - The special treatment for leaf functions generally applies only when -other conditions are met; for example, often they may use only those -registers for its own variables and temporaries. We use the term "leaf -function" to mean a function that is suitable for this special -handling, so that functions with no calls are not necessarily "leaf -functions". - - GCC assigns register numbers before it knows whether the function is -suitable for leaf function treatment. So it needs to renumber the -registers in order to output a leaf function. The following macros -accomplish this. - -`LEAF_REGISTERS' - Name of a char vector, indexed by hard register number, which - contains 1 for a register that is allowable in a candidate for leaf - function treatment. - - If leaf function treatment involves renumbering the registers, - then the registers marked here should be the ones before - renumbering--those that GCC would ordinarily allocate. The - registers which will actually be used in the assembler code, after - renumbering, should not be marked with 1 in this vector. - - Define this macro only if the target machine offers a way to - optimize the treatment of leaf functions. - -`LEAF_REG_REMAP (REGNO)' - A C expression whose value is the register number to which REGNO - should be renumbered, when a function is treated as a leaf - function. - - If REGNO is a register number which should not appear in a leaf - function before renumbering, then the expression should yield -1, - which will cause the compiler to abort. - - Define this macro only if the target machine offers a way to - optimize the treatment of leaf functions, and registers need to be - renumbered to do this. - - `TARGET_ASM_FUNCTION_PROLOGUE' and `TARGET_ASM_FUNCTION_EPILOGUE' -must usually treat leaf functions specially. They can test the C -variable `current_function_is_leaf' which is nonzero for leaf -functions. `current_function_is_leaf' is set prior to local register -allocation and is valid for the remaining compiler passes. They can -also test the C variable `current_function_uses_only_leaf_regs' which -is nonzero for leaf functions which only use leaf registers. -`current_function_uses_only_leaf_regs' is valid after reload and is -only useful if `LEAF_REGISTERS' is defined. - - -File: gccint.info, Node: Stack Registers, Prev: Leaf Functions, Up: Registers - -Registers That Form a Stack ---------------------------- - - There are special features to handle computers where some of the -"registers" form a stack, as in the 80387 coprocessor for the 80386. -Stack registers are normally written by pushing onto the stack, and are -numbered relative to the top of the stack. - - Currently, GCC can only handle one group of stack-like registers, and -they must be consecutively numbered. - -`STACK_REGS' - Define this if the machine has any stack-like registers. - -`FIRST_STACK_REG' - The number of the first stack-like register. This one is the top - of the stack. - -`LAST_STACK_REG' - The number of the last stack-like register. This one is the - bottom of the stack. - - -File: gccint.info, Node: Register Classes, Next: Stack and Calling, Prev: Registers, Up: Target Macros - -Register Classes -================ - - 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'. - - Order the classes so that if class X is contained in class Y then X -has a lower class number than Y. - - 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. - - When a value occupying several consecutive registers is expected in a -certain class, all the registers used must belong to that class. -Therefore, register classes cannot be used to enforce a requirement for -a register pair to start with an even-numbered register. The way to -specify this requirement is with `HARD_REGNO_MODE_OK'. - - 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'. In this - situation, the first integer in each sub-initializer corresponds to - registers 0 through 31, the second integer to registers 32 through - 63, and so on. - -`REGNO_REG_CLASS (REGNO)' - A C expression whose value is a register class containing hard - register REGNO. In general there is more than 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. - -`MODE_BASE_REG_CLASS (MODE)' - This is a variation of the `BASE_REG_CLASS' macro which allows the - selection of a base register in a mode depenedent manner. If MODE - is VOIDmode then it should return the same value as - `BASE_REG_CLASS'. - -`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'. The register - letter `r', corresponding to class `GENERAL_REGS', will not be - passed to this macro; you do not need to handle it. - -`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_MODE_OK_FOR_BASE_P (NUM, MODE)' - A C expression that is just like `REGNO_OK_FOR_BASE_P', except that - that expression may examine the mode of the memory reference in - MODE. You should define this macro if the mode of the memory - reference affects whether a register may be used as a base - register. If you define this macro, the compiler will use it - instead of `REGNO_OK_FOR_BASE_P'. - -`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 following - definition is safe: - - #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS - - 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. - -`PREFERRED_OUTPUT_RELOAD_CLASS (X, CLASS)' - Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of - input reloads. If you don't define this macro, the default is to - use CLASS, unchanged. - -`LIMIT_RELOAD_CLASS (MODE, CLASS)' - A C expression that places additional restrictions on the register - class to use when it is necessary to be able to hold a value of - mode MODE in a reload register for which class CLASS would - ordinarily be used. - - Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when - there are certain modes that simply can't go in certain reload - classes. - - The value is a register class; perhaps CLASS, or perhaps another, - smaller class. - - Don't define this macro unless the target machine has limitations - which require the macro to do something nontrivial. - -`SECONDARY_RELOAD_CLASS (CLASS, MODE, X)' -`SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)' -`SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)' - Many machines have some registers that cannot be copied directly - to or from memory or even from other types of registers. An - example is the `MQ' register, which on most machines, can only be - copied to or from general registers, but not memory. Some - machines allow copying all registers to and from memory, but - require a scratch register for stores to some memory locations - (e.g., those with symbolic address on the RT, and those with - certain symbolic address on the Sparc when compiling PIC). In - some cases, both an intermediate and a scratch register are - required. - - You should define these macros to indicate to the reload phase - that it may need to allocate at least one register for a reload in - addition to the register to contain the data. Specifically, if - copying X to a register CLASS in MODE requires an intermediate - register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to - return the largest register class all of whose registers can be - used as intermediate registers or scratch registers. - - If copying a register CLASS in MODE to X requires an intermediate - or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be - defined to return the largest register class required. If the - requirements for input and output reloads are the same, the macro - `SECONDARY_RELOAD_CLASS' should be used instead of defining both - macros identically. - - The values returned by these macros are often `GENERAL_REGS'. - Return `NO_REGS' if no spare register is needed; i.e., if X can be - directly copied to or from a register of CLASS in MODE without - requiring a scratch register. Do not define this macro if it - would always return `NO_REGS'. - - If a scratch register is required (either with or without an - intermediate register), you should define patterns for - `reload_inM' or `reload_outM', as required (*note Standard - Names::. These patterns, which will normally be implemented with - a `define_expand', should be similar to the `movM' patterns, - except that operand 2 is the scratch register. - - Define constraints for the reload register and scratch register - that contain a single register class. If the original reload - register (whose class is CLASS) can meet the constraint given in - the pattern, the value returned by these macros is used for the - class of the scratch register. Otherwise, two additional reload - registers are required. Their classes are obtained from the - constraints in the insn pattern. - - X might be a pseudo-register or a `subreg' of a pseudo-register, - which could either be in a hard register or in memory. Use - `true_regnum' to find out; it will return -1 if the pseudo is in - memory and the hard register number if it is in a register. - - These macros should not be used in the case where a particular - class of registers can only be copied to memory and not to another - class of registers. In that case, secondary reload registers are - not needed and would not be helpful. Instead, a stack location - must be used to perform the copy and the `movM' pattern should use - memory as an intermediate storage. This case often occurs between - floating-point and general registers. - -`SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)' - Certain machines have the property that some registers cannot be - copied to some other registers without using memory. Define this - macro on those machines to be a C expression that is nonzero if - objects of mode M in registers of CLASS1 can only be copied to - registers of class CLASS2 by storing a register of CLASS1 into - memory and loading that memory location into a register of CLASS2. - - Do not define this macro if its value would always be zero. - -`SECONDARY_MEMORY_NEEDED_RTX (MODE)' - Normally when `SECONDARY_MEMORY_NEEDED' is defined, the compiler - allocates a stack slot for a memory location needed for register - copies. If this macro is defined, the compiler instead uses the - memory location defined by this macro. - - Do not define this macro if you do not define - `SECONDARY_MEMORY_NEEDED'. - -`SECONDARY_MEMORY_NEEDED_MODE (MODE)' - When the compiler needs a secondary memory location to copy - between two registers of mode MODE, it normally allocates - sufficient memory to hold a quantity of `BITS_PER_WORD' bits and - performs the store and load operations in a mode that many bits - wide and whose class is the same as that of MODE. - - This is right thing to do on most machines because it ensures that - all bits of the register are copied and prevents accesses to the - registers in a narrower mode, which some machines prohibit for - floating-point registers. - - However, this default behavior is not correct on some machines, - such as the DEC Alpha, that store short integers in floating-point - registers differently than in integer registers. On those - machines, the default widening will not work correctly and you - must define this macro to suppress that widening in some cases. - See the file `alpha.h' for details. - - Do not define this macro if you do not define - `SECONDARY_MEMORY_NEEDED' or if widening MODE to a mode that is - `BITS_PER_WORD' bits wide is correct for your machine. - -`SMALL_REGISTER_CLASSES' - On some machines, it is risky to let hard registers live across - arbitrary insns. Typically, these machines have instructions that - require values to be in specific registers (like an accumulator), - and reload will fail if the required hard register is used for - another purpose across such an insn. - - Define `SMALL_REGISTER_CLASSES' to be an expression with a nonzero - value on these machines. When this macro has a nonzero value, the - compiler will try to minimize the lifetime of hard registers. - - It is always safe to define this macro with a nonzero value, but - if you unnecessarily define it, you will reduce the amount of - optimizations that can be performed in some cases. If you do not - define this macro with a nonzero value when it is required, the - compiler will run out of spill registers and print a fatal error - message. For most machines, you should not define this macro at - all. - -`CLASS_LIKELY_SPILLED_P (CLASS)' - A C expression whose value is nonzero if pseudos that have been - assigned to registers of class CLASS would likely be spilled - because registers of CLASS are needed for spill registers. - - The default value of this macro returns 1 if CLASS has exactly one - register and zero otherwise. On most machines, this default - should be used. Only define this macro to some other expression - if pseudos allocated by `local-alloc.c' end up in memory because - their hard registers were needed for spill registers. If this - macro returns nonzero for those classes, those pseudos will only - be allocated by `global.c', which knows how to reallocate the - pseudo to another register. If there would not be another - register available for reallocation, you should not change the - definition of this macro since the only effect of such a - definition would be to slow down register allocation. - -`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. - -`CLASS_CANNOT_CHANGE_MODE' - If defined, a C expression for a class that contains registers for - which the compiler may not change modes arbitrarily. - -`CLASS_CANNOT_CHANGE_MODE_P(FROM, TO)' - A C expression that is true if, for a register in - `CLASS_CANNOT_CHANGE_MODE', the requested mode punning is invalid. - - For the example, loading 32-bit integer or floating-point objects - into floating-point registers on the Alpha extends them to 64 bits. - Therefore loading a 64-bit object and then storing it as a 32-bit - object does not store the low-order 32 bits, as would be the case - for a normal register. Therefore, `alpha.h' defines - `CLASS_CANNOT_CHANGE_MODE' as `FLOAT_REGS' and - `CLASS_CANNOT_CHANGE_MODE_P' restricts mode changes to same-size - modes. - - Compare this to IA-64, which extends floating-point values to 82 - bits, and stores 64-bit integers in a different format than 64-bit - doubles. Therefore `CLASS_CANNOT_CHANGE_MODE_P' is always true. - - Three other special macros describe which operands fit which -constraint letters. - -`CONST_OK_FOR_LETTER_P (VALUE, C)' - A C expression that defines the machine-dependent operand - constraint letters (`I', `J', `K', ... `P') 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 - `const_double' values (`G' or `H'). - - 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. - - `const_double' is used for all floating-point constants and for - `DImode' fixed-point constants. A given letter can accept either - or both kinds of values. It can use `GET_MODE' to distinguish - between these kinds. - -`EXTRA_CONSTRAINT (VALUE, C)' - A C expression that defines the optional machine-dependent - constraint letters that can be used to segregate specific types of - operands, usually memory references, for the target machine. Any - letter that is not elsewhere defined and not matched by - `REG_CLASS_FROM_LETTER' may be used. Normally this macro will not - be defined. - - If it is required for a particular target machine, it should - return 1 if VALUE corresponds to the operand type represented by - the constraint letter C. If C is not defined as an extra - constraint, the value returned should be 0 regardless of VALUE. - - For example, on the ROMP, load instructions cannot have their - output in r0 if the memory reference contains a symbolic address. - Constraint letter `Q' is defined as representing a memory address - that does _not_ contain a symbolic address. An alternative is - specified with a `Q' constraint on the input and `r' on the - output. The next alternative specifies `m' on the input and a - register class that does not include r0 on the output. - - -File: gccint.info, Node: Stack and Calling, Next: Varargs, Prev: Register Classes, Up: Target Macros - -Stack Layout and Calling Conventions -==================================== - - This describes the stack layout and calling conventions. - -* Menu: - -* Frame Layout:: -* Exception Handling:: -* Stack Checking:: -* Frame Registers:: -* Elimination:: -* Stack Arguments:: -* Register Arguments:: -* Scalar Return:: -* Aggregate Return:: -* Caller Saves:: -* Function Entry:: -* Profiling:: -* Tail Calls:: -