Otherware/Otherware_1_SB_Development.iso/amiga/programm/language/gcc222.lha/info/gcc.info-17

GNU Info File | 1992-07-19 | 34KB | 634 lines

This is Info file gcc.info, produced by Makeinfo-1.47 from the input
file gcc.texi.
   This file documents the use and the internals of the GNU compiler.
   Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc.
   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.
   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided also
that the sections entitled "GNU General Public License" and "Boycott"
are included exactly as in the original, and provided that the entire
resulting derived work is distributed under the terms of a permission
notice identical to this one.
   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that the sections entitled "GNU General Public
License" and "Boycott", and this permission notice, may be included in
translations approved by the Free Software Foundation instead of in the
original English.
File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
Specific Options for DBX Output
-------------------------------
`DBX_DEBUGGING_INFO'
     Define this macro if GNU CC should produce debugging output for DBX
     in response to the `-g' option.
`XCOFF_DEBUGGING_INFO'
     Define this macro if GNU CC should produce XCOFF format debugging
     output in response to the `-g' option.  This is a variant of DBX
     format.
`DEFAULT_GDB_EXTENSIONS'
     Define this macro to control whether GNU CC should by default
     generate GDB's extended version of DBX debugging information
     (assuming DBX-format debugging information is enabled at all).  If
     you don't define the macro, the default is 1: always generate the
     extended information if there is any occasion to.
`DEBUG_SYMS_TEXT'
     Define this macro if all `.stabs' commands should be output while
     in the text section.
`ASM_STABS_OP'
     A C string constant naming the assembler pseudo op to use instead
     of `.stabs' to define an ordinary debugging symbol.  If you don't
     define this macro, `.stabs' is used.  This macro applies only to
     DBX debugging information format.
`ASM_STABD_OP'
     A C string constant naming the assembler pseudo op to use instead
     of `.stabd' to define a debugging symbol whose value is the current
     location.  If you don't define this macro, `.stabd' is used. This
     macro applies only to DBX debugging information format.
`ASM_STABN_OP'
     A C string constant naming the assembler pseudo op to use instead
     of `.stabn' to define a debugging symbol with no name.  If you
     don't define this macro, `.stabn' is used.  This macro applies
     only to DBX debugging information format.
`DBX_NO_XREFS'
     Define this macro if DBX on your system does not support the
     construct `xsTAGNAME'.  On some systems, this construct is used to
     describe a forward reference to a structure named TAGNAME. On
     other systems, this construct is not supported at all.
`DBX_CONTIN_LENGTH'
     A symbol name in DBX-format debugging information is normally
     continued (split into two separate `.stabs' directives) when it
     exceeds a certain length (by default, 80 characters).  On some
     operating systems, DBX requires this splitting; on others,
     splitting must not be done.  You can inhibit splitting by defining
     this macro with the value zero.  You can override the default
     splitting-length by defining this macro as an expression for the
     length you desire.
`DBX_CONTIN_CHAR'
     Normally continuation is indicated by adding a `\' character to
     the end of a `.stabs' string when a continuation follows.  To use
     a different character instead, define this macro as a character
     constant for the character you want to use.  Do not define this
     macro if backslash is correct for your system.
`DBX_STATIC_STAB_DATA_SECTION'
     Define this macro if it is necessary to go to the data section
     before outputting the `.stabs' pseudo-op for a non-global static
     variable.
`DBX_TYPE_DECL_STABS_CODE'
     The value to use in the "code" field of the `.stabs' directive for
     a typedef.  The default is `N_LSYM'.
`DBX_STATIC_CONST_VAR_CODE'
     The value to use in the "code" field of the `.stabs' directive for
     a static variable located in the text section.  DBX format does not
     provide any "right" way to do this.  The default is `N_FUN'.
`DBX_REGPARM_STABS_CODE'
     The value to use in the "code" field of the `.stabs' directive for
     a parameter passed in registers.  DBX format does not provide any
     "right" way to do this.  The default is `N_RSYM'.
`DBX_REGPARM_STABS_LETTER'
     The letter to use in DBX symbol data to identify a symbol as a
     parameter passed in registers.  DBX format does not customarily
     provide any way to do this.  The default is `'P''.
