4.4BSD/usr/src/contrib/gcc-2.3.3/gcc.info-18

This is Info file gcc.info, produced by Makeinfo-1.49 from the input
file gcc.texi.

This file documents the use and the internals of the GNU compiler.

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 "Protect
Your Freedom--Fight `Look And Feel'" 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 "Protect Your Freedom--Fight `Look And Feel'", 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: Instruction Output, Next: Dispatch Tables, Prev: Macros for Initialization, Up: Assembler Format

Output of Assembler Instructions
--------------------------------

`REGISTER_NAMES'
A C initializer containing the assembler's names for the machine
registers, each one as a C string constant. This is what
translates register numbers in the compiler into assembler
language.

`ADDITIONAL_REGISTER_NAMES'
If defined, a C initializer for an array of structures containing
a name and a register number. This macro defines additional names
for hard registers, thus allowing the `asm' option in declarations
to refer to registers using alternate names.

`ASM_OUTPUT_OPCODE (STREAM, PTR)'
Define this macro if you are using an unusual assembler that
requires different names for the machine instructions.

The definition is a C statement or statements which output an
assembler instruction opcode to the stdio stream STREAM. The
macro-operand PTR is a variable of type `char *' which points to
the opcode name in its "internal" form--the form that is written
in the machine description. The definition should output the
opcode name to STREAM, performing any translation you desire, and
increment the variable PTR to point at the end of the opcode so
that it will not be output twice.

In fact, your macro definition may process less than the entire
opcode name, or more than the opcode name; but if you want to
process text that includes `%'-sequences to substitute operands,
you must take care of the substitution yourself. Just be sure to
increment PTR over whatever text should not be output normally.

If you need to look at the operand values, they can be found as the
elements of `recog_operand'.

If the macro definition does nothing, the instruction is output in
the usual way.

`FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
If defined, a C statement to be executed just prior to the output
of assembler code for INSN, to modify the extracted operands so
they will be output differently.

Here the argument OPVEC is the vector containing the operands
extracted from INSN, and NOPERANDS is the number of elements of
the vector which contain meaningful data for this insn. The
contents of this vector are what will be used to convert the insn
template into assembler code, so you can change the assembler
output by changing the contents of the vector.

This macro is useful when various assembler syntaxes share a single
file of instruction patterns; by defining this macro differently,
you can cause a large class of instructions to be output
differently (such as with rearranged operands). Naturally,
variations in assembler syntax affecting individual insn patterns
ought to be handled by writing conditional output routines in
those patterns.

If this macro is not defined, it is equivalent to a null statement.

`PRINT_OPERAND (STREAM, X, CODE)'
A C compound statement to output to stdio stream STREAM the
assembler syntax for an instruction operand X. X is an RTL
expression.

CODE is a value that can be used to specify one of several ways of
printing the operand. It is used when identical operands must be
printed differently depending on the context. CODE comes from the
`%' specification that was used to request printing of the
operand. If the specification was just `%DIGIT' then CODE is 0;
if the specification was `%LTR DIGIT' then CODE is the ASCII code
for LTR.

If X is a register, this macro should print the register's name.
The names can be found in an array `reg_names' whose type is `char
*[]'. `reg_names' is initialized from `REGISTER_NAMES'.

When the machine description has a specification `%PUNCT' (a `%'
followed by a punctuation character), this macro is called with a
null pointer for X and the punctuation character for CODE.

`PRINT_OPERAND_PUNCT_VALID_P (CODE)'
A C expression which evaluates to true if CODE is a valid
punctuation character for use in the `PRINT_OPERAND' macro. If
`PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
punctuation characters (except for the standard one, `%') are used
in this way.

