Using and Porting GNU CC

16.19: 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 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.

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.

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.

MAX_MOVE_MAX

The maximum number of bytes that a single instruction can move quickly from memory to memory. 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 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'.

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

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

VALID_MACHINE_ATTRIBUTE (type, attributes, identifier)

Define this macro if you want to support machine specific attributes for types. If defined, it should be a C statement whose value is nonzero if identifier is an attribute that is valid for type. The attributes in attributes have previously been assigned to type.

COMP_TYPE_ATTRIBUTES (type1, type2)

Define this macro if type attributes must be checked for compatibility. If defined, it should be a C statement that returns 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)

Define this macro if you want to give the newly defined type some default attributes.

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.

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