`DBX_MEMPARM_STABS_LETTER'
     The letter to use in DBX symbol data to identify a symbol as a
     stack parameter.  The default is `'p''.
`DBX_FUNCTION_FIRST'
     Define this macro if the DBX information for a function and its
     arguments should precede the assembler code for the function.
     Normally, in DBX format, the debugging information entirely
     follows the assembler code.
`DBX_LBRAC_FIRST'
     Define this macro if the `N_LBRAC' symbol for a block should
     precede the debugging information for variables and functions
     defined in that block.  Normally, in DBX format, the `N_LBRAC'
     symbol comes first.
File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
Open-Ended Hooks for DBX Format
-------------------------------
`DBX_OUTPUT_LBRAC (STREAM, NAME)'
     Define this macro to say how to output to STREAM the debugging
     information for the start of a scope level for variable names.  The
     argument NAME is the name of an assembler symbol (for use with
     `assemble_name') whose value is the address where the scope begins.
`DBX_OUTPUT_RBRAC (STREAM, NAME)'
     Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
`DBX_OUTPUT_ENUM (STREAM, TYPE)'
     Define this macro if the target machine requires special handling
     to output an enumeration type.  The definition should be a C
     statement (sans semicolon) to output the appropriate information
     to STREAM for the type TYPE.
`DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
     Define this macro if the target machine requires special output at
     the end of the debugging information for a function.  The
     definition should be a C statement (sans semicolon) to output the
     appropriate information to STREAM.  FUNCTION is the
     `FUNCTION_DECL' node for the function.
`DBX_OUTPUT_STANDARD_TYPES (SYMS)'
     Define this macro if you need to control the order of output of the
     standard data types at the beginning of compilation.  The argument
     SYMS is a `tree' which is a chain of all the predefined global
     symbols, including names of data types.
     Normally, DBX output starts with definitions of the types for
     integers and characters, followed by all the other predefined
     types of the particular language in no particular order.
     On some machines, it is necessary to output different particular
     types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
     output those symbols in the necessary order.  Any predefined types
     that you don't explicitly output will be output afterward in no
     particular order.
     Be careful not to define this macro so that it works only for C.
     There are no global variables to access most of the built-in
     types, because another language may have another set of types.
     The way to output a particular type is to look through SYMS to see
     if you can find it. Here is an example:
          {
            tree decl;
            for (decl = syms; decl; decl = TREE_CHAIN (decl))
              if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)), "long int"))
                dbxout_symbol (decl);
            ...
          }
     This does nothing if the expected type does not exist.
     See the function `init_decl_processing' in source file `c-decl.c'
     to find the names to use for all the built-in C types.
     Here is another way of finding a particular type:
          {
            tree decl;
            for (decl = syms; decl; decl = TREE_CHAIN (decl))
              if (TREE_CODE (decl) == TYPE_DECL
              && TREE_CODE (TREE_TYPE (decl)) == INTEGER_CST
                  && TYPE_PRECISION (TREE_TYPE (decl)) == 16
                  && TYPE_UNSIGNED (TREE_TYPE (decl)))
                /* This must be `unsigned short'.  */
                dbxout_symbol (decl);
            ...
          }
File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
File Names in DBX Format
------------------------
`DBX_WORKING_DIRECTORY'
     Define this if DBX wants to have the current directory recorded in
     each object file.
     Note that the working directory is always recorded if GDB
     extensions are enabled.
`DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
     A C statement to output DBX debugging information to the stdio
     stream STREAM which indicates that file NAME is the main source
     file--the file specified as the input file for compilation. This
     macro is called only once, at the beginning of compilation.
     This macro need not be defined if the standard form of output for
     DBX debugging information is appropriate.
`DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
     A C statement to output DBX debugging information to the stdio
     stream STREAM which indicates that the current directory during
     compilation is named NAME.
     This macro need not be defined if the standard form of output for
     DBX debugging information is appropriate.
`DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
     A C statement to output DBX debugging information at the end of
     compilation of the main source file NAME.
     If you don't define this macro, nothing special is output at the
     end of compilation, which is correct for most machines.
`DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
     A C statement to output DBX debugging information to the stdio
     stream STREAM which indicates that file NAME is the current source
     file.  This output is generated each time input shifts to a
     different source file as a result of `#include', the end of an
     included file, or a `#line' command.
     This macro need not be defined if the standard form of output for
     DBX debugging information is appropriate.
File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
Macros for SDB and DWARF Output
-------------------------------
`SDB_DEBUGGING_INFO'
     Define this macro if GNU CC should produce COFF-style debugging
     output for SDB in response to the `-g' option.
`DWARF_DEBUGGING_INFO'
     Define this macro if GNU CC should produce dwarf format debugging
     output in response to the `-g' option.
`PUT_SDB_...'
     Define these macros to override the assembler syntax for the
     special SDB assembler directives.  See `sdbout.c' for a list of
     these macros and their arguments.  If the standard syntax is used,
     you need not define them yourself.
`SDB_DELIM'
     Some assemblers do not support a semicolon as a delimiter, even
     between SDB assembler directives.  In that case, define this macro
     to be the delimiter to use (usually `\n').  It is not necessary to
     define a new set of `PUT_SDB_OP' macros if this is the only change
     required.
`SDB_GENERATE_FAKE'
     Define this macro to override the usual method of constructing a
     dummy name for anonymous structure and union types.  See
     `sdbout.c' for more information.
`SDB_ALLOW_UNKNOWN_REFERENCES'
     Define this macro to allow references to unknown structure, union,
     or enumeration tags to be emitted.  Standard COFF does not allow
     handling of unknown references, MIPS ECOFF has support for it.
`SDB_ALLOW_FORWARD_REFERENCES'
     Define this macro to allow references to structure, union, or
     enumeration tags that have not yet been seen to be handled.  Some
     assemblers choke if forward tags are used, while some require it.
File: gcc.info,  Node: Cross-compilation,  Next: Misc,  Prev: Debugging Info,  Up: Target Macros
Cross Compilation and Floating Point Format
===========================================
   While all modern machines use 2's complement representation for
integers, there are a variety of representations for floating point
numbers.  This means that in a cross-compiler the representation of
floating point numbers in the compiled program may be different from
that used in the machine doing the compilation.
   Because different representation systems may offer different amounts
of range and precision, the cross compiler cannot safely use the host
machine's floating point arithmetic.  Therefore, floating point
constants must be represented in the target machine's format.  This
means that the cross compiler cannot use `atof' to parse a floating
point constant; it must have its own special routine to use instead.
Also, constant folding must emulate the target machine's arithmetic (or
must not be done at all).
   The macros in the following table should be defined only if you are
cross compiling between different floating point formats.
   Otherwise, don't define them. Then default definitions will be set
up which use `double' as the data type, `==' to test for equality, etc.
   You don't need to worry about how many times you use an operand of
any of these macros.  The compiler never uses operands which have side
effects.
`REAL_VALUE_TYPE'
     A macro for the C data type to be used to hold a floating point
     value in the target machine's format.  Typically this would be a
     `struct' containing an array of `int'.
`REAL_VALUES_EQUAL (X, Y)'
     A macro for a C expression which compares for equality the two
     values, X and Y, both of type `REAL_VALUE_TYPE'.
`REAL_VALUES_LESS (X, Y)'
     A macro for a C expression which tests whether X is less than Y,
     both values being of type `REAL_VALUE_TYPE' and interpreted as
     floating point numbers in the target machine's representation.
`REAL_VALUE_LDEXP (X, SCALE)'
     A macro for a C expression which performs the standard library
     function `ldexp', but using the target machine's floating point
     representation.  Both X and the value of the expression have type
     `REAL_VALUE_TYPE'.  The second argument, SCALE, is an integer.
`REAL_VALUE_FIX (X)'
     A macro whose definition is a C expression to convert the
     target-machine floating point value X to a signed integer.  X has
     type `REAL_VALUE_TYPE'.
`REAL_VALUE_UNSIGNED_FIX (X)'
     A macro whose definition is a C expression to convert the
     target-machine floating point value X to an unsigned integer.  X
     has type `REAL_VALUE_TYPE'.
`REAL_VALUE_FIX_TRUNCATE (X)'
     A macro whose definition is a C expression to convert the
     target-machine floating point value X to a signed integer,
     rounding toward 0. X has type `REAL_VALUE_TYPE'.
`REAL_VALUE_UNSIGNED_FIX_TRUNCATE (X)'
     A macro whose definition is a C expression to convert the
     target-machine floating point value X to an unsigned integer,
     rounding toward 0. X has type `REAL_VALUE_TYPE'.
`REAL_VALUE_ATOF (STRING)'
     A macro for a C expression which converts STRING, an expression of
     type `char *', into a floating point number in the target
     machine's representation.  The value has type `REAL_VALUE_TYPE'.
`REAL_INFINITY'
     Define this macro if infinity is a possible floating point value,
     and therefore division by 0 is legitimate.
`REAL_VALUE_ISINF (X)'
     A macro for a C expression which determines whether X, a floating
     point value, is infinity.  The value has type `int'. By default,
     this is defined to call `isinf'.
`REAL_VALUE_ISNAN (X)'
     A macro for a C expression which determines whether X, a floating
     point value, is a "nan" (not-a-number).  The value has type `int'.
      By default, this is defined to call `isnan'.
   Define the following additional macros if you want to make floating
point constant folding work while cross compiling.  If you don't define
them, cross compilation is still possible, but constant folding will
not happen for floating point values.
`REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
     A macro for a C statement which calculates an arithmetic operation
     of the two floating point values X and Y, both of type
     `REAL_VALUE_TYPE' in the target machine's representation, to
     produce a result of the same type and representation which is
     stored in OUTPUT (which will be a variable).
     The operation to be performed is specified by CODE, a tree code
     which will always be one of the following: `PLUS_EXPR',
     `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
     The expansion of this macro is responsible for checking for
     overflow. If overflow happens, the macro expansion should execute
     the statement `return 0;', which indicates the inability to
     perform the arithmetic operation requested.
`REAL_VALUE_NEGATE (X)'
     A macro for a C expression which returns the negative of the
     floating point value X.  Both X and the value of the expression
     have type `REAL_VALUE_TYPE' and are in the target machine's
     floating point representation.
     There is no way for this macro to report overflow, since overflow
     can't happen in the negation operation.
`REAL_VALUE_TRUNCATE (X)'
     A macro for a C expression which converts the double-precision
     floating point value X to single-precision.
     Both X and the value of the expression have type `REAL_VALUE_TYPE'
     and are in the target machine's floating point representation.
     However, the value should have an appropriate bit pattern to be
     output properly as a single-precision floating constant.
     There is no way for this macro to report overflow.
`REAL_VALUE_TO_INT (LOW, HIGH, X)'
     A macro for a C expression which converts a floating point value X
     into a double-precision integer which is then stored into LOW and
     HIGH, two variables of type INT.
`REAL_VALUE_FROM_INT (X, LOW, HIGH)'
     A macro for a C expression which converts a double-precision
     integer found in LOW and HIGH, two variables of type INT, into a
     floating point value which is then stored into X.
File: gcc.info,  Node: Misc,  Prev: Cross-compilation,  Up: Target Macros
Miscellaneous Parameters
========================
`PREDICATE_CODES'
     Optionally define this if you have added predicates to
     `MACHINE.c'.  This macro is called within an initializer of an
     array of structures.  The first field in the structure is the name
     of a predicate and the second field is an array of rtl codes.  For
     each predicate, list all rtl codes that can be in expressions
     matched by the predicate.  The list should have a trailing comma.
     Here is an example of two entries in the list for a typical RISC
     machine:
          #define PREDICATE_CODES \
            {"gen_reg_rtx_operand", {SUBREG, REG}},  \
            {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
     Defining this macro does not affect the generated code (however,
     incorrect definitions that omit an rtl code that may be matched by
     the predicate can cause the compiler to malfunction).  Instead, it
     allows the table built by `genrecog' to be more compact and
     efficient, thus speeding up the compiler.  The most important
     predicates to include in the list specified by this macro are
     thoses used in the most insn patterns.
`CASE_VECTOR_MODE'
     An alias for a machine mode name.  This is the machine mode that
     elements of a jump-table should have.
`CASE_VECTOR_PC_RELATIVE'
     Define this macro if jump-tables should contain relative addresses.
`CASE_DROPS_THROUGH'
     Define this if control falls through a `case' insn when the index
     value is out of range.  This means the specified default-label is
     actually ignored by the `case' insn proper.
`BYTE_LOADS_ZERO_EXTEND'
     Define this macro if an instruction to load a value narrower than a
     word from memory into a register also zero-extends the value to
     the whole register.
`IMPLICIT_FIX_EXPR'
     An alias for a tree code that should be used by default for
     conversion of floating point values to fixed point.  Normally,
     `FIX_ROUND_EXPR' is used.
`FIXUNS_TRUNC_LIKE_FIX_TRUNC'
     Define this macro if the same instructions that convert a floating
     point number to a signed fixed point number also convert validly
     to an unsigned one.
`EASY_DIV_EXPR'
     An alias for a tree code that is the easiest kind of division to
     compile code for in the general case.  It may be `TRUNC_DIV_EXPR',
     `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'.  These four
     division operators differ in how they round the result to an
     integer.  `EASY_DIV_EXPR' is used when it is permissible to use
     any of those kinds of division and the choice should be made on
     the basis of efficiency.
`MOVE_MAX'
     The maximum number of bytes that a single instruction can move
     quickly from memory to memory.
`SHIFT_COUNT_TRUNCATED'
     Defining this macro causes the compiler to omit a sign-extend,
     zero-extend, or bitwise `and' instruction that truncates the count
     of a shift operation to a width equal to the number of bits needed
     to represent the size of the object being shifted.  On machines
     that have instructions that act on bitfields at variable
     positions, including `bit test' instructions, defining
     `SHIFT_COUNT_TRUNCATED' also causes truncation not to be applied
     to these instructions.
     If both types of instructions truncate the count (for shifts) and
     position (for bitfield operations), or if no variable-position
     bitfield instructions exist, you should define this macro.
     However, on some machines, such as the 80386 and the 680x0,
     truncation only applies to shift operations and not the (real or
     pretended) bitfield operations.  Do not define
     `SHIFT_COUNT_TRUNCATED' on such machines.  Instead, add patterns
     to the `md' file that include the implied truncation of the shift
     instructions.
`TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
     A C expression which is nonzero if on this machine it is safe to
     "convert" an integer of INPREC bits to one of OUTPREC bits (where
     OUTPREC is smaller than INPREC) by merely operating on it as if it
     had only OUTPREC bits.
     On many machines, this expression can be 1.
     It is reported that suboptimal code can result when
     `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for modes for
     which `MODES_TIEABLE_P' is 0.  If this is the case, making
     `TRULY_NOOP_TRUNCATION' return 0 in such cases may improve things.
`STORE_FLAG_VALUE'
     A C expression describing the value returned by a comparison
     operator and stored by a store-flag instruction (`sCOND') when the
     condition is true.  This description must apply to *all* the
     `sCOND' patterns and all the comparison operators.
     A value of 1 or -1 means that the instruction implementing the
     comparison operator returns exactly 1 or -1 when the comparison is
     true and 0 when the comparison is false.  Otherwise, the value
     indicates which bits of the result are guaranteed to be 1 when the
     comparison is true.  This value is interpreted in the mode of the
     comparison operation, which is given by the mode of the first
     operand in the `sCOND' pattern.  Either the low bit or the sign
     bit of `STORE_FLAG_VALUE' be on.  Presently, only those bits are
     used by the compiler.
     If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will
     generate code that depends only on the specified bits.  It can also
     replace comparison operators with equivalent operations if they
     cause the required bits to be set, even if the remaining bits are
     undefined. For example, on a machine whose comparison operators
     return an `SImode' value and where `STORE_FLAG_VALUE' is defined as
     `0x80000000', saying that just the sign bit is relevant, the
     expression
          (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0))
     can be converted to
          (ashift:SI X (const_int N))
     where N is the appropriate shift count to move the bit being
     tested into the sign bit.
     There is no way to describe a machine that always sets the
     low-order bit for a true value, but does not guarantee the value
     of any other bits, but we do not know of any machine that has such
     an instruction.  If you are trying to port GNU CC to such a
     machine, include an instruction to perform a logical-and of the
     result with 1 in the pattern for the comparison operators and let
     us know (*note Bug Reporting::.).
     Often, a machine will have multiple instructions that obtain a
     value from a comparison (or the condition codes).  Here are rules
     to guide the choice of value for `STORE_FLAG_VALUE', and hence the
     instructions to be used:
        * Use the shortest sequence that yields a valid definition for
          `STORE_FLAG_VALUE'.  It is more efficient for the compiler to
          "normalize" the value (convert it to, e.g., 1 or 0) than for
          the comparison operators to do so because there may be
          opportunities to combine the normalization with other
          operations.
        * For equal-length sequences, use a value of 1 or -1, with -1
          being slightly preferred on machines with expensive jumps and
          1 preferred on other machines.
        * As a second choice, choose a value of `0x80000001' if
          instructions exist that set both the sign and low-order bits
          but do not define the others.
        * Otherwise, use a value of `0x80000000'.
     You need not define `STORE_FLAG_VALUE' if the machine has no
     store-flag instructions.
`Pmode'
     An alias for the machine mode for pointers.  Normally the
     definition can be
          #define Pmode SImode
`FUNCTION_MODE'
     An alias for the machine mode used for memory references to
     functions being called, in `call' RTL expressions.  On most
     machines this should be `QImode'.
`INTEGRATE_THRESHOLD (DECL)'
     A C expression for the maximum number of instructions above which
     the function DECL should not be inlined.  DECL is a
     `FUNCTION_DECL' node.
     The default definition of this macro is 64 plus 8 times the number
     of arguments that the function accepts.  Some people think a larger
     threshold should be used on RISC machines.
`SCCS_DIRECTIVE'
     Define this if the preprocessor should ignore `#sccs' directives
     and print no error message.
`HANDLE_PRAGMA (STREAM)'
     Define this macro if you want to implement any pragmas.  If
     defined, it should be a C statement to be executed when `#pragma'
     is seen.  The argument STREAM is the stdio input stream from which
     the source text can be read.
     It is generally a bad idea to implement new uses of `#pragma'.  The
     only reason to define this macro is for compatibility with other
     compilers that do support `#pragma' for the sake of any user
     programs which already use it.
`DOLLARS_IN_IDENTIFIERS'
     Define this macro to control use of the character `$' in identifier
     names.  The value should be 0, 1, or 2.  0 means `$' is not allowed
     by default; 1 means it is allowed by default if `-traditional' is
     used; 2 means it is allowed by default provided `-ansi' is not
     used. 1 is the default; there is no need to define this macro in
     that case.
`NO_DOLLAR_IN_LABEL'
     Define this macro if the assembler does not accept the character
     `$' in label names.  By default constructors and destructors in
     G++ have `$' in the identifiers.  If this macro is defined, `.' is
     used instead.
`DEFAULT_MAIN_RETURN'
     Define this macro if the target system expects every program's
     `main' function to return a standard "success" value by default
     (if no other value is explicitly returned).
     The definition should be a C statement (sans semicolon) to
     generate the appropriate rtl instructions.  It is used only when
     compiling the end of `main'.
`HAVE_ATEXIT'
     Define this if the target system supports the function `atexit'
     from the ANSI C standard.  If this is not defined, and
     `INIT_SECTION_ASM_OP' is not defined, a default `exit' function
     will be provided to support C++.
`EXIT_BODY'
     Define this if your `exit' function needs to do something besides
     calling an external function `_cleanup' before terminating with
     `_exit'.  The `EXIT_BODY' macro is only needed if netiher
     `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined.
File: gcc.info,  Node: Config,  Next: Index,  Prev: Target Macros,  Up: Top
The Configuration File
**********************
   The configuration file `xm-MACHINE.h' contains macro definitions
that describe the machine and system on which the compiler is running,
unlike the definitions in `MACHINE.h', which describe the machine for
which the compiler is producing output.  Most of the values in
`xm-MACHINE.h' are actually the same on all machines that GNU CC runs
on, so large parts of all configuration files are identical.  But there
are some macros that vary:
`USG'
     Define this macro if the host system is System V.
`VMS'
     Define this macro if the host system is VMS.
`FAILURE_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits after serious errors.
`SUCCESS_EXIT_CODE'
     A C expression for the status code to be returned when the compiler
     exits without serious errors.
`HOST_WORDS_BIG_ENDIAN'
     Defined if the host machine stores words of multi-word values in
     big-endian order.  (GNU CC does not depend on the host byte
     ordering within a word.)
`HOST_FLOAT_FORMAT'
     A numeric code distinguishing the floating point format for the
     host machine.  See `TARGET_FLOAT_FORMAT' in *Note Storage Layout::
     for the alternatives and default.
`HOST_BITS_PER_CHAR'
     A C expression for the number of bits in `char' on the host
     machine.
`HOST_BITS_PER_SHORT'
     A C expression for the number of bits in `short' on the host
     machine.
`HOST_BITS_PER_INT'
     A C expression for the number of bits in `int' on the host machine.
`HOST_BITS_PER_LONG'
     A C expression for the number of bits in `long' on the host
     machine.
`ONLY_INT_FIELDS'
     Define this macro to indicate that the host compiler only supports
     `int' bit fields, rather than other integral types, including
     `enum', as do most C compilers.
`EXECUTABLE_SUFFIX'
     Define this macro if the host system uses a naming convention for
     executable files that involves a common suffix (such as, in some
     systems, `.exe') that must be mentioned explicitly when you run
     the program.
`OBSTACK_CHUNK_SIZE'
     A C expression for the size of ordinary obstack chunks. If you
     don't define this, a usually-reasonable default is used.
`OBSTACK_CHUNK_ALLOC'
     The function used to allocate obstack chunks. If you don't define
     this, `xmalloc' is used.
`OBSTACK_CHUNK_FREE'
     The function used to free obstack chunks. If you don't define
     this, `free' is used.
`USE_C_ALLOCA'
     Define this macro to indicate that the compiler is running with the
     `alloca' implemented in C.  This version of `alloca' can be found
     in the file `alloca.c'; to use it, you must also alter the
     `Makefile' variable `ALLOCA'.  (This is done automatically for the
     systems on which we know it is needed.)
     If you do define this macro, you should probably do it as follows:
          #ifndef __GNUC__
          #define USE_C_ALLOCA
          #else
          #define alloca __builtin_alloca
          #endif
     so that when the compiler is compiled with GNU CC it uses the more
     efficient built-in `alloca' function.
`FUNCTION_CONVERSION_BUG'
     Define this macro to indicate that the host compiler does not
     properly handle converting a function value to a
     pointer-to-function when it is used in an expression.
`HAVE_VPRINTF'
     Define this if the library function `vprintf' is available on your
     system.
`MULTIBYTE_CHARS'
     Define this macro to enable support for multibyte characters in the
     input to GNU CC.  This requires that the host system support the
     ANSI C library functions for converting multibyte characters to
     wide characters.
`HAVE_PUTENV'
     Define this if the library function `putenv' is available on your
     system.
`NO_SYS_SIGLIST'
     Define this if your system *does not* provide the variable
     `sys_siglist'.
     Some systems do provide this variable, but with a different name
     such as `_sys_siglist'.  On these systems, you can define
     `sys_siglist' as a macro which expands into the name actually
     provided.
`NO_STAB_H'
     Define this if your system does not have the include file
     `stab.h'.  If `USG' is defined, `NO_STAB_H' is assumed.
   In addition, configuration files for system V define `bcopy',
`bzero' and `bcmp' as aliases.  Some files define `alloca' as a macro
when compiled with GNU CC, in order to take advantage of the benefit of
GNU CC's built-in `alloca'.