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