![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-17 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-17 CVS log | Up to [GCC 2.x] / gcc |
1.1.1.3 ! root 1: This is Info file gcc.info, produced by Makeinfo-1.47 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: Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc. 7: 1.1.1.3 ! root 8: Permission is granted to make and distribute verbatim copies of this ! 9: manual provided the copyright notice and this permission notice are ! 10: preserved on all copies. 1.1 root 11: 12: Permission is granted to copy and distribute modified versions of 13: this manual under the conditions for verbatim copying, provided also 1.1.1.3 ! root 14: that the sections entitled "GNU General Public License" and "Boycott" ! 15: are included exactly as in the original, and provided that the entire ! 16: resulting derived work is distributed under the terms of a permission ! 17: notice identical to this one. 1.1 root 18: 19: Permission is granted to copy and distribute translations of this 20: manual into another language, under the above conditions for modified 1.1.1.3 ! root 21: versions, except that the sections entitled "GNU General Public ! 22: License" and "Boycott", and this permission notice, may be included in ! 23: translations approved by the Free Software Foundation instead of in the ! 24: original English. 1.1 root 25: 26: 1.1.1.3 ! root 27: File: gcc.info, Node: DBX Options, Next: DBX Hooks, Prev: All Debuggers, Up: Debugging Info 1.1 root 28: 1.1.1.3 ! root 29: Specific Options for DBX Output ! 30: ------------------------------- 1.1 root 31: 1.1.1.3 ! root 32: `DBX_DEBUGGING_INFO' ! 33: Define this macro if GNU CC should produce debugging output for DBX ! 34: in response to the `-g' option. ! 35: ! 36: `XCOFF_DEBUGGING_INFO' ! 37: Define this macro if GNU CC should produce XCOFF format debugging ! 38: output in response to the `-g' option. This is a variant of DBX ! 39: format. ! 40: ! 41: `DEFAULT_GDB_EXTENSIONS' ! 42: Define this macro to control whether GNU CC should by default ! 43: generate GDB's extended version of DBX debugging information ! 44: (assuming DBX-format debugging information is enabled at all). If ! 45: you don't define the macro, the default is 1: always generate the ! 46: extended information if there is any occasion to. ! 47: ! 48: `DEBUG_SYMS_TEXT' ! 49: Define this macro if all `.stabs' commands should be output while ! 50: in the text section. ! 51: ! 52: `ASM_STABS_OP' ! 53: A C string constant naming the assembler pseudo op to use instead ! 54: of `.stabs' to define an ordinary debugging symbol. If you don't ! 55: define this macro, `.stabs' is used. This macro applies only to ! 56: DBX debugging information format. ! 57: ! 58: `ASM_STABD_OP' ! 59: A C string constant naming the assembler pseudo op to use instead ! 60: of `.stabd' to define a debugging symbol whose value is the current ! 61: location. If you don't define this macro, `.stabd' is used. This ! 62: macro applies only to DBX debugging information format. ! 63: ! 64: `ASM_STABN_OP' ! 65: A C string constant naming the assembler pseudo op to use instead ! 66: of `.stabn' to define a debugging symbol with no name. If you ! 67: don't define this macro, `.stabn' is used. This macro applies ! 68: only to DBX debugging information format. ! 69: ! 70: `DBX_NO_XREFS' ! 71: Define this macro if DBX on your system does not support the ! 72: construct `xsTAGNAME'. On some systems, this construct is used to ! 73: describe a forward reference to a structure named TAGNAME. On ! 74: other systems, this construct is not supported at all. ! 75: ! 76: `DBX_CONTIN_LENGTH' ! 77: A symbol name in DBX-format debugging information is normally ! 78: continued (split into two separate `.stabs' directives) when it ! 79: exceeds a certain length (by default, 80 characters). On some ! 80: operating systems, DBX requires this splitting; on others, ! 81: splitting must not be done. You can inhibit splitting by defining ! 82: this macro with the value zero. You can override the default ! 83: splitting-length by defining this macro as an expression for the ! 84: length you desire. ! 85: ! 86: `DBX_CONTIN_CHAR' ! 87: Normally continuation is indicated by adding a `\' character to ! 88: the end of a `.stabs' string when a continuation follows. To use ! 89: a different character instead, define this macro as a character ! 90: constant for the character you want to use. Do not define this ! 91: macro if backslash is correct for your system. ! 92: ! 93: `DBX_STATIC_STAB_DATA_SECTION' ! 94: Define this macro if it is necessary to go to the data section ! 95: before outputting the `.stabs' pseudo-op for a non-global static ! 96: variable. ! 97: ! 98: `DBX_TYPE_DECL_STABS_CODE' ! 99: The value to use in the "code" field of the `.stabs' directive for ! 100: a typedef. The default is `N_LSYM'. ! 101: ! 102: `DBX_STATIC_CONST_VAR_CODE' ! 103: The value to use in the "code" field of the `.stabs' directive for ! 104: a static variable located in the text section. DBX format does not ! 105: provide any "right" way to do this. The default is `N_FUN'. ! 106: ! 107: `DBX_REGPARM_STABS_CODE' ! 108: The value to use in the "code" field of the `.stabs' directive for ! 109: a parameter passed in registers. DBX format does not provide any ! 110: "right" way to do this. The default is `N_RSYM'. ! 111: ! 112: `DBX_REGPARM_STABS_LETTER' ! 113: The letter to use in DBX symbol data to identify a symbol as a ! 114: parameter passed in registers. DBX format does not customarily ! 115: provide any way to do this. The default is `'P''. ! 116: ! 117: `DBX_MEMPARM_STABS_LETTER' ! 118: The letter to use in DBX symbol data to identify a symbol as a ! 119: stack parameter. The default is `'p''. ! 120: ! 121: `DBX_FUNCTION_FIRST' ! 122: Define this macro if the DBX information for a function and its ! 123: arguments should precede the assembler code for the function. ! 124: Normally, in DBX format, the debugging information entirely ! 125: follows the assembler code. ! 126: ! 127: `DBX_LBRAC_FIRST' ! 128: Define this macro if the `N_LBRAC' symbol for a block should ! 129: precede the debugging information for variables and functions ! 130: defined in that block. Normally, in DBX format, the `N_LBRAC' ! 131: symbol comes first. 1.1 root 132: 1.1.1.3 ! root 133: ! 134: File: gcc.info, Node: DBX Hooks, Next: File Names and DBX, Prev: DBX Options, Up: Debugging Info ! 135: ! 136: Open-Ended Hooks for DBX Format ! 137: ------------------------------- ! 138: ! 139: `DBX_OUTPUT_LBRAC (STREAM, NAME)' ! 140: Define this macro to say how to output to STREAM the debugging ! 141: information for the start of a scope level for variable names. The ! 142: argument NAME is the name of an assembler symbol (for use with ! 143: `assemble_name') whose value is the address where the scope begins. ! 144: ! 145: `DBX_OUTPUT_RBRAC (STREAM, NAME)' ! 146: Like `DBX_OUTPUT_LBRAC', but for the end of a scope level. ! 147: ! 148: `DBX_OUTPUT_ENUM (STREAM, TYPE)' ! 149: Define this macro if the target machine requires special handling ! 150: to output an enumeration type. The definition should be a C ! 151: statement (sans semicolon) to output the appropriate information ! 152: to STREAM for the type TYPE. ! 153: ! 154: `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)' ! 155: Define this macro if the target machine requires special output at ! 156: the end of the debugging information for a function. The ! 157: definition should be a C statement (sans semicolon) to output the ! 158: appropriate information to STREAM. FUNCTION is the ! 159: `FUNCTION_DECL' node for the function. ! 160: ! 161: `DBX_OUTPUT_STANDARD_TYPES (SYMS)' ! 162: Define this macro if you need to control the order of output of the ! 163: standard data types at the beginning of compilation. The argument ! 164: SYMS is a `tree' which is a chain of all the predefined global ! 165: symbols, including names of data types. ! 166: ! 167: Normally, DBX output starts with definitions of the types for ! 168: integers and characters, followed by all the other predefined ! 169: types of the particular language in no particular order. ! 170: ! 171: On some machines, it is necessary to output different particular ! 172: types first. To do this, define `DBX_OUTPUT_STANDARD_TYPES' to ! 173: output those symbols in the necessary order. Any predefined types ! 174: that you don't explicitly output will be output afterward in no ! 175: particular order. ! 176: ! 177: Be careful not to define this macro so that it works only for C. ! 178: There are no global variables to access most of the built-in ! 179: types, because another language may have another set of types. ! 180: The way to output a particular type is to look through SYMS to see ! 181: if you can find it. Here is an example: ! 182: ! 183: { ! 184: tree decl; ! 185: for (decl = syms; decl; decl = TREE_CHAIN (decl)) ! 186: if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "long int")) ! 187: dbxout_symbol (decl); ! 188: ... ! 189: } ! 190: ! 191: This does nothing if the expected type does not exist. ! 192: ! 193: See the function `init_decl_processing' in source file `c-decl.c' ! 194: to find the names to use for all the built-in C types. ! 195: ! 196: Here is another way of finding a particular type: ! 197: ! 198: { ! 199: tree decl; ! 200: for (decl = syms; decl; decl = TREE_CHAIN (decl)) ! 201: if (TREE_CODE (decl) == TYPE_DECL ! 202: && TREE_CODE (TREE_TYPE (decl)) == INTEGER_CST ! 203: && TYPE_PRECISION (TREE_TYPE (decl)) == 16 ! 204: && TYPE_UNSIGNED (TREE_TYPE (decl))) ! 205: /* This must be `unsigned short'. */ ! 206: dbxout_symbol (decl); ! 207: ... ! 208: } ! 209: ! 210: ! 211: File: gcc.info, Node: File Names and DBX, Next: SDB and DWARF, Prev: DBX Hooks, Up: Debugging Info ! 212: ! 213: File Names in DBX Format ! 214: ------------------------ ! 215: ! 216: `DBX_WORKING_DIRECTORY' ! 217: Define this if DBX wants to have the current directory recorded in ! 218: each object file. ! 219: ! 220: Note that the working directory is always recorded if GDB ! 221: extensions are enabled. ! 222: ! 223: `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)' ! 224: A C statement to output DBX debugging information to the stdio ! 225: stream STREAM which indicates that file NAME is the main source ! 226: file--the file specified as the input file for compilation. This ! 227: macro is called only once, at the beginning of compilation. ! 228: ! 229: This macro need not be defined if the standard form of output for ! 230: DBX debugging information is appropriate. ! 231: ! 232: `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)' ! 233: A C statement to output DBX debugging information to the stdio ! 234: stream STREAM which indicates that the current directory during ! 235: compilation is named NAME. ! 236: ! 237: This macro need not be defined if the standard form of output for ! 238: DBX debugging information is appropriate. ! 239: ! 240: `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)' ! 241: A C statement to output DBX debugging information at the end of ! 242: compilation of the main source file NAME. ! 243: ! 244: If you don't define this macro, nothing special is output at the ! 245: end of compilation, which is correct for most machines. ! 246: ! 247: `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)' ! 248: A C statement to output DBX debugging information to the stdio ! 249: stream STREAM which indicates that file NAME is the current source ! 250: file. This output is generated each time input shifts to a ! 251: different source file as a result of `#include', the end of an ! 252: included file, or a `#line' command. ! 253: ! 254: This macro need not be defined if the standard form of output for ! 255: DBX debugging information is appropriate. ! 256: ! 257: ! 258: File: gcc.info, Node: SDB and DWARF, Prev: File Names and DBX, Up: Debugging Info ! 259: ! 260: Macros for SDB and DWARF Output ! 261: ------------------------------- ! 262: ! 263: `SDB_DEBUGGING_INFO' ! 264: Define this macro if GNU CC should produce COFF-style debugging ! 265: output for SDB in response to the `-g' option. ! 266: ! 267: `DWARF_DEBUGGING_INFO' ! 268: Define this macro if GNU CC should produce dwarf format debugging ! 269: output in response to the `-g' option. ! 270: ! 271: `PUT_SDB_...' ! 272: Define these macros to override the assembler syntax for the ! 273: special SDB assembler directives. See `sdbout.c' for a list of ! 274: these macros and their arguments. If the standard syntax is used, ! 275: you need not define them yourself. ! 276: ! 277: `SDB_DELIM' ! 278: Some assemblers do not support a semicolon as a delimiter, even ! 279: between SDB assembler directives. In that case, define this macro ! 280: to be the delimiter to use (usually `\n'). It is not necessary to ! 281: define a new set of `PUT_SDB_OP' macros if this is the only change ! 282: required. ! 283: ! 284: `SDB_GENERATE_FAKE' ! 285: Define this macro to override the usual method of constructing a ! 286: dummy name for anonymous structure and union types. See ! 287: `sdbout.c' for more information. ! 288: ! 289: `SDB_ALLOW_UNKNOWN_REFERENCES' ! 290: Define this macro to allow references to unknown structure, union, ! 291: or enumeration tags to be emitted. Standard COFF does not allow ! 292: handling of unknown references, MIPS ECOFF has support for it. ! 293: ! 294: `SDB_ALLOW_FORWARD_REFERENCES' ! 295: Define this macro to allow references to structure, union, or ! 296: enumeration tags that have not yet been seen to be handled. Some ! 297: assemblers choke if forward tags are used, while some require it. ! 298: ! 299: ! 300: File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Debugging Info, Up: Target Macros ! 301: ! 302: Cross Compilation and Floating Point Format ! 303: =========================================== ! 304: ! 305: While all modern machines use 2's complement representation for ! 306: integers, there are a variety of representations for floating point ! 307: numbers. This means that in a cross-compiler the representation of ! 308: floating point numbers in the compiled program may be different from ! 309: that used in the machine doing the compilation. ! 310: ! 311: Because different representation systems may offer different amounts ! 312: of range and precision, the cross compiler cannot safely use the host ! 313: machine's floating point arithmetic. Therefore, floating point ! 314: constants must be represented in the target machine's format. This ! 315: means that the cross compiler cannot use `atof' to parse a floating ! 316: point constant; it must have its own special routine to use instead. ! 317: Also, constant folding must emulate the target machine's arithmetic (or ! 318: must not be done at all). ! 319: ! 320: The macros in the following table should be defined only if you are ! 321: cross compiling between different floating point formats. ! 322: ! 323: Otherwise, don't define them. Then default definitions will be set ! 324: up which use `double' as the data type, `==' to test for equality, etc. ! 325: ! 326: You don't need to worry about how many times you use an operand of ! 327: any of these macros. The compiler never uses operands which have side ! 328: effects. ! 329: ! 330: `REAL_VALUE_TYPE' ! 331: A macro for the C data type to be used to hold a floating point ! 332: value in the target machine's format. Typically this would be a ! 333: `struct' containing an array of `int'. ! 334: ! 335: `REAL_VALUES_EQUAL (X, Y)' ! 336: A macro for a C expression which compares for equality the two ! 337: values, X and Y, both of type `REAL_VALUE_TYPE'. ! 338: ! 339: `REAL_VALUES_LESS (X, Y)' ! 340: A macro for a C expression which tests whether X is less than Y, ! 341: both values being of type `REAL_VALUE_TYPE' and interpreted as ! 342: floating point numbers in the target machine's representation. ! 343: ! 344: `REAL_VALUE_LDEXP (X, SCALE)' ! 345: A macro for a C expression which performs the standard library ! 346: function `ldexp', but using the target machine's floating point ! 347: representation. Both X and the value of the expression have type ! 348: `REAL_VALUE_TYPE'. The second argument, SCALE, is an integer. ! 349: ! 350: `REAL_VALUE_FIX (X)' ! 351: A macro whose definition is a C expression to convert the ! 352: target-machine floating point value X to a signed integer. X has ! 353: type `REAL_VALUE_TYPE'. ! 354: ! 355: `REAL_VALUE_UNSIGNED_FIX (X)' ! 356: A macro whose definition is a C expression to convert the ! 357: target-machine floating point value X to an unsigned integer. X ! 358: has type `REAL_VALUE_TYPE'. ! 359: ! 360: `REAL_VALUE_FIX_TRUNCATE (X)' ! 361: A macro whose definition is a C expression to convert the ! 362: target-machine floating point value X to a signed integer, ! 363: rounding toward 0. X has type `REAL_VALUE_TYPE'. ! 364: ! 365: `REAL_VALUE_UNSIGNED_FIX_TRUNCATE (X)' ! 366: A macro whose definition is a C expression to convert the ! 367: target-machine floating point value X to an unsigned integer, ! 368: rounding toward 0. X has type `REAL_VALUE_TYPE'. ! 369: ! 370: `REAL_VALUE_ATOF (STRING)' ! 371: A macro for a C expression which converts STRING, an expression of ! 372: type `char *', into a floating point number in the target ! 373: machine's representation. The value has type `REAL_VALUE_TYPE'. ! 374: ! 375: `REAL_INFINITY' ! 376: Define this macro if infinity is a possible floating point value, ! 377: and therefore division by 0 is legitimate. ! 378: ! 379: `REAL_VALUE_ISINF (X)' ! 380: A macro for a C expression which determines whether X, a floating ! 381: point value, is infinity. The value has type `int'. By default, ! 382: this is defined to call `isinf'. ! 383: ! 384: `REAL_VALUE_ISNAN (X)' ! 385: A macro for a C expression which determines whether X, a floating ! 386: point value, is a "nan" (not-a-number). The value has type `int'. ! 387: By default, this is defined to call `isnan'. ! 388: ! 389: Define the following additional macros if you want to make floating ! 390: point constant folding work while cross compiling. If you don't define ! 391: them, cross compilation is still possible, but constant folding will ! 392: not happen for floating point values. ! 393: ! 394: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)' ! 395: A macro for a C statement which calculates an arithmetic operation ! 396: of the two floating point values X and Y, both of type ! 397: `REAL_VALUE_TYPE' in the target machine's representation, to ! 398: produce a result of the same type and representation which is ! 399: stored in OUTPUT (which will be a variable). ! 400: ! 401: The operation to be performed is specified by CODE, a tree code ! 402: which will always be one of the following: `PLUS_EXPR', ! 403: `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'. ! 404: ! 405: The expansion of this macro is responsible for checking for ! 406: overflow. If overflow happens, the macro expansion should execute ! 407: the statement `return 0;', which indicates the inability to ! 408: perform the arithmetic operation requested. ! 409: ! 410: `REAL_VALUE_NEGATE (X)' ! 411: A macro for a C expression which returns the negative of the ! 412: floating point value X. Both X and the value of the expression ! 413: have type `REAL_VALUE_TYPE' and are in the target machine's ! 414: floating point representation. ! 415: ! 416: There is no way for this macro to report overflow, since overflow ! 417: can't happen in the negation operation. ! 418: ! 419: `REAL_VALUE_TRUNCATE (X)' ! 420: A macro for a C expression which converts the double-precision ! 421: floating point value X to single-precision. ! 422: ! 423: Both X and the value of the expression have type `REAL_VALUE_TYPE' ! 424: and are in the target machine's floating point representation. ! 425: However, the value should have an appropriate bit pattern to be ! 426: output properly as a single-precision floating constant. ! 427: ! 428: There is no way for this macro to report overflow. ! 429: ! 430: `REAL_VALUE_TO_INT (LOW, HIGH, X)' ! 431: A macro for a C expression which converts a floating point value X ! 432: into a double-precision integer which is then stored into LOW and ! 433: HIGH, two variables of type INT. ! 434: ! 435: `REAL_VALUE_FROM_INT (X, LOW, HIGH)' ! 436: A macro for a C expression which converts a double-precision ! 437: integer found in LOW and HIGH, two variables of type INT, into a ! 438: floating point value which is then stored into X. ! 439: ! 440: ! 441: File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros ! 442: ! 443: Miscellaneous Parameters ! 444: ======================== ! 445: ! 446: `PREDICATE_CODES' ! 447: Optionally define this if you have added predicates to ! 448: `MACHINE.c'. This macro is called within an initializer of an ! 449: array of structures. The first field in the structure is the name ! 450: of a predicate and the second field is an array of rtl codes. For ! 451: each predicate, list all rtl codes that can be in expressions ! 452: matched by the predicate. The list should have a trailing comma. ! 453: Here is an example of two entries in the list for a typical RISC ! 454: machine: ! 455: ! 456: #define PREDICATE_CODES \ ! 457: {"gen_reg_rtx_operand", {SUBREG, REG}}, \ ! 458: {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}}, ! 459: ! 460: Defining this macro does not affect the generated code (however, ! 461: incorrect definitions that omit an rtl code that may be matched by ! 462: the predicate can cause the compiler to malfunction). Instead, it ! 463: allows the table built by `genrecog' to be more compact and ! 464: efficient, thus speeding up the compiler. The most important ! 465: predicates to include in the list specified by this macro are ! 466: thoses used in the most insn patterns. ! 467: ! 468: `CASE_VECTOR_MODE' ! 469: An alias for a machine mode name. This is the machine mode that ! 470: elements of a jump-table should have. ! 471: ! 472: `CASE_VECTOR_PC_RELATIVE' ! 473: Define this macro if jump-tables should contain relative addresses. ! 474: ! 475: `CASE_DROPS_THROUGH' ! 476: Define this if control falls through a `case' insn when the index ! 477: value is out of range. This means the specified default-label is ! 478: actually ignored by the `case' insn proper. ! 479: ! 480: `BYTE_LOADS_ZERO_EXTEND' ! 481: Define this macro if an instruction to load a value narrower than a ! 482: word from memory into a register also zero-extends the value to ! 483: the whole register. ! 484: ! 485: `IMPLICIT_FIX_EXPR' ! 486: An alias for a tree code that should be used by default for ! 487: conversion of floating point values to fixed point. Normally, ! 488: `FIX_ROUND_EXPR' is used. ! 489: ! 490: `FIXUNS_TRUNC_LIKE_FIX_TRUNC' ! 491: Define this macro if the same instructions that convert a floating ! 492: point number to a signed fixed point number also convert validly ! 493: to an unsigned one. ! 494: ! 495: `EASY_DIV_EXPR' ! 496: An alias for a tree code that is the easiest kind of division to ! 497: compile code for in the general case. It may be `TRUNC_DIV_EXPR', ! 498: `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four ! 499: division operators differ in how they round the result to an ! 500: integer. `EASY_DIV_EXPR' is used when it is permissible to use ! 501: any of those kinds of division and the choice should be made on ! 502: the basis of efficiency. ! 503: ! 504: `MOVE_MAX' ! 505: The maximum number of bytes that a single instruction can move ! 506: quickly from memory to memory. ! 507: ! 508: `SHIFT_COUNT_TRUNCATED' ! 509: Defining this macro causes the compiler to omit a sign-extend, ! 510: zero-extend, or bitwise `and' instruction that truncates the count ! 511: of a shift operation to a width equal to the number of bits needed ! 512: to represent the size of the object being shifted. On machines ! 513: that have instructions that act on bitfields at variable ! 514: positions, including `bit test' instructions, defining ! 515: `SHIFT_COUNT_TRUNCATED' also causes truncation not to be applied ! 516: to these instructions. ! 517: ! 518: If both types of instructions truncate the count (for shifts) and ! 519: position (for bitfield operations), or if no variable-position ! 520: bitfield instructions exist, you should define this macro. ! 521: ! 522: However, on some machines, such as the 80386 and the 680x0, ! 523: truncation only applies to shift operations and not the (real or ! 524: pretended) bitfield operations. Do not define ! 525: `SHIFT_COUNT_TRUNCATED' on such machines. Instead, add patterns ! 526: to the `md' file that include the implied truncation of the shift ! 527: instructions. ! 528: ! 529: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)' ! 530: A C expression which is nonzero if on this machine it is safe to ! 531: "convert" an integer of INPREC bits to one of OUTPREC bits (where ! 532: OUTPREC is smaller than INPREC) by merely operating on it as if it ! 533: had only OUTPREC bits. ! 534: ! 535: On many machines, this expression can be 1. ! 536: ! 537: It is reported that suboptimal code can result when ! 538: `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for ! 539: which `MODES_TIEABLE_P' is 0. If this is the case, making ! 540: `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve things. ! 541: ! 542: `STORE_FLAG_VALUE' ! 543: A C expression describing the value returned by a comparison ! 544: operator and stored by a store-flag instruction (`sCOND') when the ! 545: condition is true. This description must apply to *all* the ! 546: `sCOND' patterns and all the comparison operators. ! 547: ! 548: A value of 1 or -1 means that the instruction implementing the ! 549: comparison operator returns exactly 1 or -1 when the comparison is ! 550: true and 0 when the comparison is false. Otherwise, the value ! 551: indicates which bits of the result are guaranteed to be 1 when the ! 552: comparison is true. This value is interpreted in the mode of the ! 553: comparison operation, which is given by the mode of the first ! 554: operand in the `sCOND' pattern. Either the low bit or the sign ! 555: bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are ! 556: used by the compiler. ! 557: ! 558: If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will ! 559: generate code that depends only on the specified bits. It can also ! 560: replace comparison operators with equivalent operations if they ! 561: cause the required bits to be set, even if the remaining bits are ! 562: undefined. For example, on a machine whose comparison operators ! 563: return an `SImode' value and where `STORE_FLAG_VALUE' is defined as ! 564: `0x80000000', saying that just the sign bit is relevant, the ! 565: expression ! 566: ! 567: (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0)) ! 568: ! 569: can be converted to ! 570: ! 571: (ashift:SI X (const_int N)) ! 572: ! 573: where N is the appropriate shift count to move the bit being ! 574: tested into the sign bit. ! 575: ! 576: There is no way to describe a machine that always sets the ! 577: low-order bit for a true value, but does not guarantee the value ! 578: of any other bits, but we do not know of any machine that has such ! 579: an instruction. If you are trying to port GNU CC to such a ! 580: machine, include an instruction to perform a logical-and of the ! 581: result with 1 in the pattern for the comparison operators and let ! 582: us know (*note Bug Reporting::.). ! 583: ! 584: Often, a machine will have multiple instructions that obtain a ! 585: value from a comparison (or the condition codes). Here are rules ! 586: to guide the choice of value for `STORE_FLAG_VALUE', and hence the ! 587: instructions to be used: ! 588: ! 589: * Use the shortest sequence that yields a valid definition for ! 590: `STORE_FLAG_VALUE'. It is more efficient for the compiler to ! 591: "normalize" the value (convert it to, e.g., 1 or 0) than for ! 592: the comparison operators to do so because there may be ! 593: opportunities to combine the normalization with other ! 594: operations. ! 595: ! 596: * For equal-length sequences, use a value of 1 or -1, with -1 ! 597: being slightly preferred on machines with expensive jumps and ! 598: 1 preferred on other machines. ! 599: ! 600: * As a second choice, choose a value of `0x80000001' if ! 601: instructions exist that set both the sign and low-order bits ! 602: but do not define the others. ! 603: ! 604: * Otherwise, use a value of `0x80000000'. ! 605: ! 606: You need not define `STORE_FLAG_VALUE' if the machine has no ! 607: store-flag instructions. ! 608: ! 609: `Pmode' ! 610: An alias for the machine mode for pointers. Normally the ! 611: definition can be ! 612: ! 613: #define Pmode SImode ! 614: ! 615: `FUNCTION_MODE' ! 616: An alias for the machine mode used for memory references to ! 617: functions being called, in `call' RTL expressions. On most ! 618: machines this should be `QImode'. ! 619: ! 620: `INTEGRATE_THRESHOLD (DECL)' ! 621: A C expression for the maximum number of instructions above which ! 622: the function DECL should not be inlined. DECL is a ! 623: `FUNCTION_DECL' node. ! 624: ! 625: The default definition of this macro is 64 plus 8 times the number ! 626: of arguments that the function accepts. Some people think a larger ! 627: threshold should be used on RISC machines. ! 628: ! 629: `SCCS_DIRECTIVE' ! 630: Define this if the preprocessor should ignore `#sccs' directives ! 631: and print no error message. ! 632: ! 633: `HANDLE_PRAGMA (STREAM)' ! 634: Define this macro if you want to implement any pragmas. If ! 635: defined, it should be a C statement to be executed when `#pragma' ! 636: is seen. The argument STREAM is the stdio input stream from which ! 637: the source text can be read. ! 638: ! 639: It is generally a bad idea to implement new uses of `#pragma'. The ! 640: only reason to define this macro is for compatibility with other ! 641: compilers that do support `#pragma' for the sake of any user ! 642: programs which already use it. ! 643: ! 644: `DOLLARS_IN_IDENTIFIERS' ! 645: Define this macro to control use of the character `$' in identifier ! 646: names. The value should be 0, 1, or 2. 0 means `$' is not allowed ! 647: by default; 1 means it is allowed by default if `-traditional' is ! 648: used; 2 means it is allowed by default provided `-ansi' is not ! 649: used. 1 is the default; there is no need to define this macro in ! 650: that case. ! 651: ! 652: `NO_DOLLAR_IN_LABEL' ! 653: Define this macro if the assembler does not accept the character ! 654: `$' in label names. By default constructors and destructors in ! 655: G++ have `$' in the identifiers. If this macro is defined, `.' is ! 656: used instead. ! 657: ! 658: `DEFAULT_MAIN_RETURN' ! 659: Define this macro if the target system expects every program's ! 660: `main' function to return a standard "success" value by default ! 661: (if no other value is explicitly returned). ! 662: ! 663: The definition should be a C statement (sans semicolon) to ! 664: generate the appropriate rtl instructions. It is used only when ! 665: compiling the end of `main'. ! 666: ! 667: `HAVE_ATEXIT' ! 668: Define this if the target system supports the function `atexit' ! 669: from the ANSI C standard. If this is not defined, and ! 670: `INIT_SECTION_ASM_OP' is not defined, a default `exit' function ! 671: will be provided to support C++. ! 672: ! 673: `EXIT_BODY' ! 674: Define this if your `exit' function needs to do something besides ! 675: calling an external function `_cleanup' before terminating with ! 676: `_exit'. The `EXIT_BODY' macro is only needed if netiher ! 677: `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined. ! 678: ! 679: ! 680: File: gcc.info, Node: Config, Next: Index, Prev: Target Macros, Up: Top ! 681: ! 682: The Configuration File ! 683: ********************** 1.1 root 684: 1.1.1.3 ! root 685: The configuration file `xm-MACHINE.h' contains macro definitions ! 686: that describe the machine and system on which the compiler is running, ! 687: unlike the definitions in `MACHINE.h', which describe the machine for ! 688: which the compiler is producing output. Most of the values in ! 689: `xm-MACHINE.h' are actually the same on all machines that GNU CC runs ! 690: on, so large parts of all configuration files are identical. But there ! 691: are some macros that vary: ! 692: ! 693: `USG' ! 694: Define this macro if the host system is System V. ! 695: ! 696: `VMS' ! 697: Define this macro if the host system is VMS. ! 698: ! 699: `FAILURE_EXIT_CODE' ! 700: A C expression for the status code to be returned when the compiler ! 701: exits after serious errors. ! 702: ! 703: `SUCCESS_EXIT_CODE' ! 704: A C expression for the status code to be returned when the compiler ! 705: exits without serious errors. ! 706: ! 707: `HOST_WORDS_BIG_ENDIAN' ! 708: Defined if the host machine stores words of multi-word values in ! 709: big-endian order. (GNU CC does not depend on the host byte ! 710: ordering within a word.) ! 711: ! 712: `HOST_FLOAT_FORMAT' ! 713: A numeric code distinguishing the floating point format for the ! 714: host machine. See `TARGET_FLOAT_FORMAT' in *Note Storage Layout:: ! 715: for the alternatives and default. ! 716: ! 717: `HOST_BITS_PER_CHAR' ! 718: A C expression for the number of bits in `char' on the host ! 719: machine. ! 720: ! 721: `HOST_BITS_PER_SHORT' ! 722: A C expression for the number of bits in `short' on the host ! 723: machine. ! 724: ! 725: `HOST_BITS_PER_INT' ! 726: A C expression for the number of bits in `int' on the host machine. ! 727: ! 728: `HOST_BITS_PER_LONG' ! 729: A C expression for the number of bits in `long' on the host ! 730: machine. ! 731: ! 732: `ONLY_INT_FIELDS' ! 733: Define this macro to indicate that the host compiler only supports ! 734: `int' bit fields, rather than other integral types, including ! 735: `enum', as do most C compilers. ! 736: ! 737: `EXECUTABLE_SUFFIX' ! 738: Define this macro if the host system uses a naming convention for ! 739: executable files that involves a common suffix (such as, in some ! 740: systems, `.exe') that must be mentioned explicitly when you run ! 741: the program. ! 742: ! 743: `OBSTACK_CHUNK_SIZE' ! 744: A C expression for the size of ordinary obstack chunks. If you ! 745: don't define this, a usually-reasonable default is used. ! 746: ! 747: `OBSTACK_CHUNK_ALLOC' ! 748: The function used to allocate obstack chunks. If you don't define ! 749: this, `xmalloc' is used. ! 750: ! 751: `OBSTACK_CHUNK_FREE' ! 752: The function used to free obstack chunks. If you don't define ! 753: this, `free' is used. ! 754: ! 755: `USE_C_ALLOCA' ! 756: Define this macro to indicate that the compiler is running with the ! 757: `alloca' implemented in C. This version of `alloca' can be found ! 758: in the file `alloca.c'; to use it, you must also alter the ! 759: `Makefile' variable `ALLOCA'. (This is done automatically for the ! 760: systems on which we know it is needed.) ! 761: ! 762: If you do define this macro, you should probably do it as follows: ! 763: ! 764: #ifndef __GNUC__ ! 765: #define USE_C_ALLOCA ! 766: #else ! 767: #define alloca __builtin_alloca ! 768: #endif ! 769: ! 770: so that when the compiler is compiled with GNU CC it uses the more ! 771: efficient built-in `alloca' function. ! 772: ! 773: `FUNCTION_CONVERSION_BUG' ! 774: Define this macro to indicate that the host compiler does not ! 775: properly handle converting a function value to a ! 776: pointer-to-function when it is used in an expression. ! 777: ! 778: `HAVE_VPRINTF' ! 779: Define this if the library function `vprintf' is available on your ! 780: system. ! 781: ! 782: `MULTIBYTE_CHARS' ! 783: Define this macro to enable support for multibyte characters in the ! 784: input to GNU CC. This requires that the host system support the ! 785: ANSI C library functions for converting multibyte characters to ! 786: wide characters. ! 787: ! 788: `HAVE_PUTENV' ! 789: Define this if the library function `putenv' is available on your ! 790: system. ! 791: ! 792: `NO_SYS_SIGLIST' ! 793: Define this if your system *does not* provide the variable ! 794: `sys_siglist'. ! 795: ! 796: Some systems do provide this variable, but with a different name ! 797: such as `_sys_siglist'. On these systems, you can define ! 798: `sys_siglist' as a macro which expands into the name actually ! 799: provided. ! 800: ! 801: `NO_STAB_H' ! 802: Define this if your system does not have the include file ! 803: `stab.h'. If `USG' is defined, `NO_STAB_H' is assumed. ! 804: ! 805: In addition, configuration files for system V define `bcopy', ! 806: `bzero' and `bcmp' as aliases. Some files define `alloca' as a macro ! 807: when compiled with GNU CC, in order to take advantage of the benefit of ! 808: GNU CC's built-in `alloca'. 1.1 root 809: 1.1.1.3 ! root 810:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.