Node: Misc, Previous: Target Attributes, Up: Target Macros

Miscellaneous Parameters

Here are several miscellaneous parameters.

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.

For each predicate function named in PREDICATE_CODES, a declaration will be generated in insn-codes.h.

Define this if you have special predicates that know special things about modes. Genrecog will warn about certain forms of match_operand without a mode; if the operand predicate is listed in SPECIAL_MODE_PREDICATES, the warning will be suppressed.

Here is an example from the IA-32 port (ext_register_operand specially checks for HImode or SImode in preparation for a byte extraction from %ah etc.).

          #define SPECIAL_MODE_PREDICATES \

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 the offset_unsigned and scale flags can be updated.
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.
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.
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.
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.
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.

Define this macro if loading short immediate values into registers sign extends.
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.
The maximum number of bytes that a single instruction can move quickly between memory and registers or between two memory locations.
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.
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 nonzero, 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 bit-fields 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 bit-field instructions.

If both types of instructions truncate the count (for shifts) and position (for bit-field operations), or if no variable-position bit-field 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) bit-field 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.

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 GCC 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 at

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:

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

A C expression that gives a nonzero REAL_VALUE_TYPE 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.
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.

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

In normal operation, the preprocessor expands __STDC__ to the constant 1, to signify that GCC conforms to ISO Standard C. On some hosts, like Solaris, the system compiler uses a different convention, where __STDC__ is normally 0, but is 1 if the user specifies strict conformance to the C Standard.

Defining STDC_0_IN_SYSTEM_HEADERS makes GNU CPP follows the host convention when processing system header files, but when processing user files __STDC__ will always expand to 1.

Define this if the preprocessor should ignore #sccs directives and print no error message.
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, name)
This macro is no longer supported. You must use REGISTER_TARGET_PRAGMAS instead.
Define this macro if you want to implement any target-specific pragmas. If defined, it is a C expression which makes a series of calls to cpp_register_pragma for each pragma, with pfile passed as the first argument to to these functions. The macro may also do any setup required for the pragmas.

The primary reason to define this macro is to provide compatibility with other compilers for the same target. In general, we discourage definition of target-specific pragmas for GCC.

If the pragma can be implemented by attributes then you should consider defining the target hook TARGET_INSERT_ATTRIBUTES as well.

Preprocessor macros that appear on pragma lines are not expanded. All #pragma directives that do not match any registered pragma are silently ignored, unless the user specifies -Wunknown-pragmas.

void cpp_register_pragma (cpp_reader *pfile, const char *space, const char *name, void (*callback) (cpp_reader *)) Function

Each call to cpp_register_pragma establishes one pragma. The callback routine will be called when the preprocessor encounters a pragma of the form

               #pragma [space] name ...

space is the case-sensitive namespace of the pragma, or NULL to put the pragma in the global namespace. The callback routine receives pfile as its first argument, which can be passed on to cpplib's functions if necessary. You can lex tokens after the name by calling c_lex. Tokens that are not read by the callback will be silently ignored. The end of the line is indicated by a token of type CPP_EOF.

For an example use of this routine, see c4x.h and the callback routines defined in c4x-c.c.

Note that the use of c_lex is specific to the C and C++ compilers. It will not work in the Java or Fortran compilers, or any other language compilers for that matter. Thus if c_lex is going to be called from target-specific code, it must only be done so when building the C and C++ compilers. This can be done by defining the variables c_target_objs and cxx_target_objs in the target entry in the config.gcc file. These variables should name the target-specific, language-specific object file which contains the code that uses c_lex. Note it will also be necessary to add a rule to the makefile fragment pointed to by tmake_file that shows how to build this object file.

Define this macro (to a value of 1) if you want the System V style pragmas #pragma pack(<n>) and #pragma weak <name> [=<value>] to be supported by gcc.

The pack pragma specifies the maximum alignment (in bytes) of fields within a structure, in much the same way as the __aligned__ and __packed__ __attribute__s do. A pack value of zero resets the behavior to the default.

The weak pragma only works if SUPPORTS_WEAK and ASM_WEAKEN_LABEL are defined. If enabled it allows the creation of specifically named weak labels, optionally with a value.

Define this macro (to a value of 1) if you want to support the Win32 style pragmas #pragma pack(push,n) and #pragma pack(pop). The pack(push,n) pragma specifies the maximum alignment (in bytes) of fields within a structure, in much the same way as the __aligned__ and __packed__ __attribute__s do. A pack value of zero resets the behavior to the default. Successive invocations of this pragma cause the previous values to be stacked, so that invocations of #pragma pack(pop) will return to the previous value.
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.
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.
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 ..
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.

Define this if the target system lacks the function atexit from the ISO C standard. If this macro is defined, a default definition will be provided to support C++. If ON_EXIT is not defined, a default exit function will also be provided.
Define this macro if the target has another way to implement atexit functionality without replacing exit. For instance, SunOS 4 has a similar on_exit library function.

