Go to the first, previous, next, last section, table of contents.
Here are several miscellaneous parameters.
PREDICATE_CODES
-
Define this if you have defined special-purpose predicates in the file
`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 those 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_SHORTEN_MODE (min_offset, max_offset, body)
-
Optional: return the preferred mode for an
addr_diff_vec
when the minimum and maximum offset are known. If you define this,
it enables extra code in branch shortening to deal with addr_diff_vec
.
To make this work, you also have to define INSN_ALIGN and
make the alignment for addr_diff_vec
explicit.
The body argument is provided so that teh offset_unsigned and scale
flags can be updated.
CASE_VECTOR_PC_RELATIVE
-
Define this macro to be a C expression to indicate when jump-tables
should contain relative addresses. If jump-tables never contain
relative addresses, then you need not define this macro.
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.
WORD_REGISTER_OPERATIONS
-
Define this macro if operations between registers with integral mode
smaller than a word are always performed on the entire register.
Most RISC machines have this property and most CISC machines do not.
LOAD_EXTEND_OP (mode)
-
Define this macro to be a C expression indicating when insns that read
memory in mode, an integral mode narrower than a word, set the
bits outside of mode to be either the sign-extension or the
zero-extension of the data read. Return
SIGN_EXTEND
for values
of mode for which the
insn sign-extends, ZERO_EXTEND
for which it zero-extends, and
NIL
for other modes.
This macro is not called with mode non-integral or with a width
greater than or equal to BITS_PER_WORD
, so you may return any
value in this case. Do not define this macro if it would always return
NIL
. On machines where this macro is defined, you will normally
define it as the constant SIGN_EXTEND
or ZERO_EXTEND
.
SHORT_IMMEDIATES_SIGN_EXTEND
-
Define this macro if loading short immediate values into registers sign
extends.
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
between memory and registers or between two memory locations.
MAX_MOVE_MAX
-
The maximum number of bytes that a single instruction can move quickly
between memory and registers or between two memory locations. If this
is undefined, the default is
MOVE_MAX
. Otherwise, it is the
constant value that is the largest value that MOVE_MAX
can have
at run-time.
SHIFT_COUNT_TRUNCATED
-
A C expression that is nonzero if on this machine the number of bits
actually used for the count of a shift operation is equal to the number
of bits needed to represent the size of the object being shifted. When
this macro is non-zero, the compiler will assume that it is safe to omit
a sign-extend, zero-extend, and certain bitwise `and' instructions that
truncates the count of a shift operation. On machines that have
instructions that act on bitfields at variable positions, which may
include `bit test' instructions, a nonzero
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. Define SHIFT_COUNT_TRUNCATED
to be zero on
such machines. Instead, add patterns to the `md' file that include
the implied truncation of the shift instructions.
You need not define this macro if it would always have the value of zero.
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.
When
TRULY_NOOP_TRUNCATION
returns 1 for a pair of sizes for
modes for which MODES_TIEABLE_P
is 0, suboptimal code can result.
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
(see section How to Report Bugs).
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'.
Many machines can produce both the value chosen for
STORE_FLAG_VALUE
and its negation in the same number of
instructions. On those machines, you should also define a pattern for
those cases, e.g., one matching
(set A (neg:m (ne:m B C)))
Some machines can also perform and
or plus
operations on
condition code values with less instructions than the corresponding
`scond' insn followed by and
or plus
. On those
machines, define the appropriate patterns. Use the names incscc
and decscc
, respectively, for the patterns which perform
plus
or minus
operations on condition code values. See
`rs6000.md' for some examples. The GNU Superoptizer can be used to
find such instruction sequences on other machines.
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. On most machines, define
this to be the integer mode corresponding to the width of a hardware
pointer;
SImode
on 32-bit machine or DImode
on 64-bit machines.
On some machines you must define this to be one of the partial integer
modes, such as PSImode
.
The width of Pmode
must be at least as large as the value of
POINTER_SIZE
. If it is not equal, you must define the macro
POINTERS_EXTEND_UNSIGNED
to specify how pointers are extended
to Pmode
.
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.
NO_IMPLICIT_EXTERN_C
-
Define this macro if the system header files support C++ as well as C.
This macro inhibits the usual method of using system header files in
C++, which is to pretend that the file's contents are enclosed in
`extern "C" {...}'.
HANDLE_PRAGMA (getc, ungetc, node)
-
Define this macro if you want to implement any pragmas. If defined, it
is a C expression whose value is 1 if the pragma was handled by the
function, zero otherwise. The argument getc is a function of type
`int (*)(void)' which will return the next character in the input
stream, or EOF if no characters are left. The argument ungetc is
a function of type `void (*)(int)' which will push a character back
into the input stream. The argument name is the word following
#pragma in the input stream. The input stream pointer will be pointing
just beyond the end of this word. The input stream should be left
undistrubed if the expression returns zero, otherwise it should be
pointing at the last character after the end of the pragma (newline or
end-of-file).
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.
If the pragma can be implemented by atttributes then the macro
`INSERT_ATTRIBUTES' might be a useful one to define as well.
Note: older versions of this macro only had two arguments: stream
and token. The macro was changed in order to allow it to work
when gcc is built both with and without a cpp library.
VALID_MACHINE_DECL_ATTRIBUTE (decl, attributes, identifier, args)
-
If defined, a C expression whose value is nonzero if identifier with
arguments args is a valid machine specific attribute for decl.
The attributes in attributes have previously been assigned to decl.
VALID_MACHINE_TYPE_ATTRIBUTE (type, attributes, identifier, args)
-
If defined, a C expression whose value is nonzero if identifier with
arguments args is a valid machine specific attribute for type.
The attributes in attributes have previously been assigned to type.
COMP_TYPE_ATTRIBUTES (type1, type2)
-
If defined, a C expression whose value is zero if the attributes on
type1 and type2 are incompatible, one if they are compatible,
and two if they are nearly compatible (which causes a warning to be
generated).
SET_DEFAULT_TYPE_ATTRIBUTES (type)
-
If defined, a C statement that assigns default attributes to
newly defined type.
MERGE_MACHINE_TYPE_ATTRIBUTES (type1, type2)
-
Define this macro if the merging of type attributes needs special handling.
If defined, the result is a list of the combined TYPE_ATTRIBUTES of
type1 and type2. It is assumed that comptypes has already been
called and returned 1.
MERGE_MACHINE_DECL_ATTRIBUTES (olddecl, newdecl)
-
Define this macro if the merging of decl attributes needs special handling.
If defined, the result is a list of the combined DECL_MACHINE_ATTRIBUTES of
olddecl and newdecl. newdecl is a duplicate declaration
of olddecl. Examples of when this is needed are when one attribute
overrides another, or when an attribute is nullified by a subsequent
definition.
INSERT_ATTRIBUTES (node, attr_ptr, prefix_ptr)
-
Define this macro if you want to be able to add attributes to a decl
when it is being created. This is normally useful for backends which
wish to implement a pragma by using the attributes which correspond to
the pragma's effect. The node argument is the decl which is being
created. The attr_ptr argument is a pointer to the attribute list
for this decl. The prefix_ptr is a pointer to the list of
attributes that have appeared after the specifiers and modifiers of the
declaration, but before the declaration proper.
SET_DEFAULT_DECL_ATTRIBUTES (decl, attributes)
-
If defined, a C statement that assigns default attributes to
newly defined decl.
SET_DEFAULT_SECTION_NAME (decl)
-
If defined, a C statement that assigns a section name to the newly
created decl.
DOLLARS_IN_IDENTIFIERS
-
Define this macro to control use of the character `$' in identifier
names. 0 means `$' is not allowed by default; 1 means it is allowed.
1 is the default; there is no need to define this macro in that case.
This macro controls the compiler proper; it does not affect the preprocessor.
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.
NO_DOT_IN_LABEL
-
Define this macro if the assembler does not accept the character
`.' in label names. By default constructors and destructors in G++
have names that use `.'. If this macro is defined, these names
are rewritten to avoid `.'.
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 neither HAVE_ATEXIT
nor
INIT_SECTION_ASM_OP
are defined.
INSN_SETS_ARE_DELAYED (insn)
-
Define this macro as a C expression that is nonzero if it is safe for the
delay slot scheduler to place instructions in the delay slot of insn,
even if they appear to use a resource set or clobbered in insn.
insn is always a
jump_insn
or an insn
; GNU CC knows that
every call_insn
has this behavior. On machines where some insn
or jump_insn
is really a function call and hence has this behavior,
you should define this macro.
You need not define this macro if it would always return zero.
INSN_REFERENCES_ARE_DELAYED (insn)
-
Define this macro as a C expression that is nonzero if it is safe for the
delay slot scheduler to place instructions in the delay slot of insn,
even if they appear to set or clobber a resource referenced in insn.
insn is always a
jump_insn
or an insn
. On machines where
some insn
or jump_insn
is really a function call and its operands
are registers whose use is actually in the subroutine it calls, you should
define this macro. Doing so allows the delay slot scheduler to move
instructions which copy arguments into the argument registers into the delay
slot of insn.
You need not define this macro if it would always return zero.
MACHINE_DEPENDENT_REORG (insn)
-
In rare cases, correct code generation requires extra machine
dependent processing between the second jump optimization pass and
delayed branch scheduling. On those machines, define this macro as a C
statement to act on the code starting at insn.
MULTIPLE_SYMBOL_SPACES
-
Define this macro if in some cases global symbols from one translation
unit may not be bound to undefined symbols in another translation unit
without user intervention. For instance, under Microsoft Windows
symbols must be explicitly imported from shared libraries (DLLs).
GIV_SORT_CRITERION (giv1, giv2)
-
In some cases, the strength reduction optimization pass can produce better
code if this is defined. This macro controls the order that induction
variables are combined. This macro is particularly useful if the target has
limited addressing modes. For instance, the SH target has only positive
offsets in addresses. Thus sorting to put the smallest address first
allows the most combinations to be found.
ISSUE_RATE
-
A C expression that returns how many instructions can be issued at the
same time if the machine is a superscalar machine. This is only used by
the `Haifa' scheduler, and not the traditional scheduler.
MD_SCHED_INIT (file, verbose
-
A C statement which is executed by the `Haifa' scheduler at the
beginning of each block of instructions that are to be scheduled.
file is either a null pointer, or a stdio stream to write any
debug output to. verbose is the verbose level provided by
`-fsched-verbose-'n.
MD_SCHED_REORDER (file, verbose, ready, n_ready)
-
A C statement which is executed by the `Haifa' scheduler after it
has scheduled the ready list to allow the machine description to reorder
it (for example to combine two small instructions together on
`VLIW' machines). file is either a null pointer, or a stdio
stream to write any debug output to. verbose is the verbose level
provided by `-fsched-verbose-'n. ready is a pointer to
the ready list of instructions that are ready to be scheduled.
n_ready is the number of elements in the ready list. The
scheduler reads the ready list in reverse order, starting with
ready[n_ready-1] and going to ready[0].
MD_SCHED_VARIABLE_ISSUE (file, verbose, insn, more)
-
A C statement which is executed by the `Haifa' scheduler after it
has scheduled an insn from the ready list. file is either a null
pointer, or a stdio stream to write any debug output to. verbose
is the verbose level provided by `-fsched-verbose-'n.
insn is the instruction that was scheduled. more is the
number of instructions that can be issued in the current cycle. The
`MD_SCHED_VARIABLE_ISSUE' macro is responsible for updating the
value of more (typically by more--).
MAX_INTEGER_COMPUTATION_MODE
-
Define this to the largest integer machine mode which can be used for
operations other than load, store and copy operations.
You need only define this macro if the target holds values larger than
word_mode
in general purpose registers. Most targets should not define
this macro.
NEED_MATH_LIBRARY
-
Define this macro as a C expression that is nonzero if
g++
should
automatically link in the math library or to zero if g++
should not
automatically link in the math library.
You need only define this macro if the target does not always need the math
library linked into C++ programs.
Go to the first, previous, next, last section, table of contents.