`PRINT_OPERAND_ADDRESS (STREAM, X)'
A C compound statement to output to stdio stream STREAM the
assembler syntax for an instruction operand that is a memory
reference whose address is X. X is an RTL expression.

On some machines, the syntax for a symbolic address depends on the
section that the address refers to. On these machines, define the
macro `ENCODE_SECTION_INFO' to store the information into the
`symbol_ref', and then check for it here. *Note Assembler
Format::.

`DBR_OUTPUT_SEQEND(FILE)'
A C statement, to be executed after all slot-filler instructions
have been output. If necessary, call `dbr_sequence_length' to
determine the number of slots filled in a sequence (zero if not
currently outputting a sequence), to decide how many no-ops to
output, or whatever.

Don't define this macro if it has nothing to do, but it is helpful
in reading assembly output if the extent of the delay sequence is
made explicit (e.g. with white space).

Note that output routines for instructions with delay slots must be
prepared to deal with not being output as part of a sequence (i.e.
when the scheduling pass is not run, or when no slot fillers could
be found.) The variable `final_sequence' is null when not
processing a sequence, otherwise it contains the `sequence' rtx
being output.

`REGISTER_PREFIX'
`LOCAL_LABEL_PREFIX'
`USER_LABEL_PREFIX'
`IMMEDIATE_PREFIX'
If defined, C string expressions to be used for the `%R', `%L',
`%U', and `%I' options of `asm_fprintf' (see `final.c'). These
are useful when a single `md' file must support multiple assembler
formats. In that case, the various `tm.h' files can define these
macros differently.

`ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
A C expression to output to STREAM some assembler code which will
push hard register number REGNO onto the stack. The code need not
be optimal, since this macro is used only when profiling.

`ASM_OUTPUT_REG_POP (STREAM, REGNO)'
A C expression to output to STREAM some assembler code which will
pop hard register number REGNO off of the stack. The code need not
be optimal, since this macro is used only when profiling.

File: gcc.info, Node: Dispatch Tables, Next: Alignment Output, Prev: Instruction Output, Up: Assembler Format

Output of Dispatch Tables
-------------------------

`ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
This macro should be provided on machines where the addresses in a
dispatch table are relative to the table's own address.

The definition should be a C statement to output to the stdio
stream STREAM an assembler pseudo-instruction to generate a
difference between two labels. VALUE and REL are the numbers of
two internal labels. The definitions of these labels are output
using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
same way here. For example,

fprintf (STREAM, "\t.word L%d-L%d\n",
VALUE, REL)

`ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
This macro should be provided on machines where the addresses in a
dispatch table are absolute.

The definition should be a C statement to output to the stdio
stream STREAM an assembler pseudo-instruction to generate a
reference to a label. VALUE is the number of an internal label
whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For
example,

fprintf (STREAM, "\t.word L%d\n", VALUE)

`ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
Define this if the label before a jump-table needs to be output
specially. The first three arguments are the same as for
`ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
which follows (a `jump_insn' containing an `addr_vec' or
`addr_diff_vec').

This feature is used on system V to output a `swbeg' statement for
the table.

If this macro is not defined, these labels are output with
`ASM_OUTPUT_INTERNAL_LABEL'.

`ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
Define this if something special must be output at the end of a
jump-table. The definition should be a C statement to be executed
after the assembler code for the table is written. It should write
the appropriate code to stdio stream STREAM. The argument TABLE
is the jump-table insn, and NUM is the label-number of the
preceding label.

If this macro is not defined, nothing special is output at the end
of the jump-table.

File: gcc.info, Node: Alignment Output, Prev: Dispatch Tables, Up: Assembler Format

Assembler Commands for Alignment
--------------------------------

`ASM_OUTPUT_ALIGN_CODE (FILE)'
A C expression to output text to align the location counter in the
way that is desirable at a point in the code that is reached only
by jumping.

This macro need not be defined if you don't want any special
alignment to be done at such a time. Most machine descriptions do
not currently define the macro.

`ASM_OUTPUT_LOOP_ALIGN (FILE)'
A C expression to output text to align the location counter in the
way that is desirable at the beginning of a loop.

This macro need not be defined if you don't want any special
alignment to be done at such a time. Most machine descriptions do
not currently define the macro.

`ASM_OUTPUT_SKIP (STREAM, NBYTES)'
A C statement to output to the stdio stream STREAM an assembler
instruction to advance the location counter by NBYTES bytes. Those
bytes should be zero when loaded. NBYTES will be a C expression
of type `int'.

`ASM_NO_SKIP_IN_TEXT'
Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
text section because it fails put zeros in the bytes that are
skipped. This is true on many Unix systems, where the pseudo--op
to skip bytes produces no-op instructions rather than zeros when
used in the text section.

`ASM_OUTPUT_ALIGN (STREAM, POWER)'
A C statement to output to the stdio stream STREAM an assembler
command to advance the location counter to a multiple of 2 to the
POWER bytes. POWER will be a C expression of type `int'.

File: gcc.info, Node: Debugging Info, Next: Cross-compilation, Prev: Assembler Format, Up: Target Macros

Controlling Debugging Information Format
========================================

* Menu:

* All Debuggers:: Macros that affect all debugging formats uniformly.
* DBX Options:: Macros enabling specific options in DBX format.
* DBX Hooks:: Hook macros for varying DBX format.
* File Names and DBX:: Macros controlling output of file names in DBX format.
* SDB and DWARF:: Macros for SDB (COFF) and DWARF formats.

File: gcc.info, Node: All Debuggers, Next: DBX Options, Up: Debugging Info

Macros Affecting All Debugging Formats
--------------------------------------

`DBX_REGISTER_NUMBER (REGNO)'
A C expression that returns the DBX register number for the
compiler register number REGNO. In simple cases, the value of this
expression may be REGNO itself. But sometimes there are some
registers that the compiler knows about and DBX does not, or vice
versa. In such cases, some register may need to have one number in
the compiler and another for DBX.

If two registers have consecutive numbers inside GNU CC, and they
can be used as a pair to hold a multiword value, then they *must*
have consecutive numbers after renumbering with
`DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to
access such a pair, because they expect register pairs to be
consecutive in their own numbering scheme.

If you find yourself defining `DBX_REGISTER_NUMBER' in way that
does not preserve register pairs, then what you must do instead is
redefine the actual register numbering scheme.

`DEBUGGER_AUTO_OFFSET (X)'
A C expression that returns the integer offset value for an
automatic variable having address X (an RTL expression). The
default computation assumes that X is based on the frame-pointer
and gives the offset from the frame-pointer. This is required for
targets that produce debugging output for DBX or COFF-style
debugging output for SDB and allow the frame-pointer to be
eliminated when the `-g' options is used.

`DEBUGGER_ARG_OFFSET (OFFSET, X)'
A C expression that returns the integer offset value for an
argument having address X (an RTL expression). The nominal offset
is OFFSET.

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 (MODE, X)'
A macro for a C expression which converts the floating point value
X to mode MODE.

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 floating constant whose precision accords
with mode MODE.

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.

`CASE_VALUES_THRESHOLD'
Define this to be the smallest number of different values for
which it is best to use a jump-table instead of a tree of
conditional branches. The default is four for machines with a
`casesi' instruction and five otherwise. This is best for most
machines.

`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.

`BYTE_LOADS_SIGN_EXTEND'
Define this macro if an instruction to load a value narrower than a
word from memory into a register also sign-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, which may include `bit test' instructions, defining
`SHIFT_COUNT_TRUNCATED' also enables deletion of truncations of
the values that serve as arguments to bitfield 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 with an integral mode 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 whose results have a `MODE_INT' mode.

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.

`FLOAT_STORE_FLAG_VALUE'
A C expression that gives a non-zero floating point value that is
returned when comparison operators with floating-point results are
true. Define this macro on machine that have comparison operations
that return floating-point values. If there are no such
operations, do not define this macro.

`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'.

`USE_PROTOTYPES'
Define this to be 1 if you know that the host compiler supports
prototypes, even if it doesn't define __STDC__, or define it to be
0 if you do not want any prototypes used in compiling GNU CC. If
`USE_PROTOTYPES' is not defined, it will be determined
automatically whether your compiler supports prototypes by
checking if `__STDC__' is defined.

`NO_MD_PROTOTYPES'
Define this if you wish suppression of prototypes generated from
the machine description file, but to use other prototypes within
GNU CC. If `USE_PROTOTYPES' is defined to be 0, or the host
compiler does not support prototypes, this macro has no effect.

`MD_CALL_PROTOTYPES'
Define this if you wish to generate prototypes for the `gen_call'
or `gen_call_value' functions generated from the machine
description file. If `USE_PROTOTYPES' is defined to be 0, or the
host compiler does not support prototypes, or `NO_MD_PROTOTYPES'
is defined, this macro has no effect. As soon as all of the
machine descriptions are modified to have the appropriate number
of arguments, this macro will be removed.

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'.