Run-time Target - GNU Compiler Collection (GCC) Internals
Description: GNU Compiler Collection (GCC) Internals

Next: Per-Function Data, Previous: Driver, Up: Target Macros

### 17.3 Run-time Target Specification

Here are run-time target specifications.

— Macro: TARGET_CPU_CPP_BUILTINS ()

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

— Macro: TARGET_OS_CPP_BUILTINS ()

> Similarly to `TARGET_CPU_CPP_BUILTINS` but this macro is optional and is used for the target operating system instead.

— Macro: TARGET_OBJFMT_CPP_BUILTINS ()

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

— Variable: extern int target_flags

> This variable is declared in `options.h`, which is included before any target-specific headers.

— Target Hook: int TARGET_DEFAULT_TARGET_FLAGS

> This variable specifies the initial value of `target_flags`. Its default setting is 0.

— Target Hook: bool TARGET_HANDLE_OPTION (size_t code, const char *arg, int value)

> This hook is called whenever the user specifies one of the target-specific options described by the `.opt` definition files (see Options). 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.

> code specifies the `OPT_`name enumeration value associated with the selected option; name is just a rendering of the option name in which non-alphanumeric characters are replaced by underscores. arg specifies the string argument and is null if no argument was given. If the option is flagged as a `UInteger` (see Option properties), value is the numeric value of the argument. Otherwise value is 1 if the positive form of the option was used and 0 if the “no-” form was.

— Target Hook: 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 Options). 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.

— Target Hook: 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.

— Target Hook: 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.

— Target Hook: void TARGET_CHECK_STRING_OBJECT_FORMAT_ARG (tree format_arg, tree args_list)

> If a target implements string objects then this hook should 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.

— Macro: TARGET_VERSION

> This macro is a C statement to print on `stderr` a string describing the particular machine description choice. Every machine description should define `TARGET_VERSION`. For example:

>               #ifdef MOTOROLA
>               #define TARGET_VERSION \
>                 fprintf (stderr, " (68k, Motorola syntax)");
>               #else
>               #define TARGET_VERSION \
>                 fprintf (stderr, " (68k, MIT syntax)");
>               #endif

— Target Hook: 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`.

— Macro: C_COMMON_OVERRIDE_OPTIONS

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

— Target Hook: 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.

— Target Hook: void TARGET_OPTION_INIT_STRUCT (struct gcc_options *opts)

> Set target-dependent initial values of fields in opts.

— Target Hook: void TARGET_OPTION_DEFAULT_PARAMS (void)

> Set target-dependent default values for `--param` settings, using calls to `set_default_param_value`.

— Target Hook: void TARGET_HELP (void)

> This hook is called in response to the user invoking `--target-help` on the command line. It gives the target a chance to display extra information on the target specific command line options found in its `.opt` file.

— Macro: SWITCHABLE_TARGET

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