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