The definition should be a functional macro which can be used just like the atexit function.

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 NEED_ATEXIT is defined and ON_EXIT is not defined.
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; GCC 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.

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.

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.
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).
MD_ASM_CLOBBERS (clobbers)
A C statement that adds to clobbers STRING_CST trees for any hard regs the port wishes to automatically clobber for all asms.
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.

Define this macro as a C string constant for the linker argument to link in the system math library, or "" if the target does not have a separate math library.

You need only define this macro if the default of "-lm" is wrong.

Define this macro as a C string constant for the environment variable that specifies where the linker should look for libraries.

You need only define this macro if the default of "LIBRARY_PATH" is wrong.

Define this macro if the target supports file locking with fcntl / F_SETLKW. Note that this functionality is part of POSIX. Defining TARGET_HAS_F_SETLKW will enable the test coverage code to use file locking when exiting a program, which avoids race conditions if the program has forked.
A C expression for the maximum number of instructions to execute via conditional execution instructions instead of a branch. A value of BRANCH_COST+1 is the default if the machine does not use cc0, and 1 if it does use cc0.
A C expression to modify the tests in TRUE_EXPR, and FALSE_EXPR for use in converting insns in TEST_BB, THEN_BB, ELSE_BB, and JOIN_BB basic blocks to conditional execution. Set either TRUE_EXPR or FALSE_EXPR to a null pointer if the tests cannot be converted.
A C expression to modify the PATTERN of an INSN that is to be converted to conditional execution format.
A C expression to perform any final machine dependent modifications in converting code to conditional execution in the basic blocks TEST_BB, THEN_BB, ELSE_BB, and JOIN_BB.
A C expression to cancel any machine dependent modifications in converting code to conditional execution in the basic blocks TEST_BB, THEN_BB, ELSE_BB, and JOIN_BB.

void TARGET_INIT_BUILTINS () Target Hook
Define this hook if you have any machine-specific built-in functions that need to be defined. It should be a function that performs the necessary setup.

Machine specific built-in functions can be useful to expand special machine instructions that would otherwise not normally be generated because they have no equivalent in the source language (for example, SIMD vector instructions or prefetch instructions).

To create a built-in function, call the function builtin_function which is defined by the language front end. You can use any type nodes set up by build_common_tree_nodes and build_common_tree_nodes_2; only language front ends that use those two functions will call TARGET_INIT_BUILTINS.

rtx TARGET_EXPAND_BUILTIN (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore) Target Hook

Expand a call to a machine specific built-in function that was set up by TARGET_INIT_BUILTINS. exp is the expression for the function call; the result should go to target if that is convenient, and have mode mode if that is convenient. subtarget may be used as the target for computing one of exp's operands. ignore is nonzero if the value is to be ignored. This function should return the result of the call to the built-in function.

MD_CAN_REDIRECT_BRANCH(branch1, branch2)
Take a branch insn in branch1 and another in branch2. Return true if redirecting branch1 to the destination of branch2 is possible.

On some targets, branches may have a limited range. Optimizing the filling of delay slots can result in branches being redirected, and this may in turn cause a branch offset to overflow.

When the initial value of a hard register has been copied in a pseudo register, it is often not necessary to actually allocate another register to this pseudo register, because the original hard register or a stack slot it has been saved into can be used. ALLOCATE_INITIAL_VALUE, if defined, is called at the start of register allocation once for each hard register that had its initial value copied by using get_func_hard_reg_initial_val or get_hard_reg_initial_val. Possible values are NULL_RTX, if you don't want to do any special allocation, a REG rtx--that would typically be the hard register itself, if it is known not to be clobbered--or a MEM. If you are returning a MEM, this is only a hint for the allocator; it might decide to use another register anyways. You may use current_function_leaf_function in the definition of the macro, functions that use REG_N_SETS, to determine if the hard register in question will not be clobbered.
Define this macro to be a C string representing the suffix for object files on your target machine. If you do not define this macro, GCC will use .o as the suffix for object files.
Define this macro to be a C string representing the suffix to be automatically added to executable files on your target machine. If you do not define this macro, GCC will use the null string as the suffix for executable files.
If defined, collect2 will scan the individual object files specified on its command line and create an export list for the linker. Define this macro for systems like AIX, where the linker discards object files that are not referenced from main and uses export lists.

bool TARGET_CANNOT_MODIFY_JUMPS_P (void) Target Hook
This target hook returns true past the point in which new jump instructions could be created. On machines that require a register for every jump such as the SHmedia ISA of SH5, this point would typically be reload, so this target hook should be defined to a function such as:
          static bool
          cannot_modify_jumps_past_reload_p ()
            return (reload_completed || reload_in_progress);