810 lines
33 KiB
Plaintext
810 lines
33 KiB
Plaintext
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'.
|
||
|
||
|