![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-24 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-24 CVS log | Up to [GCC 2.x] / gcc |
1.1.1.3 ! root 1: This is Info file gcc.info, produced by Makeinfo version 1.67 from the ! 2: input file gcc.texi. 1.1 root 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 59 Temple Place - Suite 330 7: Boston, MA 02111-1307 USA 1.1 root 8: 1.1.1.2 root 9: Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software 10: Foundation, 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 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. 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 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. 31: 32: 1.1.1.2 root 33: File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Debugging Info, Up: Target Macros 1.1 root 34: 1.1.1.2 root 35: Cross Compilation and Floating Point 36: ==================================== 37: 38: While all modern machines use 2's complement representation for 39: integers, there are a variety of representations for floating point 40: numbers. This means that in a cross-compiler the representation of 41: floating point numbers in the compiled program may be different from 42: that used in the machine doing the compilation. 43: 44: Because different representation systems may offer different amounts 45: of range and precision, the cross compiler cannot safely use the host 46: machine's floating point arithmetic. Therefore, floating point 47: constants must be represented in the target machine's format. This 48: means that the cross compiler cannot use `atof' to parse a floating 49: point constant; it must have its own special routine to use instead. 50: Also, constant folding must emulate the target machine's arithmetic (or 51: must not be done at all). 52: 53: The macros in the following table should be defined only if you are 54: cross compiling between different floating point formats. 55: 56: Otherwise, don't define them. Then default definitions will be set 57: up which use `double' as the data type, `==' to test for equality, etc. 58: 59: You don't need to worry about how many times you use an operand of 60: any of these macros. The compiler never uses operands which have side 61: effects. 62: 63: `REAL_VALUE_TYPE' 64: A macro for the C data type to be used to hold a floating point 65: value in the target machine's format. Typically this would be a 66: `struct' containing an array of `int'. 67: 68: `REAL_VALUES_EQUAL (X, Y)' 69: A macro for a C expression which compares for equality the two 70: values, X and Y, both of type `REAL_VALUE_TYPE'. 71: 72: `REAL_VALUES_LESS (X, Y)' 73: A macro for a C expression which tests whether X is less than Y, 74: both values being of type `REAL_VALUE_TYPE' and interpreted as 75: floating point numbers in the target machine's representation. 76: 77: `REAL_VALUE_LDEXP (X, SCALE)' 78: A macro for a C expression which performs the standard library 79: function `ldexp', but using the target machine's floating point 80: representation. Both X and the value of the expression have type 81: `REAL_VALUE_TYPE'. The second argument, SCALE, is an integer. 82: 83: `REAL_VALUE_FIX (X)' 84: A macro whose definition is a C expression to convert the 85: target-machine floating point value X to a signed integer. X has 86: type `REAL_VALUE_TYPE'. 87: 88: `REAL_VALUE_UNSIGNED_FIX (X)' 89: A macro whose definition is a C expression to convert the 90: target-machine floating point value X to an unsigned integer. X 91: has type `REAL_VALUE_TYPE'. 92: 93: `REAL_VALUE_RNDZINT (X)' 94: A macro whose definition is a C expression to round the 95: target-machine floating point value X towards zero to an integer 96: value (but still as a floating point number). X has type 97: `REAL_VALUE_TYPE', and so does the value. 98: 99: `REAL_VALUE_UNSIGNED_RNDZINT (X)' 100: A macro whose definition is a C expression to round the 101: target-machine floating point value X towards zero to an unsigned 102: integer value (but still represented as a floating point number). 1.1.1.3 ! root 103: X has type `REAL_VALUE_TYPE', and so does the value. 1.1.1.2 root 104: 105: `REAL_VALUE_ATOF (STRING, MODE)' 106: A macro for a C expression which converts STRING, an expression of 107: type `char *', into a floating point number in the target machine's 108: representation for mode MODE. The value has type 109: `REAL_VALUE_TYPE'. 110: 111: `REAL_INFINITY' 112: Define this macro if infinity is a possible floating point value, 113: and therefore division by 0 is legitimate. 114: 115: `REAL_VALUE_ISINF (X)' 116: A macro for a C expression which determines whether X, a floating 117: point value, is infinity. The value has type `int'. By default, 118: this is defined to call `isinf'. 119: 120: `REAL_VALUE_ISNAN (X)' 121: A macro for a C expression which determines whether X, a floating 122: point value, is a "nan" (not-a-number). The value has type `int'. 123: By default, this is defined to call `isnan'. 124: 125: Define the following additional macros if you want to make floating 126: point constant folding work while cross compiling. If you don't define 127: them, cross compilation is still possible, but constant folding will 128: not happen for floating point values. 129: 130: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)' 131: A macro for a C statement which calculates an arithmetic operation 132: of the two floating point values X and Y, both of type 133: `REAL_VALUE_TYPE' in the target machine's representation, to 134: produce a result of the same type and representation which is 135: stored in OUTPUT (which will be a variable). 136: 137: The operation to be performed is specified by CODE, a tree code 138: which will always be one of the following: `PLUS_EXPR', 139: `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'. 140: 141: The expansion of this macro is responsible for checking for 142: overflow. If overflow happens, the macro expansion should execute 143: the statement `return 0;', which indicates the inability to 144: perform the arithmetic operation requested. 145: 146: `REAL_VALUE_NEGATE (X)' 147: A macro for a C expression which returns the negative of the 148: floating point value X. Both X and the value of the expression 149: have type `REAL_VALUE_TYPE' and are in the target machine's 150: floating point representation. 151: 152: There is no way for this macro to report overflow, since overflow 153: can't happen in the negation operation. 154: 155: `REAL_VALUE_TRUNCATE (MODE, X)' 156: A macro for a C expression which converts the floating point value 157: X to mode MODE. 158: 159: Both X and the value of the expression are in the target machine's 160: floating point representation and have type `REAL_VALUE_TYPE'. 161: However, the value should have an appropriate bit pattern to be 162: output properly as a floating constant whose precision accords 163: with mode MODE. 164: 165: There is no way for this macro to report overflow. 166: 167: `REAL_VALUE_TO_INT (LOW, HIGH, X)' 168: A macro for a C expression which converts a floating point value X 169: into a double-precision integer which is then stored into LOW and 170: HIGH, two variables of type INT. 171: 172: `REAL_VALUE_FROM_INT (X, LOW, HIGH)' 173: A macro for a C expression which converts a double-precision 174: integer found in LOW and HIGH, two variables of type INT, into a 175: floating point value which is then stored into X. 176: 177: 178: File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros 179: 180: Miscellaneous Parameters 181: ======================== 182: 183: Here are several miscellaneous parameters. 184: 185: `PREDICATE_CODES' 186: Define this if you have defined special-purpose predicates in the 187: file `MACHINE.c'. This macro is called within an initializer of an 188: array of structures. The first field in the structure is the name 189: of a predicate and the second field is an array of rtl codes. For 190: each predicate, list all rtl codes that can be in expressions 191: matched by the predicate. The list should have a trailing comma. 192: Here is an example of two entries in the list for a typical RISC 193: machine: 194: 195: #define PREDICATE_CODES \ 196: {"gen_reg_rtx_operand", {SUBREG, REG}}, \ 197: {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, 198: 199: Defining this macro does not affect the generated code (however, 200: incorrect definitions that omit an rtl code that may be matched by 201: the predicate can cause the compiler to malfunction). Instead, it 202: allows the table built by `genrecog' to be more compact and 203: efficient, thus speeding up the compiler. The most important 204: predicates to include in the list specified by this macro are 205: thoses used in the most insn patterns. 206: 207: `CASE_VECTOR_MODE' 208: An alias for a machine mode name. This is the machine mode that 209: elements of a jump-table should have. 210: 211: `CASE_VECTOR_PC_RELATIVE' 212: Define this macro if jump-tables should contain relative addresses. 213: 214: `CASE_DROPS_THROUGH' 215: Define this if control falls through a `case' insn when the index 216: value is out of range. This means the specified default-label is 217: actually ignored by the `case' insn proper. 218: 219: `CASE_VALUES_THRESHOLD' 220: Define this to be the smallest number of different values for 221: which it is best to use a jump-table instead of a tree of 222: conditional branches. The default is four for machines with a 223: `casesi' instruction and five otherwise. This is best for most 224: machines. 225: 226: `WORD_REGISTER_OPERATIONS' 227: Define this macro if operations between registers with integral 228: mode smaller than a word are always performed on the entire 229: register. Most RISC machines have this property and most CISC 230: machines do not. 231: 232: `LOAD_EXTEND_OP (MODE)' 233: Define this macro to be a C expression indicating when insns that 234: read memory in MODE, an integral mode narrower than a word, set the 235: bits outside of MODE to be either the sign-extension or the 236: zero-extension of the data read. Return `SIGN_EXTEND' for values 237: of MODE for which the insn sign-extends, `ZERO_EXTEND' for which 238: it zero-extends, and `NIL' for other modes. 239: 240: This macro is not called with MODE non-integral or with a width 241: greater than or equal to `BITS_PER_WORD', so you may return any 242: value in this case. Do not define this macro if it would always 243: return `NIL'. On machines where this macro is defined, you will 244: normally define it as the constant `SIGN_EXTEND' or `ZERO_EXTEND'. 245: 246: `IMPLICIT_FIX_EXPR' 247: An alias for a tree code that should be used by default for 248: conversion of floating point values to fixed point. Normally, 249: `FIX_ROUND_EXPR' is used. 250: 251: `FIXUNS_TRUNC_LIKE_FIX_TRUNC' 252: Define this macro if the same instructions that convert a floating 253: point number to a signed fixed point number also convert validly 254: to an unsigned one. 255: 256: `EASY_DIV_EXPR' 257: An alias for a tree code that is the easiest kind of division to 258: compile code for in the general case. It may be `TRUNC_DIV_EXPR', 259: `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four 260: division operators differ in how they round the result to an 261: integer. `EASY_DIV_EXPR' is used when it is permissible to use 262: any of those kinds of division and the choice should be made on 263: the basis of efficiency. 264: 265: `MOVE_MAX' 266: The maximum number of bytes that a single instruction can move 267: quickly from memory to memory. 268: 269: `MAX_MOVE_MAX' 270: The maximum number of bytes that a single instruction can move 271: quickly from memory to memory. If this is undefined, the default 272: is `MOVE_MAX'. Otherwise, it is the constant value that is the 273: largest value that `MOVE_MAX' can have at run-time. 274: 275: `SHIFT_COUNT_TRUNCATED' 276: A C expression that is nonzero if on this machine the number of 277: bits actually used for the count of a shift operation is equal to 278: the number of bits needed to represent the size of the object 279: being shifted. When this macro is non-zero, the compiler will 280: assume that it is safe to omit a sign-extend, zero-extend, and 281: certain bitwise `and' instructions that truncates the count of a 282: shift operation. On machines that have instructions that act on 283: bitfields at variable positions, which may include `bit test' 284: instructions, a nonzero `SHIFT_COUNT_TRUNCATED' also enables 285: deletion of truncations of the values that serve as arguments to 286: bitfield instructions. 287: 288: If both types of instructions truncate the count (for shifts) and 289: position (for bitfield operations), or if no variable-position 290: bitfield instructions exist, you should define this macro. 291: 292: However, on some machines, such as the 80386 and the 680x0, 293: truncation only applies to shift operations and not the (real or 294: pretended) bitfield operations. Define `SHIFT_COUNT_TRUNCATED' to 295: be zero on such machines. Instead, add patterns to the `md' file 296: that include the implied truncation of the shift instructions. 297: 298: You need not define this macro if it would always have the value 299: of zero. 300: 301: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' 302: A C expression which is nonzero if on this machine it is safe to 303: "convert" an integer of INPREC bits to one of OUTPREC bits (where 304: OUTPREC is smaller than INPREC) by merely operating on it as if it 305: had only OUTPREC bits. 306: 307: On many machines, this expression can be 1. 308: 309: When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for 310: modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result. 311: If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in 312: such cases may improve things. 313: 314: `STORE_FLAG_VALUE' 315: A C expression describing the value returned by a comparison 316: operator with an integral mode and stored by a store-flag 317: instruction (`sCOND') when the condition is true. This 318: description must apply to *all* the `sCOND' patterns and all the 319: comparison operators whose results have a `MODE_INT' mode. 320: 321: A value of 1 or -1 means that the instruction implementing the 322: comparison operator returns exactly 1 or -1 when the comparison is 323: true and 0 when the comparison is false. Otherwise, the value 324: indicates which bits of the result are guaranteed to be 1 when the 325: comparison is true. This value is interpreted in the mode of the 326: comparison operation, which is given by the mode of the first 327: operand in the `sCOND' pattern. Either the low bit or the sign 328: bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are 329: used by the compiler. 330: 331: If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will 332: generate code that depends only on the specified bits. It can also 333: replace comparison operators with equivalent operations if they 334: cause the required bits to be set, even if the remaining bits are 335: undefined. For example, on a machine whose comparison operators 336: return an `SImode' value and where `STORE_FLAG_VALUE' is defined as 337: `0x80000000', saying that just the sign bit is relevant, the 338: expression 339: 340: (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) 341: 342: can be converted to 343: 344: (ashift:SI X (const_int N)) 345: 346: where N is the appropriate shift count to move the bit being 347: tested into the sign bit. 348: 349: There is no way to describe a machine that always sets the 350: low-order bit for a true value, but does not guarantee the value 351: of any other bits, but we do not know of any machine that has such 352: an instruction. If you are trying to port GNU CC to such a 353: machine, include an instruction to perform a logical-and of the 354: result with 1 in the pattern for the comparison operators and let 355: us know (*note How to Report Bugs: Bug Reporting.). 356: 357: Often, a machine will have multiple instructions that obtain a 358: value from a comparison (or the condition codes). Here are rules 359: to guide the choice of value for `STORE_FLAG_VALUE', and hence the 360: instructions to be used: 361: 362: * Use the shortest sequence that yields a valid definition for 363: `STORE_FLAG_VALUE'. It is more efficient for the compiler to 364: "normalize" the value (convert it to, e.g., 1 or 0) than for 365: the comparison operators to do so because there may be 366: opportunities to combine the normalization with other 367: operations. 368: 369: * For equal-length sequences, use a value of 1 or -1, with -1 370: being slightly preferred on machines with expensive jumps and 371: 1 preferred on other machines. 372: 373: * As a second choice, choose a value of `0x80000001' if 374: instructions exist that set both the sign and low-order bits 375: but do not define the others. 376: 377: * Otherwise, use a value of `0x80000000'. 378: 379: Many machines can produce both the value chosen for 380: `STORE_FLAG_VALUE' and its negation in the same number of 381: instructions. On those machines, you should also define a pattern 382: for those cases, e.g., one matching 383: 384: (set A (neg:M (ne:M B C))) 385: 386: Some machines can also perform `and' or `plus' operations on 387: condition code values with less instructions than the corresponding 388: `sCOND' insn followed by `and' or `plus'. On those machines, 389: define the appropriate patterns. Use the names `incscc' and 390: `decscc', respectively, for the the patterns which perform `plus' 391: or `minus' operations on condition code values. See `rs6000.md' 392: for some examples. The GNU Superoptizer can be used to find such 393: instruction sequences on other machines. 394: 395: You need not define `STORE_FLAG_VALUE' if the machine has no 396: store-flag instructions. 397: 398: `FLOAT_STORE_FLAG_VALUE' 399: A C expression that gives a non-zero floating point value that is 400: returned when comparison operators with floating-point results are 401: true. Define this macro on machine that have comparison 402: operations that return floating-point values. If there are no 403: such operations, do not define this macro. 404: 405: `Pmode' 406: An alias for the machine mode for pointers. On most machines, 407: define this to be the integer mode corresponding to the width of a 408: hardware pointer; `SImode' on 32-bit machine or `DImode' on 64-bit 409: machines. On some machines you must define this to be one of the 410: partial integer modes, such as `PSImode'. 411: 412: The width of `Pmode' must be at least as large as the value of 413: `POINTER_SIZE'. If it is not equal, you must define the macro 414: `POINTERS_EXTEND_UNSIGNED' to specify how pointers are extended to 415: `Pmode'. 416: 417: `FUNCTION_MODE' 418: An alias for the machine mode used for memory references to 419: functions being called, in `call' RTL expressions. On most 420: machines this should be `QImode'. 421: 422: `INTEGRATE_THRESHOLD (DECL)' 423: A C expression for the maximum number of instructions above which 424: the function DECL should not be inlined. DECL is a 425: `FUNCTION_DECL' node. 426: 427: The default definition of this macro is 64 plus 8 times the number 428: of arguments that the function accepts. Some people think a larger 429: threshold should be used on RISC machines. 430: 431: `SCCS_DIRECTIVE' 432: Define this if the preprocessor should ignore `#sccs' directives 433: and print no error message. 434: 435: `NO_IMPLICIT_EXTERN_C' 436: Define this macro if the system header files support C++ as well 437: as C. This macro inhibits the usual method of using system header 438: files in C++, which is to pretend that the file's contents are 439: enclosed in `extern "C" {...}'. 440: 441: `HANDLE_PRAGMA (STREAM)' 442: Define this macro if you want to implement any pragmas. If 443: defined, it should be a C statement to be executed when `#pragma' 444: is seen. The argument STREAM is the stdio input stream from which 445: the source text can be read. 446: 447: It is generally a bad idea to implement new uses of `#pragma'. The 448: only reason to define this macro is for compatibility with other 449: compilers that do support `#pragma' for the sake of any user 450: programs which already use it. 451: 452: `VALID_MACHINE_DECL_ATTRIBUTE (DECL, ATTRIBUTES, IDENTIFIER, ARGS)' 453: If defined, a C expression whose value is nonzero if IDENTIFIER 454: with arguments ARGS is a valid machine specific attribute for DECL. 455: The attributes in ATTRIBUTES have previously been assigned to DECL. 456: 457: `VALID_MACHINE_TYPE_ATTRIBUTE (TYPE, ATTRIBUTES, IDENTIFIER, ARGS)' 458: If defined, a C expression whose value is nonzero if IDENTIFIER 459: with arguments ARGS is a valid machine specific attribute for TYPE. 460: The attributes in ATTRIBUTES have previously been assigned to TYPE. 461: 462: `COMP_TYPE_ATTRIBUTES (TYPE1, TYPE2)' 463: If defined, a C expression whose value is zero if the attributes on 464: TYPE1 and TYPE2 are incompatible, one if they are compatible, and 465: two if they are nearly compatible (which causes a warning to be 466: generated). 467: 468: `SET_DEFAULT_TYPE_ATTRIBUTES (TYPE)' 469: If defined, a C statement that assigns default attributes to newly 470: defined TYPE. 471: 472: `DOLLARS_IN_IDENTIFIERS' 473: Define this macro to control use of the character `$' in identifier 474: names. The value should be 0, 1, or 2. 0 means `$' is not allowed 475: by default; 1 means it is allowed by default if `-traditional' is 476: used; 2 means it is allowed by default provided `-ansi' is not 477: used. 1 is the default; there is no need to define this macro in 478: that case. 479: 480: `NO_DOLLAR_IN_LABEL' 481: Define this macro if the assembler does not accept the character 482: `$' in label names. By default constructors and destructors in 483: G++ have `$' in the identifiers. If this macro is defined, `.' is 484: used instead. 485: 486: `NO_DOT_IN_LABEL' 487: Define this macro if the assembler does not accept the character 488: `.' in label names. By default constructors and destructors in G++ 489: have names that use `.'. If this macro is defined, these names 490: are rewritten to avoid `.'. 491: 492: `DEFAULT_MAIN_RETURN' 493: Define this macro if the target system expects every program's 494: `main' function to return a standard "success" value by default 495: (if no other value is explicitly returned). 496: 497: The definition should be a C statement (sans semicolon) to 498: generate the appropriate rtl instructions. It is used only when 499: compiling the end of `main'. 500: 501: `HAVE_ATEXIT' 502: Define this if the target system supports the function `atexit' 503: from the ANSI C standard. If this is not defined, and 504: `INIT_SECTION_ASM_OP' is not defined, a default `exit' function 505: will be provided to support C++. 506: 507: `EXIT_BODY' 508: Define this if your `exit' function needs to do something besides 509: calling an external function `_cleanup' before terminating with 510: `_exit'. The `EXIT_BODY' macro is only needed if netiher 511: `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. 512: 513: `INSN_SETS_ARE_DELAYED (INSN)' 514: Define this macro as a C expression that is nonzero if it is safe 515: for the delay slot scheduler to place instructions in the delay 516: slot of INSN, even if they appear to use a resource set or 517: clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU 518: CC knows that every `call_insn' has this behavior. On machines 519: where some `insn' or `jump_insn' is really a function call and 520: hence has this behavior, you should define this macro. 521: 522: You need not define this macro if it would always return zero. 523: 524: `INSN_REFERENCES_ARE_DELAYED (INSN)' 525: Define this macro as a C expression that is nonzero if it is safe 526: for the delay slot scheduler to place instructions in the delay 527: slot of INSN, even if they appear to set or clobber a resource 528: referenced in INSN. INSN is always a `jump_insn' or an `insn'. 529: On machines where some `insn' or `jump_insn' is really a function 530: call and its operands are registers whose use is actually in the 531: subroutine it calls, you should define this macro. Doing so 532: allows the delay slot scheduler to move instructions which copy 533: arguments into the argument registers into the delay slot of INSN. 534: 535: You need not define this macro if it would always return zero. 536: 537: `MACHINE_DEPENDENT_REORG (INSN)' 538: In rare cases, correct code generation requires extra machine 539: dependent processing between the second jump optimization pass and 540: delayed branch scheduling. On those machines, define this macro 541: as a C statement to act on the code starting at INSN. 542: 543: 544: File: gcc.info, Node: Config, Next: Fragments, Prev: Target Macros, Up: Top 545: 546: The Configuration File 547: ********************** 548: 549: The configuration file `xm-MACHINE.h' contains macro definitions 550: that describe the machine and system on which the compiler is running, 551: unlike the definitions in `MACHINE.h', which describe the machine for 552: which the compiler is producing output. Most of the values in 553: `xm-MACHINE.h' are actually the same on all machines that GNU CC runs 554: on, so large parts of all configuration files are identical. But there 555: are some macros that vary: 556: 557: `USG' 558: Define this macro if the host system is System V. 559: 560: `VMS' 561: Define this macro if the host system is VMS. 562: 563: `FATAL_EXIT_CODE' 564: A C expression for the status code to be returned when the compiler 565: exits after serious errors. 566: 567: `SUCCESS_EXIT_CODE' 568: A C expression for the status code to be returned when the compiler 569: exits without serious errors. 570: 571: `HOST_WORDS_BIG_ENDIAN' 572: Defined if the host machine stores words of multi-word values in 573: big-endian order. (GNU CC does not depend on the host byte 574: ordering within a word.) 575: 576: `HOST_FLOAT_WORDS_BIG_ENDIAN' 577: Define this macro to be 1 if the host machine stores `DFmode', 578: `XFmode' or `TFmode' floating point numbers in memory with the 579: word containing the sign bit at the lowest address; otherwise, 580: define it to be zero. 581: 582: This macro need not be defined if the ordering is the same as for 583: multi-word integers. 584: 585: `HOST_FLOAT_FORMAT' 586: A numeric code distinguishing the floating point format for the 587: host machine. See `TARGET_FLOAT_FORMAT' in *Note Storage Layout:: 588: for the alternatives and default. 589: 590: `HOST_BITS_PER_CHAR' 591: A C expression for the number of bits in `char' on the host 592: machine. 593: 594: `HOST_BITS_PER_SHORT' 595: A C expression for the number of bits in `short' on the host 596: machine. 597: 598: `HOST_BITS_PER_INT' 599: A C expression for the number of bits in `int' on the host machine. 600: 601: `HOST_BITS_PER_LONG' 602: A C expression for the number of bits in `long' on the host 603: machine. 604: 605: `ONLY_INT_FIELDS' 606: Define this macro to indicate that the host compiler only supports 607: `int' bit fields, rather than other integral types, including 608: `enum', as do most C compilers. 609: 610: `OBSTACK_CHUNK_SIZE' 611: A C expression for the size of ordinary obstack chunks. If you 612: don't define this, a usually-reasonable default is used. 613: 614: `OBSTACK_CHUNK_ALLOC' 615: The function used to allocate obstack chunks. If you don't define 616: this, `xmalloc' is used. 617: 618: `OBSTACK_CHUNK_FREE' 619: The function used to free obstack chunks. If you don't define 620: this, `free' is used. 621: 622: `USE_C_ALLOCA' 623: Define this macro to indicate that the compiler is running with the 624: `alloca' implemented in C. This version of `alloca' can be found 625: in the file `alloca.c'; to use it, you must also alter the 626: `Makefile' variable `ALLOCA'. (This is done automatically for the 627: systems on which we know it is needed.) 628: 629: If you do define this macro, you should probably do it as follows: 630: 631: #ifndef __GNUC__ 632: #define USE_C_ALLOCA 633: #else 634: #define alloca __builtin_alloca 635: #endif 636: 637: so that when the compiler is compiled with GNU CC it uses the more 638: efficient built-in `alloca' function. 639: 640: `FUNCTION_CONVERSION_BUG' 641: Define this macro to indicate that the host compiler does not 642: properly handle converting a function value to a 643: pointer-to-function when it is used in an expression. 644: 645: `HAVE_VPRINTF' 646: Define this if the library function `vprintf' is available on your 647: system. 648: 649: `MULTIBYTE_CHARS' 650: Define this macro to enable support for multibyte characters in the 651: input to GNU CC. This requires that the host system support the 652: ANSI C library functions for converting multibyte characters to 653: wide characters. 654: 655: `HAVE_PUTENV' 656: Define this if the library function `putenv' is available on your 657: system. 658: 659: `POSIX' 660: Define this if your system is POSIX.1 compliant. 661: 662: `NO_SYS_SIGLIST' 663: Define this if your system *does not* provide the variable 664: `sys_siglist'. 665: 666: `DONT_DECLARE_SYS_SIGLIST' 667: Define this if your system has the variable `sys_siglist', and 668: there is already a declaration of it in the system header files. 669: 670: `USE_PROTOTYPES' 671: Define this to be 1 if you know that the host compiler supports 672: prototypes, even if it doesn't define __STDC__, or define it to be 673: 0 if you do not want any prototypes used in compiling GNU CC. If 674: `USE_PROTOTYPES' is not defined, it will be determined 675: automatically whether your compiler supports prototypes by 676: checking if `__STDC__' is defined. 677: 678: `NO_MD_PROTOTYPES' 679: Define this if you wish suppression of prototypes generated from 680: the machine description file, but to use other prototypes within 681: GNU CC. If `USE_PROTOTYPES' is defined to be 0, or the host 682: compiler does not support prototypes, this macro has no effect. 683: 684: `MD_CALL_PROTOTYPES' 685: Define this if you wish to generate prototypes for the `gen_call' 686: or `gen_call_value' functions generated from the machine 687: description file. If `USE_PROTOTYPES' is defined to be 0, or the 688: host compiler does not support prototypes, or `NO_MD_PROTOTYPES' 689: is defined, this macro has no effect. As soon as all of the 690: machine descriptions are modified to have the appropriate number 691: of arguments, this macro will be removed. 692: 693: Some systems do provide this variable, but with a different name 694: such as `_sys_siglist'. On these systems, you can define 695: `sys_siglist' as a macro which expands into the name actually 696: provided. 697: 698: `NO_STAB_H' 699: Define this if your system does not have the include file 700: `stab.h'. If `USG' is defined, `NO_STAB_H' is assumed. 701: 702: `PATH_SEPARATOR' 703: Define this macro to be a C character constant representing the 704: character used to separate components in paths. The default value 705: is. the colon character 706: 707: `DIR_SEPARATOR' 708: If your system uses some character other than slash to separate 709: directory names within a file specification, define this macro to 710: be a C character constant specifying that character. When GNU CC 711: displays file names, the character you specify will be used. GNU 712: CC will test for both slash and the character you specify when 713: parsing filenames. 714: 715: `OBJECT_SUFFIX' 716: Define this macro to be a C string representing the suffix for 717: object files on your machine. If you do not define this macro, 718: GNU CC will use `.o' as the suffix for object files. 719: 720: `EXECUTABLE_SUFFIX' 721: Define this macro to be a C string representing the suffix for 722: executable files on your machine. If you do not define this 723: macro, GNU CC will use the null string as the suffix for object 724: files. 725: 726: `COLLECT_EXPORT_LIST' 727: If defined, `collect2' will scan the individual object files 728: specified on its command line and create an export list for the 729: linker. Define this macro for systems like AIX, where the linker 730: discards object files that are not referenced from `main' and uses 731: export lists. 732: 733: In addition, configuration files for system V define `bcopy', 734: `bzero' and `bcmp' as aliases. Some files define `alloca' as a macro 735: when compiled with GNU CC, in order to take advantage of the benefit of 736: GNU CC's built-in `alloca'. 737: 738: 739: File: gcc.info, Node: Fragments, Next: Index, Prev: Config, Up: Top 740: 741: Makefile Fragments 742: ****************** 743: 744: When you configure GNU CC using the `configure' script (*note 745: Installation::.), it will construct the file `Makefile' from the 746: template file `Makefile.in'. When it does this, it will incorporate 747: makefile fragment files from the `config' directory, named `t-TARGET' 748: and `x-HOST'. If these files do not exist, it means nothing needs to 749: be added for a given target or host. 1.1 root 750: 751: * Menu: 752: 1.1.1.2 root 753: * Target Fragment:: Writing the `t-TARGET' file. 754: * Host Fragment:: Writing the `x-HOST' file. 755: 756: 757: File: gcc.info, Node: Target Fragment, Next: Host Fragment, Up: Fragments 758: 759: The Target Makefile Fragment 760: ============================ 761: 762: The target makefile fragment, `t-TARGET', defines special target 763: dependent variables and targets used in the `Makefile': 764: 765: `LIBGCC1' 766: The rule to use to build `libgcc1.a'. If your target does not 767: need to use the functions in `libgcc1.a', set this to empty. 768: *Note Interface::. 769: 770: `CROSS_LIBGCC1' 771: The rule to use to build `libgcc1.a' when building a cross 772: compiler. If your target does not need to use the functions in 773: `libgcc1.a', set this to empty. *Note Cross Runtime::. 774: 775: `LIBGCC2_CFLAGS' 776: Compiler flags to use when compiling `libgcc2.c'. 777: 778: `LIB2FUNCS_EXTRA' 779: A list of source file names to be compiled or assembled and 780: inserted into `libgcc.a'. 781: 782: `CRTSTUFF_T_CFLAGS' 783: Special flags used when compiling `crtstuff.c'. *Note 784: Initialization::. 785: 786: `MULTILIB_OPTIONS' 787: For some targets, invoking GNU CC in different ways produces 788: objects that can not be linked together. For example, for some 789: targets GNU CC produces both big and little endian code. For 790: these targets, you must arrange for multiple versions of 791: `libgcc.a' to be compiled, one for each set of incompatible 792: options. When GNU CC invokes the linker, it arranges to link in 793: the right version of `libgcc.a', based on the command line options 794: used. 795: 796: The `MULTILIB_OPTIONS' macro lists the set of options for which 797: special versions of `libgcc.a' must be built. Write options that 798: are mutually incompatible side by side, separated by a slash. 799: Write options that may be used together separated by a space. The 800: build procedure will build all combinations of compatible options. 801: 802: For example, if you set `MULTILIB_OPTIONS' to `m68000/m68020 803: msoft-float', `Makefile' will build special versions of `libgcc.a' 804: using the options `-m68000', `-m68020', `-msoft-float', `-m68000 805: -msoft-float', and `-m68020 -msoft-float'. 806: 807: `MULTILIB_DIRNAMES' 808: If `MULTILIB_OPTIONS' is used, this variable specifies the 809: directory names that should be used to hold the various libraries. 810: Write one element in `MULTILIB_DIRNAMES' for each element in 811: `MULTILIB_OPTIONS'. If `MULTILIB_DIRNAMES' is not used, the 812: default value will be `MULTILIB_OPTIONS', with all slashes treated 813: as spaces. 814: 815: For example, if `MULTILIB_OPTIONS' is `m68000/m68020 msoft-float', 816: then the default value of `MULTILIB_DIRNAMES' is `m68000 m68020 817: msoft-float'. You may specify a different value if you desire a 818: different set of directory names. 819: 820: `MULTILIB_MATCHES' 821: Sometimes the same option may be written in two different ways. 822: If an option is listed in `MULTILIB_OPTIONS', GNU CC needs to know 823: about any synonyms. In that case, set `MULTILIB_MATCHES' to a 824: list of items of the form `option=option' to describe all relevant 825: synonyms. For example, `m68000=mc68000 m68020=mc68020'. 826: 827: 828: File: gcc.info, Node: Host Fragment, Prev: Target Fragment, Up: Fragments 829: 830: The Host Makefile Fragment 831: ========================== 832: 833: The host makefile fragment, `x-HOST', defines special host dependent 834: variables and targets used in the `Makefile': 835: 836: `CC' 837: The compiler to use when building the first stage. 838: 839: `CLIB' 840: Additional host libraries to link with. 841: 842: `OLDCC' 843: The compiler to use when building `libgcc1.a' for a native 844: compilation. 845: 846: `OLDAR' 847: The version of `ar' to use when building `libgcc1.a' for a native 848: compilation. 1.1 root 849: 1.1.1.2 root 850: `INSTALL' 851: The install program to use. 1.1 root 852:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.