Return to gcc.info-12 CVS log

Up to [GCC 2.x] / gcc

Annotation of gcc/gcc.info-12, revision 1.1.1.2

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

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.