![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-19 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to gcc.info-19 CVS log | Up to [GCC 2.x] / gcc |
1.1.1.4 ! root 1: This is Info file gcc.info, produced by Makeinfo-1.55 from the input 1.1 root 2: file gcc.texi. 3: 4: This file documents the use and the internals of the GNU compiler. 5: 1.1.1.2 root 6: Published by the Free Software Foundation 675 Massachusetts Avenue 7: Cambridge, MA 02139 USA 8: 1.1.1.4 ! root 9: Copyright (C) 1988, 1989, 1992, 1993, 1994 Free Software Foundation, ! 10: Inc. 1.1 root 11: 12: Permission is granted to make and distribute verbatim copies of this 13: manual provided the copyright notice and this permission notice are 14: preserved on all copies. 15: 16: Permission is granted to copy and distribute modified versions of 17: this manual under the conditions for verbatim copying, provided also 1.1.1.4 ! root 18: that the sections entitled "GNU General Public License," "Funding for ! 19: Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are ! 20: included exactly as in the original, and provided that the entire ! 21: resulting derived work is distributed under the terms of a permission ! 22: notice identical to this one. 1.1 root 23: 24: Permission is granted to copy and distribute translations of this 25: manual into another language, under the above conditions for modified 26: versions, except that the sections entitled "GNU General Public 1.1.1.4 ! root 27: License," "Funding for Free Software," and "Protect Your Freedom--Fight ! 28: `Look And Feel'", and this permission notice, may be included in ! 29: translations approved by the Free Software Foundation instead of in the ! 30: original English. 1.1 root 31: 32: 1.1.1.4 ! root 33: File: gcc.info, Node: Obsolete Register Macros, Prev: Stack Registers, Up: Registers 1.1.1.2 root 34: 1.1.1.4 ! root 35: Obsolete Macros for Controlling Register Usage ! 36: ---------------------------------------------- 1.1.1.2 root 37: 1.1.1.4 ! root 38: These features do not work very well. They exist because they used ! 39: to be required to generate correct code for the 80387 coprocessor of the ! 40: 80386. They are no longer used by that machine description and may be ! 41: removed in a later version of the compiler. Don't use them! ! 42: ! 43: `OVERLAPPING_REGNO_P (REGNO)' ! 44: If defined, this is a C expression whose value is nonzero if hard ! 45: register number REGNO is an overlapping register. This means a ! 46: hard register which overlaps a hard register with a different ! 47: number. (Such overlap is undesirable, but occasionally it allows ! 48: a machine to be supported which otherwise could not be.) This ! 49: macro must return nonzero for *all* the registers which overlap ! 50: each other. GNU CC can use an overlapping register only in ! 51: certain limited ways. It can be used for allocation within a ! 52: basic block, and may be spilled for reloading; that is all. ! 53: ! 54: If this macro is not defined, it means that none of the hard ! 55: registers overlap each other. This is the usual situation. ! 56: ! 57: `INSN_CLOBBERS_REGNO_P (INSN, REGNO)' ! 58: If defined, this is a C expression whose value should be nonzero if ! 59: the insn INSN has the effect of mysteriously clobbering the ! 60: contents of hard register number REGNO. By "mysterious" we mean ! 61: that the insn's RTL expression doesn't describe such an effect. ! 62: ! 63: If this macro is not defined, it means that no insn clobbers ! 64: registers mysteriously. This is the usual situation; all else ! 65: being equal, it is best for the RTL expression to show all the ! 66: activity. ! 67: ! 68: `PRESERVE_DEATH_INFO_REGNO_P (REGNO)' ! 69: If defined, this is a C expression whose value is nonzero if ! 70: accurate `REG_DEAD' notes are needed for hard register number REGNO ! 71: at the time of outputting the assembler code. When this is so, a ! 72: few optimizations that take place after register allocation and ! 73: could invalidate the death notes are not done when this register is ! 74: involved. ! 75: ! 76: You would arrange to preserve death info for a register when some ! 77: of the code in the machine description which is executed to write ! 78: the assembler code looks at the death notes. This is necessary ! 79: only when the actual hardware feature which GNU CC thinks of as a ! 80: register is not actually a register of the usual sort. (It might, ! 81: for example, be a hardware stack.) 1.1.1.3 root 82: 1.1.1.4 ! root 83: If this macro is not defined, it means that no death notes need to ! 84: be preserved. This is the usual situation. 1.1.1.2 root 85: 86: 1.1.1.4 ! root 87: File: gcc.info, Node: Register Classes, Next: Stack and Calling, Prev: Registers, Up: Target Macros 1.1.1.2 root 88: 1.1.1.4 ! root 89: Register Classes ! 90: ================ 1.1.1.2 root 91: 1.1.1.4 ! root 92: On many machines, the numbered registers are not all equivalent. ! 93: For example, certain registers may not be allowed for indexed ! 94: addressing; certain registers may not be allowed in some instructions. ! 95: These machine restrictions are described to the compiler using ! 96: "register classes". ! 97: ! 98: You define a number of register classes, giving each one a name and ! 99: saying which of the registers belong to it. Then you can specify ! 100: register classes that are allowed as operands to particular instruction ! 101: patterns. ! 102: ! 103: In general, each register will belong to several classes. In fact, ! 104: one class must be named `ALL_REGS' and contain all the registers. ! 105: Another class must be named `NO_REGS' and contain no registers. Often ! 106: the union of two classes will be another class; however, this is not ! 107: required. ! 108: ! 109: One of the classes must be named `GENERAL_REGS'. There is nothing ! 110: terribly special about the name, but the operand constraint letters `r' ! 111: and `g' specify this class. If `GENERAL_REGS' is the same as ! 112: `ALL_REGS', just define it as a macro which expands to `ALL_REGS'. ! 113: ! 114: Order the classes so that if class X is contained in class Y then X ! 115: has a lower class number than Y. ! 116: ! 117: The way classes other than `GENERAL_REGS' are specified in operand ! 118: constraints is through machine-dependent operand constraint letters. ! 119: You can define such letters to correspond to various classes, then use ! 120: them in operand constraints. ! 121: ! 122: You should define a class for the union of two classes whenever some ! 123: instruction allows both classes. For example, if an instruction allows ! 124: either a floating point (coprocessor) register or a general register ! 125: for a certain operand, you should define a class `FLOAT_OR_GENERAL_REGS' ! 126: which includes both of them. Otherwise you will get suboptimal code. ! 127: ! 128: You must also specify certain redundant information about the ! 129: register classes: for each class, which classes contain it and which ! 130: ones are contained in it; for each pair of classes, the largest class ! 131: contained in their union. ! 132: ! 133: When a value occupying several consecutive registers is expected in a ! 134: certain class, all the registers used must belong to that class. ! 135: Therefore, register classes cannot be used to enforce a requirement for ! 136: a register pair to start with an even-numbered register. The way to ! 137: specify this requirement is with `HARD_REGNO_MODE_OK'. ! 138: ! 139: Register classes used for input-operands of bitwise-and or shift ! 140: instructions have a special requirement: each such class must have, for ! 141: each fixed-point machine mode, a subclass whose registers can transfer ! 142: that mode to or from memory. For example, on some machines, the ! 143: operations for single-byte values (`QImode') are limited to certain ! 144: registers. When this is so, each register class that is used in a ! 145: bitwise-and or shift instruction must have a subclass consisting of ! 146: registers from which single-byte values can be loaded or stored. This ! 147: is so that `PREFERRED_RELOAD_CLASS' can always have a possible value to ! 148: return. ! 149: ! 150: `enum reg_class' ! 151: An enumeral type that must be defined with all the register class ! 152: names as enumeral values. `NO_REGS' must be first. `ALL_REGS' ! 153: must be the last register class, followed by one more enumeral ! 154: value, `LIM_REG_CLASSES', which is not a register class but rather ! 155: tells how many classes there are. ! 156: ! 157: Each register class has a number, which is the value of casting ! 158: the class name to type `int'. The number serves as an index in ! 159: many of the tables described below. ! 160: ! 161: `N_REG_CLASSES' ! 162: The number of distinct register classes, defined as follows: ! 163: ! 164: #define N_REG_CLASSES (int) LIM_REG_CLASSES ! 165: ! 166: `REG_CLASS_NAMES' ! 167: An initializer containing the names of the register classes as C ! 168: string constants. These names are used in writing some of the ! 169: debugging dumps. ! 170: ! 171: `REG_CLASS_CONTENTS' ! 172: An initializer containing the contents of the register classes, as ! 173: integers which are bit masks. The Nth integer specifies the ! 174: contents of class N. The way the integer MASK is interpreted is ! 175: that register R is in the class if `MASK & (1 << R)' is 1. ! 176: ! 177: When the machine has more than 32 registers, an integer does not ! 178: suffice. Then the integers are replaced by sub-initializers, ! 179: braced groupings containing several integers. Each ! 180: sub-initializer must be suitable as an initializer for the type ! 181: `HARD_REG_SET' which is defined in `hard-reg-set.h'. ! 182: ! 183: `REGNO_REG_CLASS (REGNO)' ! 184: A C expression whose value is a register class containing hard ! 185: register REGNO. In general there is more than one such class; ! 186: choose a class which is "minimal", meaning that no smaller class ! 187: also contains the register. ! 188: ! 189: `BASE_REG_CLASS' ! 190: A macro whose definition is the name of the class to which a valid ! 191: base register must belong. A base register is one used in an ! 192: address which is the register value plus a displacement. ! 193: ! 194: `INDEX_REG_CLASS' ! 195: A macro whose definition is the name of the class to which a valid ! 196: index register must belong. An index register is one used in an ! 197: address where its value is either multiplied by a scale factor or ! 198: added to another register (as well as added to a displacement). ! 199: ! 200: `REG_CLASS_FROM_LETTER (CHAR)' ! 201: A C expression which defines the machine-dependent operand ! 202: constraint letters for register classes. If CHAR is such a ! 203: letter, the value should be the register class corresponding to ! 204: it. Otherwise, the value should be `NO_REGS'. The register ! 205: letter `r', corresponding to class `GENERAL_REGS', will not be ! 206: passed to this macro; you do not need to handle it. ! 207: ! 208: `REGNO_OK_FOR_BASE_P (NUM)' ! 209: A C expression which is nonzero if register number NUM is suitable ! 210: for use as a base register in operand addresses. It may be either ! 211: a suitable hard register or a pseudo register that has been ! 212: allocated such a hard register. ! 213: ! 214: `REGNO_OK_FOR_INDEX_P (NUM)' ! 215: A C expression which is nonzero if register number NUM is suitable ! 216: for use as an index register in operand addresses. It may be ! 217: either a suitable hard register or a pseudo register that has been ! 218: allocated such a hard register. 1.1.1.2 root 219: 1.1.1.4 ! root 220: The difference between an index register and a base register is ! 221: that the index register may be scaled. If an address involves the ! 222: sum of two registers, neither one of them scaled, then either one ! 223: may be labeled the "base" and the other the "index"; but whichever ! 224: labeling is used must fit the machine's constraints of which ! 225: registers may serve in each capacity. The compiler will try both ! 226: labelings, looking for one that is valid, and will reload one or ! 227: both registers only if neither labeling works. 1.1.1.2 root 228: 1.1.1.4 ! root 229: `PREFERRED_RELOAD_CLASS (X, CLASS)' ! 230: A C expression that places additional restrictions on the register ! 231: class to use when it is necessary to copy value X into a register ! 232: in class CLASS. The value is a register class; perhaps CLASS, or ! 233: perhaps another, smaller class. On many machines, the following ! 234: definition is safe: ! 235: ! 236: #define PREFERRED_RELOAD_CLASS(X,CLASS) CLASS ! 237: ! 238: Sometimes returning a more restrictive class makes better code. ! 239: For example, on the 68000, when X is an integer constant that is ! 240: in range for a `moveq' instruction, the value of this macro is ! 241: always `DATA_REGS' as long as CLASS includes the data registers. ! 242: Requiring a data register guarantees that a `moveq' will be used. ! 243: ! 244: If X is a `const_double', by returning `NO_REGS' you can force X ! 245: into a memory constant. This is useful on certain machines where ! 246: immediate floating values cannot be loaded into certain kinds of ! 247: registers. 1.1.1.2 root 248: 1.1.1.4 ! root 249: `PREFERRED_OUTPUT_RELOAD_CLASS (X, CLASS)' ! 250: Like `PREFERRED_RELOAD_CLASS', but for output reloads instead of ! 251: input reloads. If you don't define this macro, the default is to ! 252: use CLASS, unchanged. ! 253: ! 254: `LIMIT_RELOAD_CLASS (MODE, CLASS)' ! 255: A C expression that places additional restrictions on the register ! 256: class to use when it is necessary to be able to hold a value of ! 257: mode MODE in a reload register for which class CLASS would ! 258: ordinarily be used. ! 259: ! 260: Unlike `PREFERRED_RELOAD_CLASS', this macro should be used when ! 261: there are certain modes that simply can't go in certain reload ! 262: classes. ! 263: ! 264: The value is a register class; perhaps CLASS, or perhaps another, ! 265: smaller class. ! 266: ! 267: Don't define this macro unless the target machine has limitations ! 268: which require the macro to do something nontrivial. ! 269: ! 270: `SECONDARY_RELOAD_CLASS (CLASS, MODE, X)' ! 271: `SECONDARY_INPUT_RELOAD_CLASS (CLASS, MODE, X)' ! 272: `SECONDARY_OUTPUT_RELOAD_CLASS (CLASS, MODE, X)' ! 273: Many machines have some registers that cannot be copied directly ! 274: to or from memory or even from other types of registers. An ! 275: example is the `MQ' register, which on most machines, can only be ! 276: copied to or from general registers, but not memory. Some ! 277: machines allow copying all registers to and from memory, but ! 278: require a scratch register for stores to some memory locations ! 279: (e.g., those with symbolic address on the RT, and those with ! 280: certain symbolic address on the Sparc when compiling PIC). In ! 281: some cases, both an intermediate and a scratch register are ! 282: required. ! 283: ! 284: You should define these macros to indicate to the reload phase ! 285: that it may need to allocate at least one register for a reload in ! 286: addition to the register to contain the data. Specifically, if ! 287: copying X to a register CLASS in MODE requires an intermediate ! 288: register, you should define `SECONDARY_INPUT_RELOAD_CLASS' to ! 289: return the largest register class all of whose registers can be ! 290: used as intermediate registers or scratch registers. ! 291: ! 292: If copying a register CLASS in MODE to X requires an intermediate ! 293: or scratch register, `SECONDARY_OUTPUT_RELOAD_CLASS' should be ! 294: defined to return the largest register class required. If the ! 295: requirements for input and output reloads are the same, the macro ! 296: `SECONDARY_RELOAD_CLASS' should be used instead of defining both ! 297: macros identically. ! 298: ! 299: The values returned by these macros are often `GENERAL_REGS'. ! 300: Return `NO_REGS' if no spare register is needed; i.e., if X can be ! 301: directly copied to or from a register of CLASS in MODE without ! 302: requiring a scratch register. Do not define this macro if it ! 303: would always return `NO_REGS'. ! 304: ! 305: If a scratch register is required (either with or without an ! 306: intermediate register), you should define patterns for ! 307: `reload_inM' or `reload_outM', as required (*note Standard ! 308: Names::.. These patterns, which will normally be implemented with ! 309: a `define_expand', should be similar to the `movM' patterns, ! 310: except that operand 2 is the scratch register. ! 311: ! 312: Define constraints for the reload register and scratch register ! 313: that contain a single register class. If the original reload ! 314: register (whose class is CLASS) can meet the constraint given in ! 315: the pattern, the value returned by these macros is used for the ! 316: class of the scratch register. Otherwise, two additional reload ! 317: registers are required. Their classes are obtained from the ! 318: constraints in the insn pattern. ! 319: ! 320: X might be a pseudo-register or a `subreg' of a pseudo-register, ! 321: which could either be in a hard register or in memory. Use ! 322: `true_regnum' to find out; it will return -1 if the pseudo is in ! 323: memory and the hard register number if it is in a register. ! 324: ! 325: These macros should not be used in the case where a particular ! 326: class of registers can only be copied to memory and not to another ! 327: class of registers. In that case, secondary reload registers are ! 328: not needed and would not be helpful. Instead, a stack location ! 329: must be used to perform the copy and the `movM' pattern should use ! 330: memory as a intermediate storage. This case often occurs between ! 331: floating-point and general registers. ! 332: ! 333: `SECONDARY_MEMORY_NEEDED (CLASS1, CLASS2, M)' ! 334: Certain machines have the property that some registers cannot be ! 335: copied to some other registers without using memory. Define this ! 336: macro on those machines to be a C expression that is non-zero if ! 337: objects of mode M in registers of CLASS1 can only be copied to ! 338: registers of class CLASS2 by storing a register of CLASS1 into ! 339: memory and loading that memory location into a register of CLASS2. ! 340: ! 341: Do not define this macro if its value would always be zero. ! 342: ! 343: `SECONDARY_MEMORY_NEEDED_RTX (MODE)' ! 344: Normally when `SECONDARY_MEMORY_NEEDED' is defined, the compiler ! 345: allocates a stack slot for a memory location needed for register ! 346: copies. If this macro is defined, the compiler instead uses the ! 347: memory location defined by this macro. ! 348: ! 349: Do not define this macro if you do not define ! 350: `SECONDARY_MEMORY_NEEDED'. ! 351: ! 352: `SECONDARY_MEMORY_NEEDED_MODE (MODE)' ! 353: When the compiler needs a secondary memory location to copy ! 354: between two registers of mode MODE, it normally allocates ! 355: sufficient memory to hold a quantity of `BITS_PER_WORD' bits and ! 356: performs the store and load operations in a mode that many bits ! 357: wide and whose class is the same as that of MODE. ! 358: ! 359: This is right thing to do on most machines because it ensures that ! 360: all bits of the register are copied and prevents accesses to the ! 361: registers in a narrower mode, which some machines prohibit for ! 362: floating-point registers. ! 363: ! 364: However, this default behavior is not correct on some machines, ! 365: such as the DEC Alpha, that store short integers in floating-point ! 366: registers differently than in integer registers. On those ! 367: machines, the default widening will not work correctly and you ! 368: must define this macro to suppress that widening in some cases. ! 369: See the file `alpha.h' for details. ! 370: ! 371: Do not define this macro if you do not define ! 372: `SECONDARY_MEMORY_NEEDED' or if widening MODE to a mode that is ! 373: `BITS_PER_WORD' bits wide is correct for your machine. ! 374: ! 375: `SMALL_REGISTER_CLASSES' ! 376: Normally the compiler avoids choosing registers that have been ! 377: explicitly mentioned in the rtl as spill registers (these ! 378: registers are normally those used to pass parameters and return ! 379: values). However, some machines have so few registers of certain ! 380: classes that there would not be enough registers to use as spill ! 381: registers if this were done. ! 382: ! 383: Define `SMALL_REGISTER_CLASSES' on these machines. When it is ! 384: defined, the compiler allows registers explicitly used in the rtl ! 385: to be used as spill registers but avoids extending the lifetime of ! 386: these registers. ! 387: ! 388: It is always safe to define this macro, but if you unnecessarily ! 389: define it, you will reduce the amount of optimizations that can be ! 390: performed in some cases. If you do not define this macro when it ! 391: is required, the compiler will run out of spill registers and ! 392: print a fatal error message. For most machines, you should not ! 393: define this macro. ! 394: ! 395: `CLASS_LIKELY_SPILLED_P (CLASS)' ! 396: A C expression whose value is nonzero if pseudos that have been ! 397: assigned to registers of class CLASS would likely be spilled ! 398: because registers of CLASS are needed for spill registers. ! 399: ! 400: The default value of this macro returns 1 if CLASS has exactly one ! 401: register and zero otherwise. On most machines, this default ! 402: should be used. Only define this macro to some other expression ! 403: if pseudo allocated by `local-alloc.c' end up in memory because ! 404: their hard registers were needed for spill regisers. If this ! 405: macro returns nonzero for those classes, those pseudos will only ! 406: be allocated by `global.c', which knows how to reallocate the ! 407: pseudo to another register. If there would not be another ! 408: register available for reallocation, you should not change the ! 409: definition of this macro since the only effect of such a ! 410: definition would be to slow down register allocation. ! 411: ! 412: `CLASS_MAX_NREGS (CLASS, MODE)' ! 413: A C expression for the maximum number of consecutive registers of ! 414: class CLASS needed to hold a value of mode MODE. ! 415: ! 416: This is closely related to the macro `HARD_REGNO_NREGS'. In fact, ! 417: the value of the macro `CLASS_MAX_NREGS (CLASS, MODE)' should be ! 418: the maximum value of `HARD_REGNO_NREGS (REGNO, MODE)' for all ! 419: REGNO values in the class CLASS. ! 420: ! 421: This macro helps control the handling of multiple-word values in ! 422: the reload pass. ! 423: ! 424: `CLASS_CANNOT_CHANGE_SIZE' ! 425: If defined, a C expression for a class that contains registers ! 426: which the compiler must always access in a mode that is the same ! 427: size as the mode in which it loaded the register, unless neither ! 428: mode is integral. ! 429: ! 430: For the example, loading 32-bit integer or floating-point objects ! 431: into floating-point registers on the Alpha extends them to 64-bits. ! 432: Therefore loading a 64-bit object and then storing it as a 32-bit ! 433: object does not store the low-order 32-bits, as would be the case ! 434: for a normal register. Therefore, `alpha.h' defines this macro as ! 435: `FLOAT_REGS'. ! 436: ! 437: Three other special macros describe which operands fit which ! 438: constraint letters. ! 439: ! 440: `CONST_OK_FOR_LETTER_P (VALUE, C)' ! 441: A C expression that defines the machine-dependent operand ! 442: constraint letters that specify particular ranges of integer ! 443: values. If C is one of those letters, the expression should check ! 444: that VALUE, an integer, is in the appropriate range and return 1 ! 445: if so, 0 otherwise. If C is not one of those letters, the value ! 446: should be 0 regardless of VALUE. ! 447: ! 448: `CONST_DOUBLE_OK_FOR_LETTER_P (VALUE, C)' ! 449: A C expression that defines the machine-dependent operand ! 450: constraint letters that specify particular ranges of ! 451: `const_double' values. ! 452: ! 453: If C is one of those letters, the expression should check that ! 454: VALUE, an RTX of code `const_double', is in the appropriate range ! 455: and return 1 if so, 0 otherwise. If C is not one of those ! 456: letters, the value should be 0 regardless of VALUE. ! 457: ! 458: `const_double' is used for all floating-point constants and for ! 459: `DImode' fixed-point constants. A given letter can accept either ! 460: or both kinds of values. It can use `GET_MODE' to distinguish ! 461: between these kinds. ! 462: ! 463: `EXTRA_CONSTRAINT (VALUE, C)' ! 464: A C expression that defines the optional machine-dependent ! 465: constraint letters that can be used to segregate specific types of ! 466: operands, usually memory references, for the target machine. ! 467: Normally this macro will not be defined. If it is required for a ! 468: particular target machine, it should return 1 if VALUE corresponds ! 469: to the operand type represented by the constraint letter C. If C ! 470: is not defined as an extra constraint, the value returned should ! 471: be 0 regardless of VALUE. ! 472: ! 473: For example, on the ROMP, load instructions cannot have their ! 474: output in r0 if the memory reference contains a symbolic address. ! 475: Constraint letter `Q' is defined as representing a memory address ! 476: that does *not* contain a symbolic address. An alternative is ! 477: specified with a `Q' constraint on the input and `r' on the ! 478: output. The next alternative specifies `m' on the input and a ! 479: register class that does not include r0 on the output. 1.1.1.2 root 480: 481: 1.1.1.4 ! root 482: File: gcc.info, Node: Stack and Calling, Next: Varargs, Prev: Register Classes, Up: Target Macros 1.1.1.2 root 483: 1.1.1.4 ! root 484: Stack Layout and Calling Conventions ! 485: ==================================== 1.1.1.2 root 486: 1.1.1.4 ! root 487: This describes the stack layout and calling conventions. 1.1.1.2 root 488: 1.1.1.4 ! root 489: * Menu: 1.1.1.2 root 490: 1.1.1.4 ! root 491: * Frame Layout:: ! 492: * Frame Registers:: ! 493: * Elimination:: ! 494: * Stack Arguments:: ! 495: * Register Arguments:: ! 496: * Scalar Return:: ! 497: * Aggregate Return:: ! 498: * Caller Saves:: ! 499: * Function Entry:: ! 500: * Profiling:: 1.1.1.2 root 501: 502: 1.1.1.4 ! root 503: File: gcc.info, Node: Frame Layout, Next: Frame Registers, Up: Stack and Calling 1.1.1.2 root 504: 1.1.1.4 ! root 505: Basic Stack Layout ! 506: ------------------ 1.1.1.2 root 507: 1.1.1.4 ! root 508: Here is the basic stack layout. 1.1.1.2 root 509: 1.1.1.4 ! root 510: `STACK_GROWS_DOWNWARD' ! 511: Define this macro if pushing a word onto the stack moves the stack ! 512: pointer to a smaller address. ! 513: ! 514: When we say, "define this macro if ...," it means that the ! 515: compiler checks this macro only with `#ifdef' so the precise ! 516: definition used does not matter. ! 517: ! 518: `FRAME_GROWS_DOWNWARD' ! 519: Define this macro if the addresses of local variable slots are at ! 520: negative offsets from the frame pointer. ! 521: ! 522: `ARGS_GROW_DOWNWARD' ! 523: Define this macro if successive arguments to a function occupy ! 524: decreasing addresses on the stack. ! 525: ! 526: `STARTING_FRAME_OFFSET' ! 527: Offset from the frame pointer to the first local variable slot to ! 528: be allocated. ! 529: ! 530: If `FRAME_GROWS_DOWNWARD', find the next slot's offset by ! 531: subtracting the first slot's length from `STARTING_FRAME_OFFSET'. ! 532: Otherwise, it is found by adding the length of the first slot to ! 533: the value `STARTING_FRAME_OFFSET'. ! 534: ! 535: `STACK_POINTER_OFFSET' ! 536: Offset from the stack pointer register to the first location at ! 537: which outgoing arguments are placed. If not specified, the ! 538: default value of zero is used. This is the proper value for most ! 539: machines. ! 540: ! 541: If `ARGS_GROW_DOWNWARD', this is the offset to the location above ! 542: the first location at which outgoing arguments are placed. ! 543: ! 544: `FIRST_PARM_OFFSET (FUNDECL)' ! 545: Offset from the argument pointer register to the first argument's ! 546: address. On some machines it may depend on the data type of the ! 547: function. ! 548: ! 549: If `ARGS_GROW_DOWNWARD', this is the offset to the location above ! 550: the first argument's address. ! 551: ! 552: `STACK_DYNAMIC_OFFSET (FUNDECL)' ! 553: Offset from the stack pointer register to an item dynamically ! 554: allocated on the stack, e.g., by `alloca'. ! 555: ! 556: The default value for this macro is `STACK_POINTER_OFFSET' plus the ! 557: length of the outgoing arguments. The default is correct for most ! 558: machines. See `function.c' for details. ! 559: ! 560: `DYNAMIC_CHAIN_ADDRESS (FRAMEADDR)' ! 561: A C expression whose value is RTL representing the address in a ! 562: stack frame where the pointer to the caller's frame is stored. ! 563: Assume that FRAMEADDR is an RTL expression for the address of the ! 564: stack frame itself. ! 565: ! 566: If you don't define this macro, the default is to return the value ! 567: of FRAMEADDR--that is, the stack frame address is also the address ! 568: of the stack word that points to the previous frame. ! 569: ! 570: `SERTUP_FRAME_ADDRESSES ()' ! 571: If defined, a C expression that produces the machine-specific code ! 572: to setup the stack so that arbitrary frames can be accessed. For ! 573: example, on the Sparc, we must flush all of the register windows ! 574: to the stack before we can access arbitrary stack frames. This ! 575: macro will seldom need to be defined. ! 576: ! 577: `RETURN_ADDR_RTX (COUNT, FRAMEADDR)' ! 578: A C expression whose value is RTL representing the value of the ! 579: return address for the frame COUNT steps up from the current frame. ! 580: fRAMEADDR is the frame pointer of the COUNT frame, or the frame ! 581: pointer of the COUNT - 1 frame if `RETURN_ADDR_IN_PREVIOUS_FRAME' ! 582: is defined. ! 583: ! 584: `RETURN_ADDR_IN_PREVIOUS_FRAME' ! 585: Define this if the return address of a particular stack frame is ! 586: accessed from the frame pointer of the previous stack frame. 1.1.1.2 root 587: 588: 1.1.1.4 ! root 589: File: gcc.info, Node: Frame Registers, Next: Elimination, Prev: Frame Layout, Up: Stack and Calling 1.1.1.2 root 590: 1.1.1.4 ! root 591: Registers That Address the Stack Frame ! 592: -------------------------------------- 1.1.1.2 root 593: 1.1.1.4 ! root 594: This discusses registers that address the stack frame. 1.1.1.3 root 595: 1.1.1.4 ! root 596: `STACK_POINTER_REGNUM' ! 597: The register number of the stack pointer register, which must also ! 598: be a fixed register according to `FIXED_REGISTERS'. On most ! 599: machines, the hardware determines which register this is. ! 600: ! 601: `FRAME_POINTER_REGNUM' ! 602: The register number of the frame pointer register, which is used to ! 603: access automatic variables in the stack frame. On some machines, ! 604: the hardware determines which register this is. On other ! 605: machines, you can choose any register you wish for this purpose. ! 606: ! 607: `HARD_FRAME_POINTER_REGNUM' ! 608: On some machines the offset between the frame pointer and starting ! 609: offset of the automatic variables is not known until after register ! 610: allocation has been done (for example, because the saved registers ! 611: are between these two locations). On those machines, define ! 612: `FRAME_POINTER_REGNUM' the number of a special, fixed register to ! 613: be used internally until the offset is known, and define ! 614: `HARD_FRAME_POINTER_REGNUM' to be actual the hard register number ! 615: used for the frame pointer. ! 616: ! 617: You should define this macro only in the very rare circumstances ! 618: when it is not possible to calculate the offset between the frame ! 619: pointer and the automatic variables until after register ! 620: allocation has been completed. When this macro is defined, you ! 621: must also indicate in your definition of `ELIMINABLE_REGS' how to ! 622: eliminate `FRAME_POINTER_REGNUM' into either ! 623: `HARD_FRAME_POINTER_REGNUM' or `STACK_POINTER_REGNUM'. ! 624: ! 625: Do not define this macro if it would be the same as ! 626: `FRAME_POINTER_REGNUM'. ! 627: ! 628: `ARG_POINTER_REGNUM' ! 629: The register number of the arg pointer register, which is used to ! 630: access the function's argument list. On some machines, this is ! 631: the same as the frame pointer register. On some machines, the ! 632: hardware determines which register this is. On other machines, ! 633: you can choose any register you wish for this purpose. If this is ! 634: not the same register as the frame pointer register, then you must ! 635: mark it as a fixed register according to `FIXED_REGISTERS', or ! 636: arrange to be able to eliminate it (*note Elimination::.). ! 637: ! 638: `STATIC_CHAIN_REGNUM' ! 639: `STATIC_CHAIN_INCOMING_REGNUM' ! 640: Register numbers used for passing a function's static chain ! 641: pointer. If register windows are used, the register number as ! 642: seen by the called function is `STATIC_CHAIN_INCOMING_REGNUM', ! 643: while the register number as seen by the calling function is ! 644: `STATIC_CHAIN_REGNUM'. If these registers are the same, ! 645: `STATIC_CHAIN_INCOMING_REGNUM' need not be defined. ! 646: ! 647: The static chain register need not be a fixed register. ! 648: ! 649: If the static chain is passed in memory, these macros should not be ! 650: defined; instead, the next two macros should be defined. ! 651: ! 652: `STATIC_CHAIN' ! 653: `STATIC_CHAIN_INCOMING' ! 654: If the static chain is passed in memory, these macros provide rtx ! 655: giving `mem' expressions that denote where they are stored. ! 656: `STATIC_CHAIN' and `STATIC_CHAIN_INCOMING' give the locations as ! 657: seen by the calling and called functions, respectively. Often the ! 658: former will be at an offset from the stack pointer and the latter ! 659: at an offset from the frame pointer. ! 660: ! 661: The variables `stack_pointer_rtx', `frame_pointer_rtx', and ! 662: `arg_pointer_rtx' will have been initialized prior to the use of ! 663: these macros and should be used to refer to those items. 1.1.1.3 root 664: 1.1.1.4 ! root 665: If the static chain is passed in a register, the two previous ! 666: macros should be defined instead. 1.1.1.2 root 667: 668: 1.1.1.4 ! root 669: File: gcc.info, Node: Elimination, Next: Stack Arguments, Prev: Frame Registers, Up: Stack and Calling 1.1.1.2 root 670: 1.1.1.4 ! root 671: Eliminating Frame Pointer and Arg Pointer ! 672: ----------------------------------------- 1.1.1.2 root 673: 1.1.1.4 ! root 674: This is about eliminating the frame pointer and arg pointer. ! 675: ! 676: `FRAME_POINTER_REQUIRED' ! 677: A C expression which is nonzero if a function must have and use a ! 678: frame pointer. This expression is evaluated in the reload pass. ! 679: If its value is nonzero the function will have a frame pointer. ! 680: ! 681: The expression can in principle examine the current function and ! 682: decide according to the facts, but on most machines the constant 0 ! 683: or the constant 1 suffices. Use 0 when the machine allows code to ! 684: be generated with no frame pointer, and doing so saves some time ! 685: or space. Use 1 when there is no possible advantage to avoiding a ! 686: frame pointer. ! 687: ! 688: In certain cases, the compiler does not know how to produce valid ! 689: code without a frame pointer. The compiler recognizes those cases ! 690: and automatically gives the function a frame pointer regardless of ! 691: what `FRAME_POINTER_REQUIRED' says. You don't need to worry about ! 692: them. ! 693: ! 694: In a function that does not require a frame pointer, the frame ! 695: pointer register can be allocated for ordinary usage, unless you ! 696: mark it as a fixed register. See `FIXED_REGISTERS' for more ! 697: information. ! 698: ! 699: `INITIAL_FRAME_POINTER_OFFSET (DEPTH-VAR)' ! 700: A C statement to store in the variable DEPTH-VAR the difference ! 701: between the frame pointer and the stack pointer values immediately ! 702: after the function prologue. The value would be computed from ! 703: information such as the result of `get_frame_size ()' and the ! 704: tables of registers `regs_ever_live' and `call_used_regs'. ! 705: ! 706: If `ELIMINABLE_REGS' is defined, this macro will be not be used and ! 707: need not be defined. Otherwise, it must be defined even if ! 708: `FRAME_POINTER_REQUIRED' is defined to always be true; in that ! 709: case, you may set DEPTH-VAR to anything. ! 710: ! 711: `ELIMINABLE_REGS' ! 712: If defined, this macro specifies a table of register pairs used to ! 713: eliminate unneeded registers that point into the stack frame. If ! 714: it is not defined, the only elimination attempted by the compiler ! 715: is to replace references to the frame pointer with references to ! 716: the stack pointer. ! 717: ! 718: The definition of this macro is a list of structure ! 719: initializations, each of which specifies an original and ! 720: replacement register. ! 721: ! 722: On some machines, the position of the argument pointer is not ! 723: known until the compilation is completed. In such a case, a ! 724: separate hard register must be used for the argument pointer. ! 725: This register can be eliminated by replacing it with either the ! 726: frame pointer or the argument pointer, depending on whether or not ! 727: the frame pointer has been eliminated. ! 728: ! 729: In this case, you might specify: ! 730: #define ELIMINABLE_REGS \ ! 731: {{ARG_POINTER_REGNUM, STACK_POINTER_REGNUM}, \ ! 732: {ARG_POINTER_REGNUM, FRAME_POINTER_REGNUM}, \ ! 733: {FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM}} ! 734: ! 735: Note that the elimination of the argument pointer with the stack ! 736: pointer is specified first since that is the preferred elimination. ! 737: ! 738: `CAN_ELIMINATE (FROM-REG, TO-REG)' ! 739: A C expression that returns non-zero if the compiler is allowed to ! 740: try to replace register number FROM-REG with register number ! 741: TO-REG. This macro need only be defined if `ELIMINABLE_REGS' is ! 742: defined, and will usually be the constant 1, since most of the ! 743: cases preventing register elimination are things that the compiler ! 744: already knows about. ! 745: ! 746: `INITIAL_ELIMINATION_OFFSET (FROM-REG, TO-REG, OFFSET-VAR)' ! 747: This macro is similar to `INITIAL_FRAME_POINTER_OFFSET'. It ! 748: specifies the initial difference between the specified pair of ! 749: registers. This macro must be defined if `ELIMINABLE_REGS' is ! 750: defined. ! 751: ! 752: `LONGJMP_RESTORE_FROM_STACK' ! 753: Define this macro if the `longjmp' function restores registers from ! 754: the stack frames, rather than from those saved specifically by ! 755: `setjmp'. Certain quantities must not be kept in registers across ! 756: a call to `setjmp' on such machines. 1.1.1.2 root 757: 1.1.1.3 root 758: 1.1.1.4 ! root 759: File: gcc.info, Node: Stack Arguments, Next: Register Arguments, Prev: Elimination, Up: Stack and Calling 1.1.1.2 root 760: 1.1.1.4 ! root 761: Passing Function Arguments on the Stack ! 762: --------------------------------------- 1.1.1.2 root 763: 1.1.1.4 ! root 764: The macros in this section control how arguments are passed on the ! 765: stack. See the following section for other macros that control passing ! 766: certain arguments in registers. ! 767: ! 768: `PROMOTE_PROTOTYPES' ! 769: Define this macro if an argument declared in a prototype as an ! 770: integral type smaller than `int' should actually be passed as an ! 771: `int'. In addition to avoiding errors in certain cases of ! 772: mismatch, it also makes for better code on certain machines. ! 773: ! 774: `PUSH_ROUNDING (NPUSHED)' ! 775: A C expression that is the number of bytes actually pushed onto the ! 776: stack when an instruction attempts to push NPUSHED bytes. ! 777: ! 778: If the target machine does not have a push instruction, do not ! 779: define this macro. That directs GNU CC to use an alternate ! 780: strategy: to allocate the entire argument block and then store the ! 781: arguments into it. ! 782: ! 783: On some machines, the definition ! 784: ! 785: #define PUSH_ROUNDING(BYTES) (BYTES) ! 786: ! 787: will suffice. But on other machines, instructions that appear to ! 788: push one byte actually push two bytes in an attempt to maintain ! 789: alignment. Then the definition should be ! 790: ! 791: #define PUSH_ROUNDING(BYTES) (((BYTES) + 1) & ~1) ! 792: ! 793: `ACCUMULATE_OUTGOING_ARGS' ! 794: If defined, the maximum amount of space required for outgoing ! 795: arguments will be computed and placed into the variable ! 796: `current_function_outgoing_args_size'. No space will be pushed ! 797: onto the stack for each call; instead, the function prologue should ! 798: increase the stack frame size by this amount. ! 799: ! 800: Defining both `PUSH_ROUNDING' and `ACCUMULATE_OUTGOING_ARGS' is ! 801: not proper. ! 802: ! 803: `REG_PARM_STACK_SPACE (FNDECL)' ! 804: Define this macro if functions should assume that stack space has ! 805: been allocated for arguments even when their values are passed in ! 806: registers. ! 807: ! 808: The value of this macro is the size, in bytes, of the area ! 809: reserved for arguments passed in registers for the function ! 810: represented by FNDECL. ! 811: ! 812: This space can be allocated by the caller, or be a part of the ! 813: machine-dependent stack frame: `OUTGOING_REG_PARM_STACK_SPACE' says ! 814: which. ! 815: ! 816: `MAYBE_REG_PARM_STACK_SPACE' ! 817: `FINAL_REG_PARM_STACK_SPACE (CONST_SIZE, VAR_SIZE)' ! 818: Define these macros in addition to the one above if functions might ! 819: allocate stack space for arguments even when their values are ! 820: passed in registers. These should be used when the stack space ! 821: allocated for arguments in registers is not a simple constant ! 822: independent of the function declaration. ! 823: ! 824: The value of the first macro is the size, in bytes, of the area ! 825: that we should initially assume would be reserved for arguments ! 826: passed in registers. ! 827: ! 828: The value of the second macro is the actual size, in bytes, of the ! 829: area that will be reserved for arguments passed in registers. ! 830: This takes two arguments: an integer representing the number of ! 831: bytes of fixed sized arguments on the stack, and a tree ! 832: representing the number of bytes of variable sized arguments on ! 833: the stack. ! 834: ! 835: When these macros are defined, `REG_PARM_STACK_SPACE' will only be ! 836: called for libcall functions, the current function, or for a ! 837: function being called when it is known that such stack space must ! 838: be allocated. In each case this value can be easily computed. ! 839: ! 840: When deciding whether a called function needs such stack space, ! 841: and how much space to reserve, GNU CC uses these two macros ! 842: instead of `REG_PARM_STACK_SPACE'. ! 843: ! 844: `OUTGOING_REG_PARM_STACK_SPACE' ! 845: Define this if it is the responsibility of the caller to allocate ! 846: the area reserved for arguments passed in registers. ! 847: ! 848: If `ACCUMULATE_OUTGOING_ARGS' is defined, this macro controls ! 849: whether the space for these arguments counts in the value of ! 850: `current_function_outgoing_args_size'. ! 851: ! 852: `STACK_PARMS_IN_REG_PARM_AREA' ! 853: Define this macro if `REG_PARM_STACK_SPACE' is defined, but the ! 854: stack parameters don't skip the area specified by it. ! 855: ! 856: Normally, when a parameter is not passed in registers, it is ! 857: placed on the stack beyond the `REG_PARM_STACK_SPACE' area. ! 858: Defining this macro suppresses this behavior and causes the ! 859: parameter to be passed on the stack in its natural location. ! 860: ! 861: `RETURN_POPS_ARGS (FUNTYPE, STACK-SIZE)' ! 862: A C expression that should indicate the number of bytes of its own ! 863: arguments that a function pops on returning, or 0 if the function ! 864: pops no arguments and the caller must therefore pop them all after ! 865: the function returns. ! 866: ! 867: FUNTYPE is a C variable whose value is a tree node that describes ! 868: the function in question. Normally it is a node of type ! 869: `FUNCTION_TYPE' that describes the data type of the function. ! 870: From this it is possible to obtain the data types of the value and ! 871: arguments (if known). ! 872: ! 873: When a call to a library function is being considered, FUNTYPE ! 874: will contain an identifier node for the library function. Thus, if ! 875: you need to distinguish among various library functions, you can ! 876: do so by their names. Note that "library function" in this ! 877: context means a function used to perform arithmetic, whose name is ! 878: known specially in the compiler and was not mentioned in the C ! 879: code being compiled. ! 880: ! 881: STACK-SIZE is the number of bytes of arguments passed on the ! 882: stack. If a variable number of bytes is passed, it is zero, and ! 883: argument popping will always be the responsibility of the calling ! 884: function. ! 885: ! 886: On the Vax, all functions always pop their arguments, so the ! 887: definition of this macro is STACK-SIZE. On the 68000, using the ! 888: standard calling convention, no functions pop their arguments, so ! 889: the value of the macro is always 0 in this case. But an ! 890: alternative calling convention is available in which functions ! 891: that take a fixed number of arguments pop them but other functions ! 892: (such as `printf') pop nothing (the caller pops all). When this ! 893: convention is in use, FUNTYPE is examined to determine whether a ! 894: function takes a fixed number of arguments. 1.1.1.2 root 895: 896: 1.1.1.4 ! root 897: File: gcc.info, Node: Register Arguments, Next: Scalar Return, Prev: Stack Arguments, Up: Stack and Calling 1.1.1.2 root 898: 1.1.1.4 ! root 899: Passing Arguments in Registers ! 900: ------------------------------ 1.1.1.2 root 901: 1.1.1.4 ! root 902: This section describes the macros which let you control how various ! 903: types of arguments are passed in registers or how they are arranged in ! 904: the stack. ! 905: ! 906: `FUNCTION_ARG (CUM, MODE, TYPE, NAMED)' ! 907: A C expression that controls whether a function argument is passed ! 908: in a register, and which register. ! 909: ! 910: The arguments are CUM, which summarizes all the previous ! 911: arguments; MODE, the machine mode of the argument; TYPE, the data ! 912: type of the argument as a tree node or 0 if that is not known ! 913: (which happens for C support library functions); and NAMED, which ! 914: is 1 for an ordinary argument and 0 for nameless arguments that ! 915: correspond to `...' in the called function's prototype. ! 916: ! 917: The value of the expression should either be a `reg' RTX for the ! 918: hard register in which to pass the argument, or zero to pass the ! 919: argument on the stack. ! 920: ! 921: For machines like the Vax and 68000, where normally all arguments ! 922: are pushed, zero suffices as a definition. ! 923: ! 924: The usual way to make the ANSI library `stdarg.h' work on a machine ! 925: where some arguments are usually passed in registers, is to cause ! 926: nameless arguments to be passed on the stack instead. This is done ! 927: by making `FUNCTION_ARG' return 0 whenever NAMED is 0. ! 928: ! 929: You may use the macro `MUST_PASS_IN_STACK (MODE, TYPE)' in the ! 930: definition of this macro to determine if this argument is of a ! 931: type that must be passed in the stack. If `REG_PARM_STACK_SPACE' ! 932: is not defined and `FUNCTION_ARG' returns non-zero for such an ! 933: argument, the compiler will abort. If `REG_PARM_STACK_SPACE' is ! 934: defined, the argument will be computed in the stack and then ! 935: loaded into a register. ! 936: ! 937: `FUNCTION_INCOMING_ARG (CUM, MODE, TYPE, NAMED)' ! 938: Define this macro if the target machine has "register windows", so ! 939: that the register in which a function sees an arguments is not ! 940: necessarily the same as the one in which the caller passed the ! 941: argument. ! 942: ! 943: For such machines, `FUNCTION_ARG' computes the register in which ! 944: the caller passes the value, and `FUNCTION_INCOMING_ARG' should be ! 945: defined in a similar fashion to tell the function being called ! 946: where the arguments will arrive. ! 947: ! 948: If `FUNCTION_INCOMING_ARG' is not defined, `FUNCTION_ARG' serves ! 949: both purposes. ! 950: ! 951: `FUNCTION_ARG_PARTIAL_NREGS (CUM, MODE, TYPE, NAMED)' ! 952: A C expression for the number of words, at the beginning of an ! 953: argument, must be put in registers. The value must be zero for ! 954: arguments that are passed entirely in registers or that are ! 955: entirely pushed on the stack. ! 956: ! 957: On some machines, certain arguments must be passed partially in ! 958: registers and partially in memory. On these machines, typically ! 959: the first N words of arguments are passed in registers, and the ! 960: rest on the stack. If a multi-word argument (a `double' or a ! 961: structure) crosses that boundary, its first few words must be ! 962: passed in registers and the rest must be pushed. This macro tells ! 963: the compiler when this occurs, and how many of the words should go ! 964: in registers. ! 965: ! 966: `FUNCTION_ARG' for these arguments should return the first ! 967: register to be used by the caller for this argument; likewise ! 968: `FUNCTION_INCOMING_ARG', for the called function. ! 969: ! 970: `FUNCTION_ARG_PASS_BY_REFERENCE (CUM, MODE, TYPE, NAMED)' ! 971: A C expression that indicates when an argument must be passed by ! 972: reference. If nonzero for an argument, a copy of that argument is ! 973: made in memory and a pointer to the argument is passed instead of ! 974: the argument itself. The pointer is passed in whatever way is ! 975: appropriate for passing a pointer to that type. ! 976: ! 977: On machines where `REG_PARM_STACK_SPACE' is not defined, a suitable ! 978: definition of this macro might be ! 979: #define FUNCTION_ARG_PASS_BY_REFERENCE\ ! 980: (CUM, MODE, TYPE, NAMED) \ ! 981: MUST_PASS_IN_STACK (MODE, TYPE) ! 982: ! 983: `FUNCTION_ARG_CALLEE_COPIES (CUM, MODE, TYPE, NAMED)' ! 984: If defined, a C expression that indicates when it is the called ! 985: function's responsibility to make a copy of arguments passed by ! 986: invisible reference. Normally, the caller makes a copy and passes ! 987: the address of the copy to the routine being called. When ! 988: FUNCTION_ARG_CALLEE_COPIES is defined and is nonzero, the caller ! 989: does not make a copy. Instead, it passes a pointer to the "live" ! 990: value. The called function must not modify this value. If it can ! 991: be determined that the value won't be modified, it need not make a ! 992: copy; otherwise a copy must be made. ! 993: ! 994: `CUMULATIVE_ARGS' ! 995: A C type for declaring a variable that is used as the first ! 996: argument of `FUNCTION_ARG' and other related values. For some ! 997: target machines, the type `int' suffices and can hold the number ! 998: of bytes of argument so far. ! 999: ! 1000: There is no need to record in `CUMULATIVE_ARGS' anything about the ! 1001: arguments that have been passed on the stack. The compiler has ! 1002: other variables to keep track of that. For target machines on ! 1003: which all arguments are passed on the stack, there is no need to ! 1004: store anything in `CUMULATIVE_ARGS'; however, the data structure ! 1005: must exist and should not be empty, so use `int'. ! 1006: ! 1007: `INIT_CUMULATIVE_ARGS (CUM, FNTYPE, LIBNAME)' ! 1008: A C statement (sans semicolon) for initializing the variable CUM ! 1009: for the state at the beginning of the argument list. The variable ! 1010: has type `CUMULATIVE_ARGS'. The value of FNTYPE is the tree node ! 1011: for the data type of the function which will receive the args, or 0 ! 1012: if the args are to a compiler support library function. ! 1013: ! 1014: When processing a call to a compiler support library function, ! 1015: LIBNAME identifies which one. It is a `symbol_ref' rtx which ! 1016: contains the name of the function, as a string. LIBNAME is 0 when ! 1017: an ordinary C function call is being processed. Thus, each time ! 1018: this macro is called, either LIBNAME or FNTYPE is nonzero, but ! 1019: never both of them at once. ! 1020: ! 1021: `INIT_CUMULATIVE_INCOMING_ARGS (CUM, FNTYPE, LIBNAME)' ! 1022: Like `INIT_CUMULATIVE_ARGS' but overrides it for the purposes of ! 1023: finding the arguments for the function being compiled. If this ! 1024: macro is undefined, `INIT_CUMULATIVE_ARGS' is used instead. ! 1025: ! 1026: The value passed for LIBNAME is always 0, since library routines ! 1027: with special calling conventions are never compiled with GNU CC. ! 1028: The argument LIBNAME exists for symmetry with ! 1029: `INIT_CUMULATIVE_ARGS'. ! 1030: ! 1031: `FUNCTION_ARG_ADVANCE (CUM, MODE, TYPE, NAMED)' ! 1032: A C statement (sans semicolon) to update the summarizer variable ! 1033: CUM to advance past an argument in the argument list. The values ! 1034: MODE, TYPE and NAMED describe that argument. Once this is done, ! 1035: the variable CUM is suitable for analyzing the *following* ! 1036: argument with `FUNCTION_ARG', etc. ! 1037: ! 1038: This macro need not do anything if the argument in question was ! 1039: passed on the stack. The compiler knows how to track the amount ! 1040: of stack space used for arguments without any special help. ! 1041: ! 1042: `FUNCTION_ARG_PADDING (MODE, TYPE)' ! 1043: If defined, a C expression which determines whether, and in which ! 1044: direction, to pad out an argument with extra space. The value ! 1045: should be of type `enum direction': either `upward' to pad above ! 1046: the argument, `downward' to pad below, or `none' to inhibit ! 1047: padding. ! 1048: ! 1049: The *amount* of padding is always just enough to reach the next ! 1050: multiple of `FUNCTION_ARG_BOUNDARY'; this macro does not control ! 1051: it. ! 1052: ! 1053: This macro has a default definition which is right for most ! 1054: systems. For little-endian machines, the default is to pad ! 1055: upward. For big-endian machines, the default is to pad downward ! 1056: for an argument of constant size shorter than an `int', and upward ! 1057: otherwise. 1.1.1.3 root 1058: 1.1.1.4 ! root 1059: `FUNCTION_ARG_BOUNDARY (MODE, TYPE)' ! 1060: If defined, a C expression that gives the alignment boundary, in ! 1061: bits, of an argument with the specified mode and type. If it is ! 1062: not defined, `PARM_BOUNDARY' is used for all arguments. 1.1.1.3 root 1063: 1.1.1.4 ! root 1064: `FUNCTION_ARG_REGNO_P (REGNO)' ! 1065: A C expression that is nonzero if REGNO is the number of a hard ! 1066: register in which function arguments are sometimes passed. This ! 1067: does *not* include implicit arguments such as the static chain and ! 1068: the structure-value address. On many machines, no registers can be ! 1069: used for this purpose since all function arguments are pushed on ! 1070: the stack. 1.1 root 1071:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.