![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-13 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-13 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: Driver, Next: Run-time Target, Up: Target Macros 1.1.1.2 root 28: 1.1.1.3 ! root 29: Controlling the Compilation Driver, `gcc' ! 30: ========================================= 1.1.1.2 root 31: 1.1.1.3 ! root 32: `SWITCH_TAKES_ARG (CHAR)' ! 33: A C expression which determines whether the option `-CHAR' takes ! 34: arguments. The value should be the number of arguments that ! 35: option takes--zero, for many options. 1.1.1.2 root 36: 1.1.1.3 ! root 37: By default, this macro is defined to handle the standard options ! 38: properly. You need not define it unless you wish to add additional ! 39: options which take arguments. 1.1.1.2 root 40: 1.1.1.3 ! root 41: `WORD_SWITCH_TAKES_ARG (NAME)' ! 42: A C expression which determines whether the option `-NAME' takes ! 43: arguments. The value should be the number of arguments that ! 44: option takes--zero, for many options. This macro rather than ! 45: `SWITCH_TAKES_ARG' is used for multi-character option names. 1.1.1.2 root 46: 1.1.1.3 ! root 47: By default, this macro is defined to handle the standard options ! 48: properly. You need not define it unless you wish to add additional ! 49: options which take arguments. 1.1.1.2 root 50: 1.1.1.3 ! root 51: `SWITCHES_NEED_SPACES' ! 52: A string-valued C expression which is nonempty if the linker needs ! 53: a space between the `-L' or `-o' option and its argument. 1.1.1.2 root 54: 1.1.1.3 ! root 55: If this macro is not defined, the default value is 0. 1.1.1.2 root 56: 1.1.1.3 ! root 57: `CPP_SPEC' ! 58: A C string constant that tells the GNU CC driver program options to ! 59: pass to CPP. It can also specify how to translate options you ! 60: give to GNU CC into options for GNU CC to pass to the CPP. 1.1.1.2 root 61: 1.1.1.3 ! root 62: Do not define this macro if it does not need to do anything. ! 63: ! 64: `SIGNED_CHAR_SPEC' ! 65: A C string constant that tells the GNU CC driver program options to ! 66: pass to CPP. By default, this macro is defined to pass the option ! 67: `-D__CHAR_UNSIGNED__' to CPP if `char' will be treated as ! 68: `unsigned char' by `cc1'. ! 69: ! 70: Do not define this macro unless you need to override the default ! 71: definition. ! 72: ! 73: `CC1_SPEC' ! 74: A C string constant that tells the GNU CC driver program options to ! 75: pass to `cc1'. It can also specify how to translate options you ! 76: give to GNU CC into options for GNU CC to pass to the `cc1'. ! 77: ! 78: Do not define this macro if it does not need to do anything. ! 79: ! 80: `CC1PLUS_SPEC' ! 81: A C string constant that tells the GNU CC driver program options to ! 82: pass to `cc1plus'. It can also specify how to translate options ! 83: you give to GNU CC into options for GNU CC to pass to the ! 84: `cc1plus'. ! 85: ! 86: Do not define this macro if it does not need to do anything. ! 87: ! 88: `ASM_SPEC' ! 89: A C string constant that tells the GNU CC driver program options to ! 90: pass to the assembler. It can also specify how to translate ! 91: options you give to GNU CC into options for GNU CC to pass to the ! 92: assembler. See the file `sun3.h' for an example of this. ! 93: ! 94: Do not define this macro if it does not need to do anything. ! 95: ! 96: `ASM_FINAL_SPEC' ! 97: A C string constant that tells the GNU CC driver program how to ! 98: run any programs which cleanup after the normal assembler. ! 99: Normally, this is not needed. See the file `mips.h' for an ! 100: example of this. ! 101: ! 102: Do not define this macro if it does not need to do anything. ! 103: ! 104: `LINK_SPEC' ! 105: A C string constant that tells the GNU CC driver program options to ! 106: pass to the linker. It can also specify how to translate options ! 107: you give to GNU CC into options for GNU CC to pass to the linker. ! 108: ! 109: Do not define this macro if it does not need to do anything. ! 110: ! 111: `LIB_SPEC' ! 112: Another C string constant used much like `LINK_SPEC'. The ! 113: difference between the two is that `LIB_SPEC' is used at the end ! 114: of the command given to the linker. ! 115: ! 116: If this macro is not defined, a default is provided that loads the ! 117: standard C library from the usual place. See `gcc.c'. ! 118: ! 119: `STARTFILE_SPEC' ! 120: Another C string constant used much like `LINK_SPEC'. The ! 121: difference between the two is that `STARTFILE_SPEC' is used at the ! 122: very beginning of the command given to the linker. ! 123: ! 124: If this macro is not defined, a default is provided that loads the ! 125: standard C startup file from the usual place. See `gcc.c'. ! 126: ! 127: `ENDFILE_SPEC' ! 128: Another C string constant used much like `LINK_SPEC'. The ! 129: difference between the two is that `ENDFILE_SPEC' is used at the ! 130: very end of the command given to the linker. ! 131: ! 132: Do not define this macro if it does not need to do anything. ! 133: ! 134: `LINK_LIBGCC_SPECIAL' ! 135: Define this macro meaning that `gcc' should find the library ! 136: `libgcc.a' by hand, rather than passing the argument `-lgcc' to ! 137: tell the linker to do the search. ! 138: ! 139: `RELATIVE_PREFIX_NOT_LINKDIR' ! 140: Define this macro to tell `gcc' that it should only translate a ! 141: `-B' prefix into a `-L' linker option if the prefix indicates an ! 142: absolute file name. ! 143: ! 144: `STANDARD_EXEC_PREFIX' ! 145: Define this macro as a C string constant if you wish to override ! 146: the standard choice of `/usr/local/lib/gcc-lib/' as the default ! 147: prefix to try when searching for the executable files of the ! 148: compiler. ! 149: ! 150: `MD_EXEC_PREFIX' ! 151: If defined, this macro is an additional prefix to try after ! 152: `STANDARD_EXEC_PREFIX'. `MD_EXEC_PREFIX' is not searched when the ! 153: `-b' option is used, or the compiler is built as a cross compiler. ! 154: ! 155: `STANDARD_STARTFILE_PREFIX' ! 156: Define this macro as a C string constant if you wish to override ! 157: the standard choice of `/usr/local/lib/' as the default prefix to ! 158: try when searching for startup files such as `crt0.o'. ! 159: ! 160: `MD_STARTFILE_PREFIX' ! 161: If defined, this macro supplies an additional prefix to try after ! 162: the standard prefixes. `MD_EXEC_PREFIX' is not searched when the ! 163: `-b' option is used, or when the compiler is built as a cross ! 164: compiler. ! 165: ! 166: `MD_STARTFILE_PREFIX_1' ! 167: If defined, this macro supplies yet another prefix to try after the ! 168: standard prefixes. It is not searched when the `-b' option is ! 169: used, or when the compiler is built as a cross compiler. ! 170: ! 171: `LOCAL_INCLUDE_DIR' ! 172: Define this macro as a C string constant if you wish to override ! 173: the standard choice of `/usr/local/include' as the default prefix ! 174: to try when searching for local header files. `LOCAL_INCLUDE_DIR' ! 175: comes before `SYSTEM_INCLUDE_DIR' in the search order. ! 176: ! 177: Cross compilers do not use this macro and do not search either ! 178: `/usr/local/include' or its replacement. ! 179: ! 180: `SYSTEM_INCLUDE_DIR' ! 181: Define this macro as a C string constant if you wish to specify a ! 182: system-specific directory to search for header files before the ! 183: standard directory. `SYSTEM_INCLUDE_DIR' comes before ! 184: `STANDARD_INCLUDE_DIR' in the search order. ! 185: ! 186: Cross compilers do not use this macro and do not search the ! 187: directory specified. ! 188: ! 189: `STANDARD_INCLUDE_DIR' ! 190: Define this macro as a C string constant if you wish to override ! 191: the standard choice of `/usr/include' as the default prefix to try ! 192: when searching for header files. ! 193: ! 194: Cross compilers do not use this macro and do not search either ! 195: `/usr/include' or its replacement. ! 196: ! 197: `INCLUDE_DEFAULTS' ! 198: Define this macro if you wish to override the entire default ! 199: search path for include files. The default search path includes ! 200: `GPLUSPLUS_INCLUDE_DIR', `GCC_INCLUDE_DIR', `LOCAL_INCLUDE_DIR', ! 201: `SYSTEM_INCLUDE_DIR', and `STANDARD_INCLUDE_DIR'. In addition, ! 202: the macros `GPLUSPLUS_INCLUDE_DIR' and `GCC_INCLUDE_DIR' are ! 203: defined automatically by `Makefile', and specify private search ! 204: areas for GCC. The directory `GPLUSPLUS_INCLUDE_DIR' is used only ! 205: for C++ programs. ! 206: ! 207: The definition should be an initializer for an array of structures. ! 208: Each array element should have two elements: the directory name (a ! 209: string constant) and a flag for C++-only directories. Mark the ! 210: end of the array with a null element. For example, here is the ! 211: definition used for VMS: ! 212: ! 213: #define INCLUDE_DEFAULTS \ ! 214: { \ ! 215: { "GNU_GXX_INCLUDE:", 1}, \ ! 216: { "GNU_CC_INCLUDE:", 0}, \ ! 217: { "SYS$SYSROOT:[SYSLIB.]", 0}, \ ! 218: { ".", 0}, \ ! 219: { 0, 0} \ ! 220: } ! 221: ! 222: Here is the order of prefixes tried for exec files: ! 223: ! 224: 1. Any prefixes specified by the user with `-B'. ! 225: ! 226: 2. The environment variable `GCC_EXEC_PREFIX', if any. 1.1.1.2 root 227: 1.1.1.3 ! root 228: 3. The directories specified by the environment variable ! 229: `COMPILER_PATH'. 1.1.1.2 root 230: 1.1.1.3 ! root 231: 4. The macro `STANDARD_EXEC_PREFIX'. ! 232: ! 233: 5. `/usr/lib/gcc/'. ! 234: ! 235: 6. The macro `MD_EXEC_PREFIX', if any. ! 236: ! 237: Here is the order of prefixes tried for startfiles: ! 238: ! 239: 1. Any prefixes specified by the user with `-B'. ! 240: ! 241: 2. The environment variable `GCC_EXEC_PREFIX', if any. ! 242: ! 243: 3. The directories specified by the environment variable ! 244: `LIBRARY_PATH'. ! 245: ! 246: 4. The macro `STANDARD_EXEC_PREFIX'. ! 247: ! 248: 5. `/usr/lib/gcc/'. ! 249: ! 250: 6. The macro `MD_EXEC_PREFIX', if any. ! 251: ! 252: 7. The macro `MD_STARTFILE_PREFIX', if any. ! 253: ! 254: 8. The macro `STANDARD_STARTFILE_PREFIX'. ! 255: ! 256: 9. `/lib/'. ! 257: ! 258: 10. `/usr/lib/'. 1.1.1.2 root 259: 260: 1.1.1.3 ! root 261: File: gcc.info, Node: Run-time Target, Next: Storage Layout, Prev: Driver, Up: Target Macros ! 262: ! 263: Run-time Target Specification ! 264: ============================= ! 265: ! 266: `CPP_PREDEFINES' ! 267: Define this to be a string constant containing `-D' options to ! 268: define the predefined macros that identify this machine and system. ! 269: These macros will be predefined unless the `-ansi' option is ! 270: specified. 1.1 root 271: 1.1.1.3 ! root 272: In addition, a parallel set of macros are predefined, whose names ! 273: are made by appending `__' at the beginning and at the end. These ! 274: `__' macros are permitted by the ANSI standard, so they are ! 275: predefined regardless of whether `-ansi' is specified. ! 276: ! 277: For example, on the Sun, one can use the following value: ! 278: ! 279: "-Dmc68000 -Dsun -Dunix" ! 280: ! 281: The result is to define the macros `__mc68000__', `__sun__' and ! 282: `__unix__' unconditionally, and the macros `mc68000', `sun' and ! 283: `unix' provided `-ansi' is not specified. ! 284: ! 285: `STDC_VALUE' ! 286: Define the value to be assigned to the built-in macro `__STDC__'. ! 287: The default is the value `1'. ! 288: ! 289: `extern int target_flags;' ! 290: This declaration should be present. ! 291: ! 292: `TARGET_...' ! 293: This series of macros is to allow compiler command arguments to ! 294: enable or disable the use of optional features of the target ! 295: machine. For example, one machine description serves both the ! 296: 68000 and the 68020; a command argument tells the compiler whether ! 297: it should use 68020-only instructions or not. This command ! 298: argument works by means of a macro `TARGET_68020' that tests a bit ! 299: in `target_flags'. ! 300: ! 301: Define a macro `TARGET_FEATURENAME' for each such option. Its ! 302: definition should test a bit in `target_flags'; for example: ! 303: ! 304: #define TARGET_68020 (target_flags & 1) ! 305: ! 306: One place where these macros are used is in the ! 307: condition-expressions of instruction patterns. Note how ! 308: `TARGET_68020' appears frequently in the 68000 machine description ! 309: file, `m68k.md'. Another place they are used is in the definitions ! 310: of the other macros in the `MACHINE.h' file. ! 311: ! 312: `TARGET_SWITCHES' ! 313: This macro defines names of command options to set and clear bits ! 314: in `target_flags'. Its definition is an initializer with a ! 315: subgrouping for each command option. ! 316: ! 317: Each subgrouping contains a string constant, that defines the ! 318: option name, and a number, which contains the bits to set in ! 319: `target_flags'. A negative number says to clear bits instead; the ! 320: negative of the number is which bits to clear. The actual option ! 321: name is made by appending `-m' to the specified name. ! 322: ! 323: One of the subgroupings should have a null string. The number in ! 324: this grouping is the default value for `target_flags'. Any target ! 325: options act starting with that value. ! 326: ! 327: Here is an example which defines `-m68000' and `-m68020' with ! 328: opposite meanings, and picks the latter as the default: ! 329: ! 330: #define TARGET_SWITCHES \ ! 331: { { "68020", 1}, \ ! 332: { "68000", -1}, \ ! 333: { "", 1}} ! 334: ! 335: `TARGET_OPTIONS' ! 336: This macro is similar to `TARGET_SWITCHES' but defines names of ! 337: command options that have values. Its definition is an ! 338: initializer with a subgrouping for each command option. ! 339: ! 340: Each subgrouping contains a string constant, that defines the ! 341: fixed part of the option name, and the address of a variable. The ! 342: variable, type `char *', is set to the variable part of the given ! 343: option if the fixed part matches. The actual option name is made ! 344: by appending `-m' to the specified name. ! 345: ! 346: Here is an example which defines `-mshort-data-NUMBER'. If the ! 347: given option is `-mshort-data-512', the variable `m88k_short_data' ! 348: will be set to the string `"512"'. ! 349: ! 350: extern char *m88k_short_data; ! 351: #define TARGET_OPTIONS { { "short-data-", &m88k_short_data } } ! 352: ! 353: `TARGET_VERSION' ! 354: This macro is a C statement to print on `stderr' a string ! 355: describing the particular machine description choice. Every ! 356: machine description should define `TARGET_VERSION'. For example: ! 357: ! 358: #ifdef MOTOROLA ! 359: #define TARGET_VERSION fprintf (stderr, " (68k, Motorola syntax)"); ! 360: #else ! 361: #define TARGET_VERSION fprintf (stderr, " (68k, MIT syntax)"); ! 362: #endif ! 363: ! 364: `OVERRIDE_OPTIONS' ! 365: Sometimes certain combinations of command options do not make ! 366: sense on a particular target machine. You can define a macro ! 367: `OVERRIDE_OPTIONS' to take account of this. This macro, if ! 368: defined, is executed once just after all the command options have ! 369: been parsed. ! 370: ! 371: Don't use this macro to turn on various extra optimizations for ! 372: `-O'. That is what `OPTIMIZATION_OPTIONS' is for. ! 373: ! 374: `OPTIMIZATION_OPTIONS (LEVEL)' ! 375: Some machines may desire to change what optimizations are ! 376: performed for various optimization levels. This macro, if ! 377: defined, is executed once just after the optimization level is ! 378: determined and before the remainder of the command options have ! 379: been parsed. Values set in this macro are used as the default ! 380: values for the other command line options. 1.1 root 381: 1.1.1.3 ! root 382: LEVEL is the optimization level specified; 2 if -O2 is specified, ! 383: 1 if -O is specified, and 0 if neither is specified. 1.1 root 384: 1.1.1.3 ! root 385: *Do not examine `write_symbols' in this macro!* The debugging ! 386: options are not supposed to alter the generated code. 1.1 root 387: 388: 1.1.1.3 ! root 389: File: gcc.info, Node: Storage Layout, Next: Type Layout, Prev: Run-time Target, Up: Target Macros 1.1 root 390: 1.1.1.3 ! root 391: Storage Layout ! 392: ============== 1.1 root 393: 1.1.1.3 ! root 394: Note that the definitions of the macros in this table which are ! 395: sizes or alignments measured in bits do not need to be constant. They ! 396: can be C expressions that refer to static variables, such as the ! 397: `target_flags'. *Note Run-time Target::. ! 398: ! 399: `BITS_BIG_ENDIAN' ! 400: Define this macro to be the value 1 if the most significant bit in ! 401: a byte has the lowest number; otherwise define it to be the value ! 402: zero. This means that bit-field instructions count from the most ! 403: significant bit. If the machine has no bit-field instructions, ! 404: this macro is irrelevant. ! 405: ! 406: This macro does not affect the way structure fields are packed into ! 407: bytes or words; that is controlled by `BYTES_BIG_ENDIAN'. ! 408: ! 409: `BYTES_BIG_ENDIAN' ! 410: Define this macro to be 1 if the most significant byte in a word ! 411: has the lowest number. ! 412: ! 413: `WORDS_BIG_ENDIAN' ! 414: Define this macro to be 1 if, in a multiword object, the most ! 415: significant word has the lowest number. ! 416: ! 417: `BITS_PER_UNIT' ! 418: Number of bits in an addressable storage unit (byte); normally 8. ! 419: ! 420: `BITS_PER_WORD' ! 421: Number of bits in a word; normally 32. ! 422: ! 423: `MAX_BITS_PER_WORD' ! 424: Maximum number of bits in a word. If this is undefined, the ! 425: default is `BITS_PER_WORD'. Otherwise, it is the constant value ! 426: that is the largest value that `BITS_PER_WORD' can have at ! 427: run-time. ! 428: ! 429: `UNITS_PER_WORD' ! 430: Number of storage units in a word; normally 4. ! 431: ! 432: `POINTER_SIZE' ! 433: Width of a pointer, in bits. ! 434: ! 435: `PARM_BOUNDARY' ! 436: Normal alignment required for function parameters on the stack, in ! 437: bits. All stack parameters receive least this much alignment ! 438: regardless of data type. On most machines, this is the same as the ! 439: size of an integer. ! 440: ! 441: `STACK_BOUNDARY' ! 442: Define this macro if you wish to preserve a certain alignment for ! 443: the stack pointer. The definition is a C expression for the ! 444: desired alignment (measured in bits). ! 445: ! 446: If `PUSH_ROUNDING' is not defined, the stack will always be aligned ! 447: to the specified boundary. If `PUSH_ROUNDING' is defined and ! 448: specifies a less strict alignment than `STACK_BOUNDARY', the stack ! 449: may be momentarily unaligned while pushing arguments. ! 450: ! 451: `FUNCTION_BOUNDARY' ! 452: Alignment required for a function entry point, in bits. ! 453: ! 454: `BIGGEST_ALIGNMENT' ! 455: Biggest alignment that any data type can require on this machine, ! 456: in bits. ! 457: ! 458: `BIGGEST_FIELD_ALIGNMENT' ! 459: Biggest alignment that any structure field can require on this ! 460: machine, in bits. If defined, this overrides `BIGGEST_ALIGNMENT' ! 461: for structure fields only. ! 462: ! 463: `MAX_OFILE_ALIGNMENT' ! 464: Biggest alignment supported by the object file format of this ! 465: machine. Use this macro to limit the alignment which can be ! 466: specified using the `__attribute__ ((aligned (N)))' construct. If ! 467: not defined, the default value is `BIGGEST_ALIGNMENT'. ! 468: ! 469: `DATA_ALIGNMENT (TYPE, BASIC-ALIGN)' ! 470: If defined, a C expression to compute the alignment for a static ! 471: variable. TYPE is the data type, and BASIC-ALIGN is the alignment ! 472: that the object would ordinarily have. The value of this macro is ! 473: used instead of that alignment to align the object. ! 474: ! 475: If this macro is not defined, then BASIC-ALIGN is used. ! 476: ! 477: One use of this macro is to increase alignment of medium-size data ! 478: to make it all fit in fewer cache lines. Another is to cause ! 479: character arrays to be word-aligned so that `strcpy' calls that ! 480: copy constants to character arrays can be done inline. ! 481: ! 482: `CONSTANT_ALIGNMENT (CONSTANT, BASIC-ALIGN)' ! 483: If defined, a C expression to compute the alignment given to a ! 484: constant that is being placed in memory. CONSTANT is the constant ! 485: and BASIC-ALIGN is the alignment that the object would ordinarily ! 486: have. The value of this macro is used instead of that alignment to ! 487: align the object. ! 488: ! 489: If this macro is not defined, then BASIC-ALIGN is used. ! 490: ! 491: The typical use of this macro is to increase alignment for string ! 492: constants to be word aligned so that `strcpy' calls that copy ! 493: constants can be done inline. ! 494: ! 495: `EMPTY_FIELD_BOUNDARY' ! 496: Alignment in bits to be given to a structure bit field that ! 497: follows an empty field such as `int : 0;'. ! 498: ! 499: Note that `PCC_BITFIELD_TYPE_MATTERS' also affects the alignment ! 500: that results from an empty field. ! 501: ! 502: `STRUCTURE_SIZE_BOUNDARY' ! 503: Number of bits which any structure or union's size must be a ! 504: multiple of. Each structure or union's size is rounded up to a ! 505: multiple of this. ! 506: ! 507: If you do not define this macro, the default is the same as ! 508: `BITS_PER_UNIT'. ! 509: ! 510: `STRICT_ALIGNMENT' ! 511: Define this macro to be the value 1 if instructions will fail to ! 512: work if given data not on the nominal alignment. If instructions ! 513: will merely go slower in that case, define this macro as 0. ! 514: ! 515: `PCC_BITFIELD_TYPE_MATTERS' ! 516: Define this if you wish to imitate the way many other C compilers ! 517: handle alignment of bitfields and the structures that contain them. ! 518: ! 519: The behavior is that the type written for a bitfield (`int', ! 520: `short', or other integer type) imposes an alignment for the ! 521: entire structure, as if the structure really did contain an ! 522: ordinary field of that type. In addition, the bitfield is placed ! 523: within the structure so that it would fit within such a field, not ! 524: crossing a boundary for it. ! 525: ! 526: Thus, on most machines, a bitfield whose type is written as `int' ! 527: would not cross a four-byte boundary, and would force four-byte ! 528: alignment for the whole structure. (The alignment used may not be ! 529: four bytes; it is controlled by the other alignment parameters.) ! 530: ! 531: If the macro is defined, its definition should be a C expression; ! 532: a nonzero value for the expression enables this behavior. ! 533: ! 534: Note that if this macro is not defined, or its value is zero, some ! 535: bitfields may cross more than one alignment boundary. The ! 536: compiler can support such references if there are `insv', `extv', ! 537: and `extzv' insns that can directly reference memory. ! 538: ! 539: The other known way of making bitfields work is to define ! 540: `STRUCTURE_SIZE_BOUNDARY' as large as `BIGGEST_ALIGNMENT'. Then ! 541: every structure can be accessed with fullwords. ! 542: ! 543: Unless the machine has bitfield instructions or you define ! 544: `STRUCTURE_SIZE_BOUNDARY' that way, you must define ! 545: `PCC_BITFIELD_TYPE_MATTERS' to have a nonzero value. ! 546: ! 547: `BITFIELD_NBYTES_LIMITED' ! 548: Like PCC_BITFIELD_TYPE_MATTERS except that its effect is limited to ! 549: aligning a bitfield within the structure. ! 550: ! 551: `ROUND_TYPE_SIZE (STRUCT, SIZE, ALIGN)' ! 552: Define this macro as an expression for the overall size of a ! 553: structure (given by STRUCT as a tree node) when the size computed ! 554: from the fields is SIZE and the alignment is ALIGN. ! 555: ! 556: The default is to round SIZE up to a multiple of ALIGN. ! 557: ! 558: `ROUND_TYPE_ALIGN (STRUCT, COMPUTED, SPECIFIED)' ! 559: Define this macro as an expression for the alignment of a structure ! 560: (given by STRUCT as a tree node) if the alignment computed in the ! 561: usual way is COMPUTED and the alignment explicitly specified was ! 562: SPECIFIED. ! 563: ! 564: The default is to use SPECIFIED if it is larger; otherwise, use ! 565: the smaller of COMPUTED and `BIGGEST_ALIGNMENT' ! 566: ! 567: `MAX_FIXED_MODE_SIZE' ! 568: An integer expression for the size in bits of the largest integer ! 569: machine mode that should actually be used. All integer machine ! 570: modes of this size or smaller can be used for structures and ! 571: unions with the appropriate sizes. If this macro is undefined, ! 572: `GET_MODE_BITSIZE (DImode)' is assumed. ! 573: ! 574: `CHECK_FLOAT_VALUE (MODE, VALUE)' ! 575: A C statement to validate the value VALUE (of type `double') for ! 576: mode MODE. This means that you check whether VALUE fits within ! 577: the possible range of values for mode MODE on this target machine. ! 578: The mode MODE is always `SFmode' or `DFmode'. ! 579: ! 580: If VALUE is not valid, you should call `error' to print an error ! 581: message and then assign some valid value to VALUE. Allowing an ! 582: invalid value to go through the compiler can produce incorrect ! 583: assembler code which may even cause Unix assemblers to crash. ! 584: ! 585: This macro need not be defined if there is no work for it to do. ! 586: ! 587: `TARGET_FLOAT_FORMAT' ! 588: A code distinguishing the floating point format of the target ! 589: machine. There are three defined values: ! 590: ! 591: `IEEE_FLOAT_FORMAT' ! 592: This code indicates IEEE floating point. It is the default; ! 593: there is no need to define this macro when the format is IEEE. ! 594: ! 595: `VAX_FLOAT_FORMAT' ! 596: This code indicates the peculiar format used on the Vax. ! 597: ! 598: `UNKNOWN_FLOAT_FORMAT' ! 599: This code indicates any other format. ! 600: ! 601: The value of this macro is compared with `HOST_FLOAT_FORMAT' ! 602: (*note Config::.) to determine whether the target machine has the ! 603: same format as the host machine. If any other formats are ! 604: actually in use on supported machines, new codes should be defined ! 605: for them. ! 606: ! 607: ! 608: File: gcc.info, Node: Type Layout, Next: Registers, Prev: Storage Layout, Up: Target Macros ! 609: ! 610: Layout of Source Language Data Types ! 611: ==================================== ! 612: ! 613: These macros define the sizes and other characteristics of the ! 614: standard basic data types used in programs being compiled. Unlike the ! 615: macros in the previous section, these apply to specific features of C ! 616: and related languages, rather than to fundamental aspects of storage ! 617: layout. ! 618: ! 619: `INT_TYPE_SIZE' ! 620: A C expression for the size in bits of the type `int' on the ! 621: target machine. If you don't define this, the default is one word. ! 622: ! 623: `SHORT_TYPE_SIZE' ! 624: A C expression for the size in bits of the type `short' on the ! 625: target machine. If you don't define this, the default is half a ! 626: word. (If this would be less than one storage unit, it is rounded ! 627: up to one unit.) ! 628: ! 629: `LONG_TYPE_SIZE' ! 630: A C expression for the size in bits of the type `long' on the ! 631: target machine. If you don't define this, the default is one word. ! 632: ! 633: `LONG_LONG_TYPE_SIZE' ! 634: A C expression for the size in bits of the type `long long' on the ! 635: target machine. If you don't define this, the default is two ! 636: words. ! 637: ! 638: `CHAR_TYPE_SIZE' ! 639: A C expression for the size in bits of the type `char' on the ! 640: target machine. If you don't define this, the default is one ! 641: quarter of a word. (If this would be less than one storage unit, ! 642: it is rounded up to one unit.) ! 643: ! 644: `FLOAT_TYPE_SIZE' ! 645: A C expression for the size in bits of the type `float' on the ! 646: target machine. If you don't define this, the default is one word. ! 647: ! 648: `DOUBLE_TYPE_SIZE' ! 649: A C expression for the size in bits of the type `double' on the ! 650: target machine. If you don't define this, the default is two ! 651: words. ! 652: ! 653: `LONG_DOUBLE_TYPE_SIZE' ! 654: A C expression for the size in bits of the type `long double' on ! 655: the target machine. If you don't define this, the default is two ! 656: words. ! 657: ! 658: `DEFAULT_SIGNED_CHAR' ! 659: An expression whose value is 1 or 0, according to whether the type ! 660: `char' should be signed or unsigned by default. The user can ! 661: always override this default with the options `-fsigned-char' and ! 662: `-funsigned-char'. ! 663: ! 664: `DEFAULT_SHORT_ENUMS' ! 665: A C expression to determine whether to give an `enum' type only as ! 666: many bytes as it takes to represent the range of possible values ! 667: of that type. A nonzero value means to do that; a zero value ! 668: means all `enum' types should be allocated like `int'. ! 669: ! 670: If you don't define the macro, the default is 0. ! 671: ! 672: `SIZE_TYPE' ! 673: A C expression for a string describing the name of the data type ! 674: to use for size values. The typedef name `size_t' is defined ! 675: using the contents of the string. ! 676: ! 677: The string can contain more than one keyword. If so, separate ! 678: them with spaces, and write first any length keyword, then ! 679: `unsigned' if appropriate, and finally `int'. The string must ! 680: exactly match one of the data type names defined in the function ! 681: `init_decl_processing' in the file `c-decl.c'. You may not omit ! 682: `int' or change the order--that would cause the compiler to crash ! 683: on startup. ! 684: ! 685: If you don't define this macro, the default is `"long unsigned ! 686: int"'. ! 687: ! 688: `PTRDIFF_TYPE' ! 689: A C expression for a string describing the name of the data type ! 690: to use for the result of subtracting two pointers. The typedef ! 691: name `ptrdiff_t' is defined using the contents of the string. See ! 692: `SIZE_TYPE' above for more information. ! 693: ! 694: If you don't define this macro, the default is `"long int"'. ! 695: ! 696: `WCHAR_TYPE' ! 697: A C expression for a string describing the name of the data type ! 698: to use for wide characters. The typedef name `wchar_t' is defined ! 699: using the contents of the string. See `SIZE_TYPE' above for more 1.1 root 700: information. 701: 1.1.1.3 ! root 702: If you don't define this macro, the default is `"int"'. 1.1 root 703: 1.1.1.3 ! root 704: `WCHAR_TYPE_SIZE' ! 705: A C expression for the size in bits of the data type for wide ! 706: characters. This is used in `cpp', which cannot make use of ! 707: `WCHAR_TYPE'. ! 708: ! 709: `OBJC_INT_SELECTORS' ! 710: Define this macro if the type of Objective C selectors should be ! 711: `int'. ! 712: ! 713: If this macro is not defined, then selectors should have the type ! 714: `struct objc_selector *'. ! 715: ! 716: `OBJC_SELECTORS_WITHOUT_LABELS' ! 717: Define this macro if the compiler can group all the selectors ! 718: together into a vector and use just one label at the beginning of ! 719: the vector. Otherwise, the compiler must give each selector its ! 720: own assembler label. ! 721: ! 722: On certain machines, it is important to have a separate label for ! 723: each selector because this enables the linker to eliminate ! 724: duplicate selectors. ! 725: ! 726: `TARGET_BELL' ! 727: A C constant expression for the integer value for escape sequence ! 728: `\a'. ! 729: ! 730: `TARGET_BS' ! 731: `TARGET_TAB' ! 732: `TARGET_NEWLINE' ! 733: C constant expressions for the integer values for escape sequences ! 734: `\b', `\t' and `\n'. ! 735: ! 736: `TARGET_VT' ! 737: `TARGET_FF' ! 738: `TARGET_CR' ! 739: C constant expressions for the integer values for escape sequences ! 740: `\v', `\f' and `\r'. 1.1 root 741: 742: 1.1.1.3 ! root 743: File: gcc.info, Node: Registers, Next: Register Classes, Prev: Type Layout, Up: Target Macros 1.1 root 744: 1.1.1.3 ! root 745: Register Usage ! 746: ============== 1.1 root 747: 1.1.1.3 ! root 748: This section explains how to describe what registers the target ! 749: machine has, and how (in general) they can be used. 1.1 root 750: 1.1.1.3 ! root 751: The description of which registers a specific instruction can use is ! 752: done with register classes; see *Note Register Classes::. For ! 753: information on using registers to access a stack frame, see *Note Frame ! 754: Registers::. For passing values in registers, see *Note Register ! 755: Arguments::. For returning values in registers, see *Note Scalar ! 756: Return::. ! 757: ! 758: * Menu: ! 759: ! 760: * Register Basics:: Number and kinds of registers. ! 761: * Allocation Order:: Order in which registers are allocated. ! 762: * Values in Registers:: What kinds of values each reg can hold. ! 763: * Leaf Functions:: Renumbering registers for leaf functions. ! 764: * Stack Registers:: Handling a register stack such as 80387. ! 765: * Obsolete Register Macros:: Macros formerly used for the 80387. 1.1 root 766: 767: 1.1.1.3 ! root 768: File: gcc.info, Node: Register Basics, Next: Allocation Order, Up: Registers 1.1 root 769: 1.1.1.3 ! root 770: Basic Characteristics of Registers ! 771: ---------------------------------- 1.1 root 772: 1.1.1.3 ! root 773: `FIRST_PSEUDO_REGISTER' ! 774: Number of hardware registers known to the compiler. They receive ! 775: numbers 0 through `FIRST_PSEUDO_REGISTER-1'; thus, the first ! 776: pseudo register's number really is assigned the number ! 777: `FIRST_PSEUDO_REGISTER'. ! 778: ! 779: `FIXED_REGISTERS' ! 780: An initializer that says which registers are used for fixed ! 781: purposes all throughout the compiled code and are therefore not ! 782: available for general allocation. These would include the stack ! 783: pointer, the frame pointer (except on machines where that can be ! 784: used as a general register when no frame pointer is needed), the ! 785: program counter on machines where that is considered one of the ! 786: addressable registers, and any other numbered register with a ! 787: standard use. ! 788: ! 789: This information is expressed as a sequence of numbers, separated ! 790: by commas and surrounded by braces. The Nth number is 1 if ! 791: register N is fixed, 0 otherwise. ! 792: ! 793: The table initialized from this macro, and the table initialized by ! 794: the following one, may be overridden at run time either ! 795: automatically, by the actions of the macro ! 796: `CONDITIONAL_REGISTER_USAGE', or by the user with the command ! 797: options `-ffixed-REG', `-fcall-used-REG' and `-fcall-saved-REG'. ! 798: ! 799: `CALL_USED_REGISTERS' ! 800: Like `FIXED_REGISTERS' but has 1 for each register that is ! 801: clobbered (in general) by function calls as well as for fixed ! 802: registers. This macro therefore identifies the registers that are ! 803: not available for general allocation of values that must live ! 804: across function calls. ! 805: ! 806: If a register has 0 in `CALL_USED_REGISTERS', the compiler ! 807: automatically saves it on function entry and restores it on ! 808: function exit, if the register is used within the function. ! 809: ! 810: `CONDITIONAL_REGISTER_USAGE' ! 811: Zero or more C statements that may conditionally modify two ! 812: variables `fixed_regs' and `call_used_regs' (both of type `char ! 813: []') after they have been initialized from the two preceding ! 814: macros. ! 815: ! 816: This is necessary in case the fixed or call-clobbered registers ! 817: depend on target flags. ! 818: ! 819: You need not define this macro if it has no work to do. ! 820: ! 821: If the usage of an entire class of registers depends on the target ! 822: flags, you may indicate this to GCC by using this macro to modify ! 823: `fixed_regs' and `call_used_regs' to 1 for each of the registers ! 824: in the classes which should not be used by GCC. Also define the ! 825: macro `REG_CLASS_FROM_LETTER' to return `NO_REGS' if it is called ! 826: with a letter for a class that shouldn't be used. ! 827: ! 828: (However, if this class is not included in `GENERAL_REGS' and all ! 829: of the insn patterns whose constraints permit this class are ! 830: controlled by target switches, then GCC will automatically avoid ! 831: using these registers when the target switches are opposed to ! 832: them.) ! 833: ! 834: `NON_SAVING_SETJMP' ! 835: If this macro is defined and has a nonzero value, it means that ! 836: `setjmp' and related functions fail to save the registers, or that ! 837: `longjmp' fails to restore them. To compensate, the compiler ! 838: avoids putting variables in registers in functions that use ! 839: `setjmp'. ! 840: ! 841: ! 842: File: gcc.info, Node: Allocation Order, Next: Values in Registers, Prev: Register Basics, Up: Registers ! 843: ! 844: Order of Allocation of Registers ! 845: -------------------------------- ! 846: ! 847: `REG_ALLOC_ORDER' ! 848: If defined, an initializer for a vector of integers, containing the ! 849: numbers of hard registers in the order in which GNU CC should ! 850: prefer to use them (from most preferred to least). ! 851: ! 852: If this macro is not defined, registers are used lowest numbered ! 853: first (all else being equal). ! 854: ! 855: One use of this macro is on machines where the highest numbered ! 856: registers must always be saved and the save-multiple-registers ! 857: instruction supports only sequences of consecutive registers. On ! 858: such machines, define `REG_ALLOC_ORDER' to be an initializer that ! 859: lists the highest numbered allocatable register first. ! 860: ! 861: `ORDER_REGS_FOR_LOCAL_ALLOC' ! 862: A C statement (sans semicolon) to choose the order in which to ! 863: allocate hard registers for pseudo-registers local to a basic ! 864: block. ! 865: ! 866: Store the desired order of registers in the array ! 867: `reg_alloc_order'. Element 0 should be the register to allocate ! 868: first; element 1, the next register; and so on. ! 869: ! 870: The macro body should not assume anything about the contents of ! 871: `reg_alloc_order' before execution of the macro. 1.1 root 872: 1.1.1.3 ! root 873: On most machines, it is not necessary to define this macro. 1.1 root 874: 875: 1.1.1.3 ! root 876: File: gcc.info, Node: Values in Registers, Next: Leaf Functions, Prev: Allocation Order, Up: Registers 1.1 root 877: 1.1.1.3 ! root 878: How Values Fit in Registers ! 879: --------------------------- 1.1 root 880: 1.1.1.3 ! root 881: This section discusses the macros that describe which kinds of values ! 882: (specifically, which machine modes) each register can hold, and how many ! 883: consecutive registers are needed for a given mode. ! 884: ! 885: `HARD_REGNO_NREGS (REGNO, MODE)' ! 886: A C expression for the number of consecutive hard registers, ! 887: starting at register number REGNO, required to hold a value of mode ! 888: MODE. ! 889: ! 890: On a machine where all registers are exactly one word, a suitable ! 891: definition of this macro is ! 892: ! 893: #define HARD_REGNO_NREGS(REGNO, MODE) \ ! 894: ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) \ ! 895: / UNITS_PER_WORD)) ! 896: ! 897: `HARD_REGNO_MODE_OK (REGNO, MODE)' ! 898: A C expression that is nonzero if it is permissible to store a ! 899: value of mode MODE in hard register number REGNO (or in several ! 900: registers starting with that one). For a machine where all ! 901: registers are equivalent, a suitable definition is ! 902: ! 903: #define HARD_REGNO_MODE_OK(REGNO, MODE) 1 ! 904: ! 905: It is not necessary for this macro to check for the numbers of ! 906: fixed registers, because the allocation mechanism considers them ! 907: to be always occupied. ! 908: ! 909: On some machines, double-precision values must be kept in even/odd ! 910: register pairs. The way to implement that is to define this macro ! 911: to reject odd register numbers for such modes. ! 912: ! 913: The minimum requirement for a mode to be OK in a register is that ! 914: the `movMODE' instruction pattern support moves between the ! 915: register and any other hard register for which the mode is OK; and ! 916: that moving a value into the register and back out not alter it. ! 917: ! 918: Since the same instruction used to move `SImode' will work for all ! 919: narrower integer modes, it is not necessary on any machine for ! 920: `HARD_REGNO_MODE_OK' to distinguish between these modes, provided ! 921: you define patterns `movhi', etc., to take advantage of this. This ! 922: is useful because of the interaction between `HARD_REGNO_MODE_OK' ! 923: and `MODES_TIEABLE_P'; it is very desirable for all integer modes ! 924: to be tieable. ! 925: ! 926: Many machines have special registers for floating point arithmetic. ! 927: Often people assume that floating point machine modes are allowed ! 928: only in floating point registers. This is not true. Any ! 929: registers that can hold integers can safely *hold* a floating ! 930: point machine mode, whether or not floating arithmetic can be done ! 931: on it in those registers. Integer move instructions can be used ! 932: to move the values. ! 933: ! 934: On some machines, though, the converse is true: fixed-point machine ! 935: modes may not go in floating registers. This is true if the ! 936: floating registers normalize any value stored in them, because ! 937: storing a non-floating value there would garble it. In this case, ! 938: `HARD_REGNO_MODE_OK' should reject fixed-point machine modes in ! 939: floating registers. But if the floating registers do not ! 940: automatically normalize, if you can store any bit pattern in one ! 941: and retrieve it unchanged without a trap, then any machine mode ! 942: may go in a floating register, so you can define this macro to say ! 943: so. ! 944: ! 945: On some machines, such as the Sparc and the Mips, we get better ! 946: code by defining `HARD_REGNO_MODE_OK' to forbid integers in ! 947: floating registers, even though the hardware is capable of ! 948: handling them. This is because transferring values between ! 949: floating registers and general registers is so slow that it is ! 950: better to keep the integer in memory. ! 951: ! 952: The primary significance of special floating registers is rather ! 953: that they are the registers acceptable in floating point arithmetic ! 954: instructions. However, this is of no concern to ! 955: `HARD_REGNO_MODE_OK'. You handle it by writing the proper ! 956: constraints for those instructions. ! 957: ! 958: On some machines, the floating registers are especially slow to ! 959: access, so that it is better to store a value in a stack frame ! 960: than in such a register if floating point arithmetic is not being ! 961: done. As long as the floating registers are not in class ! 962: `GENERAL_REGS', they will not be used unless some pattern's ! 963: constraint asks for one. ! 964: ! 965: `MODES_TIEABLE_P (MODE1, MODE2)' ! 966: A C expression that is nonzero if it is desirable to choose ! 967: register allocation so as to avoid move instructions between a ! 968: value of mode MODE1 and a value of mode MODE2. ! 969: ! 970: If `HARD_REGNO_MODE_OK (R, MODE1)' and `HARD_REGNO_MODE_OK (R, ! 971: MODE2)' are ever different for any R, then `MODES_TIEABLE_P (MODE1, ! 972: MODE2)' must be zero. 1.1 root 973: 1.1.1.3 ! root 974: ! 975: File: gcc.info, Node: Leaf Functions, Next: Stack Registers, Prev: Values in Registers, Up: Registers ! 976: ! 977: Handling Leaf Functions ! 978: ----------------------- ! 979: ! 980: On some machines, a leaf function (i.e., one which make no calls) ! 981: can run more efficiently if it does not make its own register window. ! 982: Often this means it is required to receive its arguments in the ! 983: registers where they are passed by the caller, instead of the registers ! 984: where they would normally arrive. ! 985: ! 986: The special treatment for leaf functions generally applies only when ! 987: other conditions are met; for example, often they may use only those ! 988: registers for its own variables and temporaries. We use the term "leaf ! 989: function" to mean a function that is suitable for this special ! 990: handling, so that functions with no calls are not necessarily "leaf ! 991: functions". ! 992: ! 993: GNU CC assigns register numbers before it knows whether the function ! 994: is suitable for leaf function treatment. So it needs to renumber the ! 995: registers in order to output a leaf function. The following macros ! 996: accomplish this. ! 997: ! 998: `LEAF_REGISTERS' ! 999: A C initializer for a vector, indexed by hard register number, ! 1000: which contains 1 for a register that is allowable in a candidate ! 1001: for leaf function treatment. ! 1002: ! 1003: If leaf function treatment involves renumbering the registers, ! 1004: then the registers marked here should be the ones before ! 1005: renumbering--those that GNU CC would ordinarily allocate. The ! 1006: registers which will actually be used in the assembler code, after ! 1007: renumbering, should not be marked with 1 in this vector. ! 1008: ! 1009: Define this macro only if the target machine offers a way to ! 1010: optimize the treatment of leaf functions. ! 1011: ! 1012: `LEAF_REG_REMAP (REGNO)' ! 1013: A C expression whose value is the register number to which REGNO ! 1014: should be renumbered, when a function is treated as a leaf ! 1015: function. ! 1016: ! 1017: If REGNO is a register number which should not appear in a leaf ! 1018: function before renumbering, then the expression should yield -1, ! 1019: which will cause the compiler to abort. ! 1020: ! 1021: Define this macro only if the target machine offers a way to ! 1022: optimize the treatment of leaf functions, and registers need to be ! 1023: renumbered to do this. ! 1024: ! 1025: `REG_LEAF_ALLOC_ORDER' ! 1026: If defined, an initializer for a vector of integers, containing the ! 1027: numbers of hard registers in the order in which the GNU CC should ! 1028: prefer to use them (from most preferred to least) in a leaf ! 1029: function. If this macro is not defined, REG_ALLOC_ORDER is used ! 1030: for both non-leaf and leaf-functions. ! 1031: ! 1032: Normally, it is necessary for `FUNCTION_PROLOGUE' and ! 1033: `FUNCTION_EPILOGUE' to treat leaf functions specially. It can test the ! 1034: C variable `leaf_function' which is nonzero for leaf functions. (The ! 1035: variable `leaf_function' is defined only if `LEAF_REGISTERS' is ! 1036: defined.) 1.1 root 1037: 1038: 1.1.1.3 ! root 1039: File: gcc.info, Node: Stack Registers, Next: Obsolete Register Macros, Prev: Leaf Functions, Up: Registers 1.1 root 1040: 1.1.1.3 ! root 1041: Registers That Form a Stack ! 1042: --------------------------- 1.1 root 1043: 1.1.1.3 ! root 1044: There are special features to handle computers where some of the ! 1045: "registers" form a stack, as in the 80387 coprocessor for the 80386. ! 1046: Stack registers are normally written by pushing onto the stack, and are ! 1047: numbered relative to the top of the stack. ! 1048: ! 1049: Currently, GNU CC can only handle one group of stack-like registers, ! 1050: and they must be consecutively numbered. ! 1051: ! 1052: `STACK_REGS' ! 1053: Define this if the machine has any stack-like registers. 1.1 root 1054: 1.1.1.3 ! root 1055: `FIRST_STACK_REG' ! 1056: The number of the first stack-like register. This one is the top ! 1057: of the stack. ! 1058: ! 1059: `LAST_STACK_REG' ! 1060: The number of the last stack-like register. This one is the ! 1061: bottom of the stack. 1.1 root 1062: 1063: 1.1.1.3 ! root 1064: File: gcc.info, Node: Obsolete Register Macros, Prev: Stack Registers, Up: Registers 1.1 root 1065: 1.1.1.3 ! root 1066: Obsolete Macros for Controlling Register Usage ! 1067: ---------------------------------------------- 1.1 root 1068: 1.1.1.3 ! root 1069: These features do not work very well. They exist because they used ! 1070: to be required to generate correct code for the 80387 coprocessor of the ! 1071: 80386. They are no longer used by that machine description and may be ! 1072: removed in a later version of the compiler. Don't use them! ! 1073: ! 1074: `OVERLAPPING_REGNO_P (REGNO)' ! 1075: If defined, this is a C expression whose value is nonzero if hard ! 1076: register number REGNO is an overlapping register. This means a ! 1077: hard register which overlaps a hard register with a different ! 1078: number. (Such overlap is undesirable, but occasionally it allows a ! 1079: machine to be supported which otherwise could not be.) This macro ! 1080: must return nonzero for *all* the registers which overlap each ! 1081: other. GNU CC can use an overlapping register only in certain ! 1082: limited ways. It can be used for allocation within a basic block, ! 1083: and may be spilled for reloading; that is all. ! 1084: ! 1085: If this macro is not defined, it means that none of the hard ! 1086: registers overlap each other. This is the usual situation. ! 1087: ! 1088: `INSN_CLOBBERS_REGNO_P (INSN, REGNO)' ! 1089: If defined, this is a C expression whose value should be nonzero if ! 1090: the insn INSN has the effect of mysteriously clobbering the ! 1091: contents of hard register number REGNO. By "mysterious" we mean ! 1092: that the insn's RTL expression doesn't describe such an effect. ! 1093: ! 1094: If this macro is not defined, it means that no insn clobbers ! 1095: registers mysteriously. This is the usual situation; all else ! 1096: being equal, it is best for the RTL expression to show all the ! 1097: activity. ! 1098: ! 1099: `PRESERVE_DEATH_INFO_REGNO_P (REGNO)' ! 1100: If defined, this is a C expression whose value is nonzero if ! 1101: accurate `REG_DEAD' notes are needed for hard register number REGNO ! 1102: at the time of outputting the assembler code. When this is so, a ! 1103: few optimizations that take place after register allocation and ! 1104: could invalidate the death notes are not done when this register is ! 1105: involved. ! 1106: ! 1107: You would arrange to preserve death info for a register when some ! 1108: of the code in the machine description which is executed to write ! 1109: the assembler code looks at the death notes. This is necessary ! 1110: only when the actual hardware feature which GNU CC thinks of as a ! 1111: register is not actually a register of the usual sort. (It might, ! 1112: for example, be a hardware stack.) 1.1 root 1113: 1.1.1.3 ! root 1114: If this macro is not defined, it means that no death notes need to ! 1115: be preserved. This is the usual situation. 1.1 root 1116: 1117:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.