![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-22 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to gcc.info-22 CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 ! root 1: This is Info file gcc.info, produced by Makeinfo-1.54 from the input ! 2: file gcc.texi. ! 3: ! 4: This file documents the use and the internals of the GNU compiler. ! 5: ! 6: Published by the Free Software Foundation 675 Massachusetts Avenue ! 7: Cambridge, MA 02139 USA ! 8: ! 9: Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc. ! 10: ! 11: Permission is granted to make and distribute verbatim copies of this ! 12: manual provided the copyright notice and this permission notice are ! 13: preserved on all copies. ! 14: ! 15: Permission is granted to copy and distribute modified versions of ! 16: this manual under the conditions for verbatim copying, provided also ! 17: that the sections entitled "GNU General Public License" and "Protect ! 18: Your Freedom--Fight `Look And Feel'" are included exactly as in the ! 19: original, and provided that the entire resulting derived work is ! 20: distributed under the terms of a permission notice identical to this ! 21: one. ! 22: ! 23: Permission is granted to copy and distribute translations of this ! 24: manual into another language, under the above conditions for modified ! 25: versions, except that the sections entitled "GNU General Public ! 26: License" and "Protect Your Freedom--Fight `Look And Feel'", and this ! 27: permission notice, may be included in translations approved by the Free ! 28: Software Foundation instead of in the original English. ! 29: ! 30: ! 31: File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros ! 32: ! 33: Miscellaneous Parameters ! 34: ======================== ! 35: ! 36: `PREDICATE_CODES' ! 37: Define this if you have defined special-purpose predicates in the ! 38: file `MACHINE.c'. This macro is called within an initializer of an ! 39: array of structures. The first field in the structure is the name ! 40: of a predicate and the second field is an array of rtl codes. For ! 41: each predicate, list all rtl codes that can be in expressions ! 42: matched by the predicate. The list should have a trailing comma. ! 43: Here is an example of two entries in the list for a typical RISC ! 44: machine: ! 45: ! 46: #define PREDICATE_CODES \ ! 47: {"gen_reg_rtx_operand", {SUBREG, REG}}, \ ! 48: {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, ! 49: ! 50: Defining this macro does not affect the generated code (however, ! 51: incorrect definitions that omit an rtl code that may be matched by ! 52: the predicate can cause the compiler to malfunction). Instead, it ! 53: allows the table built by `genrecog' to be more compact and ! 54: efficient, thus speeding up the compiler. The most important ! 55: predicates to include in the list specified by this macro are ! 56: thoses used in the most insn patterns. ! 57: ! 58: `CASE_VECTOR_MODE' ! 59: An alias for a machine mode name. This is the machine mode that ! 60: elements of a jump-table should have. ! 61: ! 62: `CASE_VECTOR_PC_RELATIVE' ! 63: Define this macro if jump-tables should contain relative addresses. ! 64: ! 65: `CASE_DROPS_THROUGH' ! 66: Define this if control falls through a `case' insn when the index ! 67: value is out of range. This means the specified default-label is ! 68: actually ignored by the `case' insn proper. ! 69: ! 70: `CASE_VALUES_THRESHOLD' ! 71: Define this to be the smallest number of different values for ! 72: which it is best to use a jump-table instead of a tree of ! 73: conditional branches. The default is four for machines with a ! 74: `casesi' instruction and five otherwise. This is best for most ! 75: machines. ! 76: ! 77: `WORD_REGISTER_OPERATIONS' ! 78: Define this macro if operations between registers with integral ! 79: mode smaller than a word are always performed on the entire ! 80: register. Most RISC machines have this property and most CISC ! 81: machines do not. ! 82: ! 83: `LOAD_EXTEND_OP (MODE)' ! 84: Define this macro to be a C expression indicating when insns that ! 85: read memory in MODE, an integral mode narrower than a word, set the ! 86: bits outside of MODE to be either the sign-extension or the ! 87: zero-extension of the data read. Return `SIGN_EXTEND' for values ! 88: of MODE for which the insn sign-extends, `ZERO_EXTEND' for which ! 89: it zero-extends, and `NIL' for other modes. ! 90: ! 91: This macro is not called with MODE non-integral or with a width ! 92: greater than or equal to `BITS_PER_WORD', so you may return any ! 93: value in this case. Do not define this macro if it would always ! 94: return `NIL'. On machines where this macro is defined, you will ! 95: normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'. ! 96: ! 97: `IMPLICIT_FIX_EXPR' ! 98: An alias for a tree code that should be used by default for ! 99: conversion of floating point values to fixed point. Normally, ! 100: `FIX_ROUND_EXPR' is used. ! 101: ! 102: `FIXUNS_TRUNC_LIKE_FIX_TRUNC' ! 103: Define this macro if the same instructions that convert a floating ! 104: point number to a signed fixed point number also convert validly ! 105: to an unsigned one. ! 106: ! 107: `EASY_DIV_EXPR' ! 108: An alias for a tree code that is the easiest kind of division to ! 109: compile code for in the general case. It may be `TRUNC_DIV_EXPR', ! 110: `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four ! 111: division operators differ in how they round the result to an ! 112: integer. `EASY_DIV_EXPR' is used when it is permissible to use ! 113: any of those kinds of division and the choice should be made on ! 114: the basis of efficiency. ! 115: ! 116: `MOVE_MAX' ! 117: The maximum number of bytes that a single instruction can move ! 118: quickly from memory to memory. ! 119: ! 120: `MAX_MOVE_MAX' ! 121: The maximum number of bytes that a single instruction can move ! 122: quickly from memory to memory. If this is undefined, the default ! 123: is `MOVE_MAX'. Otherwise, it is the constant value that is the ! 124: largest value that `MOVE_MAX' can have at run-time. ! 125: ! 126: `SHIFT_COUNT_TRUNCATED' ! 127: A C expression that is nonzero if on this machine the number of ! 128: bits actually used for the count of a shift operation is equal to ! 129: the number of bits needed to represent the size of the object ! 130: being shifted. When this macro is non-zero, the compiler will ! 131: assume that it is safe to omit a sign-extend, zero-extend, and ! 132: certain bitwise `and' instructions that truncates the count of a ! 133: shift operation. On machines that have instructions that act on ! 134: bitfields at variable positions, which may include `bit test' ! 135: instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables ! 136: deletion of truncations of the values that serve as arguments to ! 137: bitfield instructions. ! 138: ! 139: If both types of instructions truncate the count (for shifts) and ! 140: position (for bitfield operations), or if no variable-position ! 141: bitfield instructions exist, you should define this macro. ! 142: ! 143: However, on some machines, such as the 80386 and the 680x0, ! 144: truncation only applies to shift operations and not the (real or ! 145: pretended) bitfield operations. Define `SHIFT_COUNT_TRUNCATED' to ! 146: be zero on such machines. Instead, add patterns to the `md' file ! 147: that include the implied truncation of the shift instructions. ! 148: ! 149: You need not define this macro if it would always have the value ! 150: of zero. ! 151: ! 152: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' ! 153: A C expression which is nonzero if on this machine it is safe to ! 154: "convert" an integer of INPREC bits to one of OUTPREC bits (where ! 155: OUTPREC is smaller than INPREC) by merely operating on it as if it ! 156: had only OUTPREC bits. ! 157: ! 158: On many machines, this expression can be 1. ! 159: ! 160: When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for ! 161: modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. ! 162: If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in ! 163: such cases may improve things. ! 164: ! 165: `STORE_FLAG_VALUE' ! 166: A C expression describing the value returned by a comparison ! 167: operator with an integral mode and stored by a store-flag ! 168: instruction (`sCOND') when the condition is true. This ! 169: description must apply to *all* the `sCOND' patterns and all the ! 170: comparison operators whose results have a `MODE_INT' mode. ! 171: ! 172: A value of 1 or -1 means that the instruction implementing the ! 173: comparison operator returns exactly 1 or -1 when the comparison is ! 174: true and 0 when the comparison is false. Otherwise, the value ! 175: indicates which bits of the result are guaranteed to be 1 when the ! 176: comparison is true. This value is interpreted in the mode of the ! 177: comparison operation, which is given by the mode of the first ! 178: operand in the `sCOND' pattern. Either the low bit or the sign ! 179: bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are ! 180: used by the compiler. ! 181: ! 182: If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will ! 183: generate code that depends only on the specified bits. It can also ! 184: replace comparison operators with equivalent operations if they ! 185: cause the required bits to be set, even if the remaining bits are ! 186: undefined. For example, on a machine whose comparison operators ! 187: return an `SImode' value and where `STORE_FLAG_VALUE' is defined as ! 188: `0x80000000', saying that just the sign bit is relevant, the ! 189: expression ! 190: ! 191: (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) ! 192: ! 193: can be converted to ! 194: ! 195: (ashift:SI X (const_int N)) ! 196: ! 197: where N is the appropriate shift count to move the bit being ! 198: tested into the sign bit. ! 199: ! 200: There is no way to describe a machine that always sets the ! 201: low-order bit for a true value, but does not guarantee the value ! 202: of any other bits, but we do not know of any machine that has such ! 203: an instruction. If you are trying to port GNU CC to such a ! 204: machine, include an instruction to perform a logical-and of the ! 205: result with 1 in the pattern for the comparison operators and let ! 206: us know (*note How to Report Bugs: Bug Reporting.). ! 207: ! 208: Often, a machine will have multiple instructions that obtain a ! 209: value from a comparison (or the condition codes). Here are rules ! 210: to guide the choice of value for `STORE_FLAG_VALUE', and hence the ! 211: instructions to be used: ! 212: ! 213: * Use the shortest sequence that yields a valid definition for ! 214: `STORE_FLAG_VALUE'. It is more efficient for the compiler to ! 215: "normalize" the value (convert it to, e.g., 1 or 0) than for ! 216: the comparison operators to do so because there may be ! 217: opportunities to combine the normalization with other ! 218: operations. ! 219: ! 220: * For equal-length sequences, use a value of 1 or -1, with -1 ! 221: being slightly preferred on machines with expensive jumps and ! 222: 1 preferred on other machines. ! 223: ! 224: * As a second choice, choose a value of `0x80000001' if ! 225: instructions exist that set both the sign and low-order bits ! 226: but do not define the others. ! 227: ! 228: * Otherwise, use a value of `0x80000000'. ! 229: ! 230: Many machines can produce both the value chosen for ! 231: `STORE_FLAG_VALUE' and its negation in the same number of ! 232: instructions. On those machines, you should also define a pattern ! 233: for those cases, e.g., one matching ! 234: ! 235: (set A (neg:M (ne:M B C))) ! 236: ! 237: Some machines can also perform `and' or `plus' operations on ! 238: condition code values with less instructions than the corresponding ! 239: `sCOND' insn followed by `and' or `plus'. On those machines, ! 240: define the appropriate patterns. Use the names `incscc' and ! 241: `decscc', respectively, for the the patterns which perform `plus' ! 242: or `minus' operations on condition code values. See `rs6000.md' ! 243: for some examples. The GNU Superoptizer can be used to find such ! 244: instruction sequences on other machines. ! 245: ! 246: You need not define `STORE_FLAG_VALUE' if the machine has no ! 247: store-flag instructions. ! 248: ! 249: `FLOAT_STORE_FLAG_VALUE' ! 250: A C expression that gives a non-zero floating point value that is ! 251: returned when comparison operators with floating-point results are ! 252: true. Define this macro on machine that have comparison ! 253: operations that return floating-point values. If there are no ! 254: such operations, do not define this macro. ! 255: ! 256: `Pmode' ! 257: An alias for the machine mode for pointers. Normally the ! 258: definition can be ! 259: ! 260: #define Pmode SImode ! 261: ! 262: `FUNCTION_MODE' ! 263: An alias for the machine mode used for memory references to ! 264: functions being called, in `call' RTL expressions. On most ! 265: machines this should be `QImode'. ! 266: ! 267: `INTEGRATE_THRESHOLD (DECL)' ! 268: A C expression for the maximum number of instructions above which ! 269: the function DECL should not be inlined. DECL is a ! 270: `FUNCTION_DECL' node. ! 271: ! 272: The default definition of this macro is 64 plus 8 times the number ! 273: of arguments that the function accepts. Some people think a larger ! 274: threshold should be used on RISC machines. ! 275: ! 276: `SCCS_DIRECTIVE' ! 277: Define this if the preprocessor should ignore `#sccs' directives ! 278: and print no error message. ! 279: ! 280: `HANDLE_PRAGMA (STREAM)' ! 281: Define this macro if you want to implement any pragmas. If ! 282: defined, it should be a C statement to be executed when `#pragma' ! 283: is seen. The argument STREAM is the stdio input stream from which ! 284: the source text can be read. ! 285: ! 286: It is generally a bad idea to implement new uses of `#pragma'. The ! 287: only reason to define this macro is for compatibility with other ! 288: compilers that do support `#pragma' for the sake of any user ! 289: programs which already use it. ! 290: ! 291: `DOLLARS_IN_IDENTIFIERS' ! 292: Define this macro to control use of the character `$' in identifier ! 293: names. The value should be 0, 1, or 2. 0 means `$' is not allowed ! 294: by default; 1 means it is allowed by default if `-traditional' is ! 295: used; 2 means it is allowed by default provided `-ansi' is not ! 296: used. 1 is the default; there is no need to define this macro in ! 297: that case. ! 298: ! 299: `NO_DOLLAR_IN_LABEL' ! 300: Define this macro if the assembler does not accept the character ! 301: `$' in label names. By default constructors and destructors in ! 302: G++ have `$' in the identifiers. If this macro is defined, `.' is ! 303: used instead. ! 304: ! 305: `DEFAULT_MAIN_RETURN' ! 306: Define this macro if the target system expects every program's ! 307: `main' function to return a standard "success" value by default ! 308: (if no other value is explicitly returned). ! 309: ! 310: The definition should be a C statement (sans semicolon) to ! 311: generate the appropriate rtl instructions. It is used only when ! 312: compiling the end of `main'. ! 313: ! 314: `HAVE_ATEXIT' ! 315: Define this if the target system supports the function `atexit' ! 316: from the ANSI C standard. If this is not defined, and ! 317: `INIT_SECTION_ASM_OP' is not defined, a default `exit' function ! 318: will be provided to support C++. ! 319: ! 320: `EXIT_BODY' ! 321: Define this if your `exit' function needs to do something besides ! 322: calling an external function `_cleanup' before terminating with ! 323: `_exit'. The `EXIT_BODY' macro is only needed if netiher ! 324: `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. ! 325: ! 326: `INSN_SETS_ARE_DELAYED (INSN)' ! 327: Define this macro as a C expression that is nonzero if it is safe ! 328: for the delay slot scheduler to place instructions in the delay ! 329: slot of INSN, even if they appear to use a resource set or ! 330: clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU ! 331: CC knows that every `call_insn' has this behavior. On machines ! 332: where some `insn' or `jump_insn' is really a function call and ! 333: hence has this behavior, you should define this macro. ! 334: ! 335: You need not define this macro if it would always return zero. ! 336: ! 337: `INSN_REFERENCES_ARE_DELAYED (INSN)' ! 338: Define this macro as a C expression that is nonzero if it is safe ! 339: for the delay slot scheduler to place instructions in the delay ! 340: slot of INSN, even if they appear to set or clobber a resource ! 341: referenced in INSN. INSN is always a `jump_insn' or an `insn'. ! 342: On machines where some `insn' or `jump_insn' is really a function ! 343: call and its operands are registers whose use is actually in the ! 344: subroutine it calls, you should define this macro. Doing so ! 345: allows the delay slot scheduler to move instructions which copy ! 346: arguments into the argument registers into the delay slot of INSN. ! 347: ! 348: You need not define this macro if it would always return zero. ! 349: ! 350: ! 351: File: gcc.info, Node: Config, Next: Index, Prev: Target Macros, Up: Top ! 352: ! 353: The Configuration File ! 354: ********************** ! 355: ! 356: The configuration file `xm-MACHINE.h' contains macro definitions ! 357: that describe the machine and system on which the compiler is running, ! 358: unlike the definitions in `MACHINE.h', which describe the machine for ! 359: which the compiler is producing output. Most of the values in ! 360: `xm-MACHINE.h' are actually the same on all machines that GNU CC runs ! 361: on, so large parts of all configuration files are identical. But there ! 362: are some macros that vary: ! 363: ! 364: `USG' ! 365: Define this macro if the host system is System V. ! 366: ! 367: `VMS' ! 368: Define this macro if the host system is VMS. ! 369: ! 370: `FAILURE_EXIT_CODE' ! 371: A C expression for the status code to be returned when the compiler ! 372: exits after serious errors. ! 373: ! 374: `SUCCESS_EXIT_CODE' ! 375: A C expression for the status code to be returned when the compiler ! 376: exits without serious errors. ! 377: ! 378: `HOST_WORDS_BIG_ENDIAN' ! 379: Defined if the host machine stores words of multi-word values in ! 380: big-endian order. (GNU CC does not depend on the host byte ! 381: ordering within a word.) ! 382: ! 383: `HOST_FLOAT_WORDS_BIG_ENDIAN' ! 384: Define this macro to be 1 if the host machine stores `DFmode', ! 385: `XFmode' or `TFmode' floating point numbers in memory with the ! 386: word containing the sign bit at the lowest address; otherwise, ! 387: define it to be zero. ! 388: ! 389: This macro need not be defined if the ordering is the same as for ! 390: multi-word integers. ! 391: ! 392: `HOST_FLOAT_FORMAT' ! 393: A numeric code distinguishing the floating point format for the ! 394: host machine. See `TARGET_FLOAT_FORMAT' in *Note Storage Layout:: ! 395: for the alternatives and default. ! 396: ! 397: `HOST_BITS_PER_CHAR' ! 398: A C expression for the number of bits in `char' on the host ! 399: machine. ! 400: ! 401: `HOST_BITS_PER_SHORT' ! 402: A C expression for the number of bits in `short' on the host ! 403: machine. ! 404: ! 405: `HOST_BITS_PER_INT' ! 406: A C expression for the number of bits in `int' on the host machine. ! 407: ! 408: `HOST_BITS_PER_LONG' ! 409: A C expression for the number of bits in `long' on the host ! 410: machine. ! 411: ! 412: `ONLY_INT_FIELDS' ! 413: Define this macro to indicate that the host compiler only supports ! 414: `int' bit fields, rather than other integral types, including ! 415: `enum', as do most C compilers. ! 416: ! 417: `EXECUTABLE_SUFFIX' ! 418: Define this macro if the host system uses a naming convention for ! 419: executable files that involves a common suffix (such as, in some ! 420: systems, `.exe') that must be mentioned explicitly when you run ! 421: the program. ! 422: ! 423: `OBSTACK_CHUNK_SIZE' ! 424: A C expression for the size of ordinary obstack chunks. If you ! 425: don't define this, a usually-reasonable default is used. ! 426: ! 427: `OBSTACK_CHUNK_ALLOC' ! 428: The function used to allocate obstack chunks. If you don't define ! 429: this, `xmalloc' is used. ! 430: ! 431: `OBSTACK_CHUNK_FREE' ! 432: The function used to free obstack chunks. If you don't define ! 433: this, `free' is used. ! 434: ! 435: `USE_C_ALLOCA' ! 436: Define this macro to indicate that the compiler is running with the ! 437: `alloca' implemented in C. This version of `alloca' can be found ! 438: in the file `alloca.c'; to use it, you must also alter the ! 439: `Makefile' variable `ALLOCA'. (This is done automatically for the ! 440: systems on which we know it is needed.) ! 441: ! 442: If you do define this macro, you should probably do it as follows: ! 443: ! 444: #ifndef __GNUC__ ! 445: #define USE_C_ALLOCA ! 446: #else ! 447: #define alloca __builtin_alloca ! 448: #endif ! 449: ! 450: so that when the compiler is compiled with GNU CC it uses the more ! 451: efficient built-in `alloca' function. ! 452: ! 453: `FUNCTION_CONVERSION_BUG' ! 454: Define this macro to indicate that the host compiler does not ! 455: properly handle converting a function value to a ! 456: pointer-to-function when it is used in an expression. ! 457: ! 458: `HAVE_VPRINTF' ! 459: Define this if the library function `vprintf' is available on your ! 460: system. ! 461: ! 462: `MULTIBYTE_CHARS' ! 463: Define this macro to enable support for multibyte characters in the ! 464: input to GNU CC. This requires that the host system support the ! 465: ANSI C library functions for converting multibyte characters to ! 466: wide characters. ! 467: ! 468: `HAVE_PUTENV' ! 469: Define this if the library function `putenv' is available on your ! 470: system. ! 471: ! 472: `NO_SYS_SIGLIST' ! 473: Define this if your system *does not* provide the variable ! 474: `sys_siglist'. ! 475: ! 476: `USE_PROTOTYPES' ! 477: Define this to be 1 if you know that the host compiler supports ! 478: prototypes, even if it doesn't define __STDC__, or define it to be ! 479: 0 if you do not want any prototypes used in compiling GNU CC. If ! 480: `USE_PROTOTYPES' is not defined, it will be determined ! 481: automatically whether your compiler supports prototypes by ! 482: checking if `__STDC__' is defined. ! 483: ! 484: `NO_MD_PROTOTYPES' ! 485: Define this if you wish suppression of prototypes generated from ! 486: the machine description file, but to use other prototypes within ! 487: GNU CC. If `USE_PROTOTYPES' is defined to be 0, or the host ! 488: compiler does not support prototypes, this macro has no effect. ! 489: ! 490: `MD_CALL_PROTOTYPES' ! 491: Define this if you wish to generate prototypes for the `gen_call' ! 492: or `gen_call_value' functions generated from the machine ! 493: description file. If `USE_PROTOTYPES' is defined to be 0, or the ! 494: host compiler does not support prototypes, or `NO_MD_PROTOTYPES' ! 495: is defined, this macro has no effect. As soon as all of the ! 496: machine descriptions are modified to have the appropriate number ! 497: of arguments, this macro will be removed. ! 498: ! 499: Some systems do provide this variable, but with a different name ! 500: such as `_sys_siglist'. On these systems, you can define ! 501: `sys_siglist' as a macro which expands into the name actually ! 502: provided. ! 503: ! 504: `NO_STAB_H' ! 505: Define this if your system does not have the include file ! 506: `stab.h'. If `USG' is defined, `NO_STAB_H' is assumed. ! 507: ! 508: In addition, configuration files for system V define `bcopy', ! 509: `bzero' and `bcmp' as aliases. Some files define `alloca' as a macro ! 510: when compiled with GNU CC, in order to take advantage of the benefit of ! 511: GNU CC's built-in `alloca'. ! 512:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.