Here are run-time target specifications.
This function-like macro expands to a block of code that defines
built-in preprocessor macros and assertions for the target CPU, using
the functions builtin_define
, builtin_define_std
and
builtin_assert
. When the front end
calls this macro it provides a trailing semicolon, and since it has
finished command line option processing your code can use those
results freely.
builtin_assert
takes a string in the form you pass to the
command-line option -A, such as cpu=mips
, and creates
the assertion. builtin_define
takes a string in the form
accepted by option -D and unconditionally defines the macro.
builtin_define_std
takes a string representing the name of an
object-like macro. If it doesn’t lie in the user’s namespace,
builtin_define_std
defines it unconditionally. Otherwise, it
defines a version with two leading underscores, and another version
with two leading and trailing underscores, and defines the original
only if an ISO standard was not requested on the command line. For
example, passing unix
defines __unix
, __unix__
and possibly unix
; passing _mips
defines __mips
,
__mips__
and possibly _mips
, and passing _ABI64
defines only _ABI64
.
You can also test for the C dialect being compiled. The variable
c_language
is set to one of clk_c
, clk_cplusplus
or clk_objective_c
. Note that if we are preprocessing
assembler, this variable will be clk_c
but the function-like
macro preprocessing_asm_p()
will return true, so you might want
to check for that first. If you need to check for strict ANSI, the
variable flag_iso
can be used. The function-like macro
preprocessing_trad_p()
can be used to check for traditional
preprocessing.
Similarly to TARGET_CPU_CPP_BUILTINS
but this macro is optional
and is used for the target operating system instead.
Similarly to TARGET_CPU_CPP_BUILTINS
but this macro is optional
and is used for the target object format. elfos.h uses this
macro to define __ELF__
, so you probably do not need to define
it yourself.
extern int
target_flags ¶This variable is declared in options.h, which is included before any target-specific headers.
int
TARGET_DEFAULT_TARGET_FLAGS ¶This variable specifies the initial value of target_flags
.
Its default setting is 0.
bool
TARGET_HANDLE_OPTION (struct gcc_options *opts, struct gcc_options *opts_set, const struct cl_decoded_option *decoded, location_t loc)
¶This hook is called whenever the user specifies one of the target-specific options described by the .opt definition files (see Option specification files). It has the opportunity to do some option-specific processing and should return true if the option is valid. The default definition does nothing but return true.
decoded specifies the option and its arguments. opts and
opts_set are the gcc_options
structures to be used for
storing option state, and loc is the location at which the
option was passed (UNKNOWN_LOCATION
except for options passed
via attributes).
bool
TARGET_HANDLE_C_OPTION (size_t code, const char *arg, int value)
¶This target hook is called whenever the user specifies one of the
target-specific C language family options described by the .opt
definition files(see Option specification files). It has the opportunity to do some
option-specific processing and should return true if the option is
valid. The arguments are like for TARGET_HANDLE_OPTION
. The
default definition does nothing but return false.
In general, you should use TARGET_HANDLE_OPTION
to handle
options. However, if processing an option requires routines that are
only available in the C (and related language) front ends, then you
should use TARGET_HANDLE_C_OPTION
instead.
tree
TARGET_OBJC_CONSTRUCT_STRING_OBJECT (tree string)
¶Targets may provide a string object type that can be used within
and between C, C++ and their respective Objective-C dialects.
A string object might, for example, embed encoding and length information.
These objects are considered opaque to the compiler and handled as references.
An ideal implementation makes the composition of the string object
match that of the Objective-C NSString
(NXString
for GNUStep),
allowing efficient interworking between C-only and Objective-C code.
If a target implements string objects then this hook should return a
reference to such an object constructed from the normal ‘C’ string
representation provided in string.
At present, the hook is used by Objective-C only, to obtain a
common-format string object when the target provides one.
void
TARGET_OBJC_DECLARE_UNRESOLVED_CLASS_REFERENCE (const char *classname)
¶Declare that Objective C class classname is referenced by the current TU.
void
TARGET_OBJC_DECLARE_CLASS_DEFINITION (const char *classname)
¶Declare that Objective C class classname is defined by the current TU.
bool
TARGET_STRING_OBJECT_REF_TYPE_P (const_tree stringref)
¶If a target implements string objects then this hook should return
true
if stringref is a valid reference to such an object.
void
TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree format_arg, tree args_list)
¶If a target implements string objects then this hook should provide a facility to check the function arguments in args_list against the format specifiers in format_arg where the type of format_arg is one recognized as a valid string reference type.
void
TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE (void)
¶This target function is similar to the hook TARGET_OPTION_OVERRIDE
but is called when the optimize level is changed via an attribute or
pragma or when it is reset at the end of the code affected by the
attribute or pragma. It is not called at the beginning of compilation
when TARGET_OPTION_OVERRIDE
is called so if you want to perform these
actions then, you should have TARGET_OPTION_OVERRIDE
call
TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE
.
This is similar to the TARGET_OPTION_OVERRIDE
hook
but is only used in the C
language frontends (C, Objective-C, C++, Objective-C++) and so can be
used to alter option flag variables which only exist in those
frontends.
const struct default_options *
TARGET_OPTION_OPTIMIZATION_TABLE ¶Some machines may desire to change what optimizations are performed for various optimization levels. This variable, if defined, describes options to enable at particular sets of optimization levels. These options are processed once just after the optimization level is determined and before the remainder of the command options have been parsed, so may be overridden by other options passed explicitly.
This processing is run once at program startup and when the optimization
options are changed via #pragma GCC optimize
or by using the
optimize
attribute.
void
TARGET_OPTION_INIT_STRUCT (struct gcc_options *opts)
¶Set target-dependent initial values of fields in opts.
const char *
TARGET_COMPUTE_MULTILIB (const struct switchstr *switches, int n_switches, const char *multilib_dir, const char *multilib_defaults, const char *multilib_select, const char *multilib_matches, const char *multilib_exclusions, const char *multilib_reuse)
¶Some targets like RISC-V might have complicated multilib reuse rules which are hard to implement with the current multilib scheme. This hook allows targets to override the result from the built-in multilib mechanism. switches is the raw option list with n_switches items; multilib_dir is the multi-lib result which is computed by the built-in multi-lib mechanism; multilib_defaults is the default options list for multi-lib; multilib_select is the string containing the list of supported multi-libs, and the option checking list. multilib_matches, multilib_exclusions, and multilib_reuse are corresponding to MULTILIB_MATCHES, MULTILIB_EXCLUSIONS, and MULTILIB_REUSE. The default definition does nothing but return multilib_dir directly.
Some targets need to switch between substantially different subtargets
during compilation. For example, the MIPS target has one subtarget for
the traditional MIPS architecture and another for MIPS16. Source code
can switch between these two subarchitectures using the mips16
and nomips16
attributes.
Such subtargets can differ in things like the set of available registers, the set of available instructions, the costs of various operations, and so on. GCC caches a lot of this type of information in global variables, and recomputing them for each subtarget takes a significant amount of time. The compiler therefore provides a facility for maintaining several versions of the global variables and quickly switching between them; see target-globals.h for details.
Define this macro to 1 if your target needs this facility. The default is 0.
bool
TARGET_FLOAT_EXCEPTIONS_ROUNDING_SUPPORTED_P (void)
¶Returns true if the target supports IEEE 754 floating-point exceptions
and rounding modes, false otherwise. This is intended to relate to the
float
and double
types, but not necessarily long double
.
By default, returns true if the adddf3
instruction pattern is
available and false otherwise, on the assumption that hardware floating
point supports exceptions and rounding modes but software floating point
does not.