Effective-Target Keywords (GNU Compiler Collection (GCC) Internals)

#### 6.2.3 Keywords describing target attributes ¶

Effective-target keywords identify sets of targets that support particular functionality. They are used to limit tests to be run only for particular targets, or to specify that particular sets of targets are expected to fail some tests.

Effective-target keywords are defined in `lib/target-supports.exp` in the GCC testsuite, with the exception of those that are documented as being local to a particular test directory.

The ‘`effective target`’ takes into account all of the compiler options with which the test will be compiled, including the multilib options. By convention, keywords ending in `_nocache` can also include options specified for the particular test in an earlier `dg-options` or `dg-add-options` directive.

#### 6.2.3.1 Object file format ¶

This identifies the object file format emitted by the compiler. Matching assembler output often depends on content that differs between file formats.

`elf`

  Target uses the ELF file format (note that ELFv2 is matched specifically for the powerpc platform, below).

`macho`

  Target uses the Mach-O file format (currently applies only to Darwin / macOS).

`pe`

  Target uses the PE/COFF file format (e.g. for Windows).

#### 6.2.3.2 Endianness ¶

`be`

  Target uses big-endian memory order for multi-byte and multi-word data.

`le`

  Target uses little-endian memory order for multi-byte and multi-word data.

#### 6.2.3.3 Data type sizes ¶

`ilp32`

  Target has 32-bit `int`, `long`, and pointers.

`lp64`

  Target has 32-bit `int`, 64-bit `long` and pointers.

`llp64`

  Target has 32-bit `int` and `long`, 64-bit `long long` and pointers.

`double64`

  Target has 64-bit `double`.

`double64plus`

  Target has `double` that is 64 bits or longer.

`longdouble128`

  Target has 128-bit `long double`.

`int32plus`

  Target has `int` that is at 32 bits or longer.

`int16`

  Target has `int` that is 16 bits or shorter.

`longlong64`

  Target has 64-bit `long long`.

`long_neq_int`

  Target has `int` and `long` with different sizes.

`short_eq_int`

  Target has `short` and `int` with the same size.

`ptr_eq_short`

  Target has pointers (`void *`) and `short` with the same size.

`int_eq_float`

  Target has `int` and `float` with the same size.

`ptr_eq_long`

  Target has pointers (`void *`) and `long` with the same size.

`large_double`

  Target supports `double` that is longer than `float`.

`large_long_double`

  Target supports `long double` that is longer than `double`.

`ptr32plus`

  Target has pointers that are 32 bits or longer.

`size20plus`

  Target has a 20-bit or larger address space, so supports at least 16-bit array and structure sizes.

`size24plus`

  Target has a 24-bit or larger address space, so supports at least 20-bit array and structure sizes.

`size32plus`

  Target has a 32-bit or larger address space, so supports at least 24-bit array and structure sizes.

`4byte_wchar_t`

  Target has `wchar_t` that is at least 4 bytes.

`floatn`

  Target has the `_Floatn` type.

`floatnx`

  Target has the `_Floatnx` type.

`floatn_runtime`

  Target has the `_Floatn` type, including runtime support for any options added with `dg-add-options`.

`floatnx_runtime`

  Target has the `_Floatnx` type, including runtime support for any options added with `dg-add-options`.

`floatn_nx_runtime`

  Target has runtime support for any options added with `dg-add-options` for any `_Floatn` or `_Floatnx` type.

`inf`

  Target supports floating point infinite (`inf`) for type `double`.

`inff`

  Target supports floating point infinite (`inf`) for type `float`.

#### 6.2.3.4 Fortran-specific attributes ¶

`fortran_integer_16`

  Target supports Fortran `integer` that is 16 bytes or longer.

`fortran_real_10`

  Target supports Fortran `real` that is 10 bytes or longer.

`fortran_real_16`

  Target supports Fortran `real` that is 16 bytes or longer.

`fortran_large_int`

  Target supports Fortran `integer` kinds larger than `integer(8)`.

`fortran_large_real`

  Target supports Fortran `real` kinds larger than `real(8)`.

#### 6.2.3.5 Vector-specific attributes ¶

`vect_align_stack_vars`

  The target’s ABI allows stack variables to be aligned to the preferred vector alignment.

`vect_avg_qi`

  Target supports both signed and unsigned averaging operations on vectors of bytes.

`vect_mulhrs_hi`

  Target supports both signed and unsigned multiply-high-with-round-and-scale operations on vectors of half-words.

`vect_sdiv_pow2_si`

  Target supports signed division by constant power-of-2 operations on vectors of 4-byte integers.

`vect_condition`

  Target supports vector conditional operations.

`vect_cond_mixed`

  Target supports vector conditional operations where comparison operands have different type from the value operands.

`vect_double`

  Target supports hardware vectors of `double`.

`vect_double_cond_arith`

  Target supports conditional addition, subtraction, multiplication, division, minimum and maximum on vectors of `double`, via the `cond_` optabs.

`vect_element_align_preferred`

  The target’s preferred vector alignment is the same as the element alignment.

`vect_float`

  Target supports hardware vectors of `float` when `-funsafe-math-optimizations` is in effect.

`vect_float_strict`

  Target supports hardware vectors of `float` when `-funsafe-math-optimizations` is not in effect. This implies `vect_float`.

`vect_early_break`

  Target supports vectorization codegen of loops with early breaks. This requires an implementation of the cbranch optab for vectors.

`vect_early_break_hw`

  Target supports hardware vectorization and running of loops with early breaks. This requires an implementation of the cbranch optab for vectors.

`vect_int`

  Target supports hardware vectors of `int`.

`vect_long`

  Target supports hardware vectors of `long`.

`vect_long_long`

  Target supports hardware vectors of `long long`.

`vect_check_ptrs`

  Target supports the `check_raw_ptrs` and `check_war_ptrs` optabs on vectors.

`vect_fully_masked`

  Target supports fully-masked (also known as fully-predicated) loops, so that vector loops can handle partial as well as full vectors.

`vect_masked_load`

  Target supports vector masked loads.

`vect_masked_store`

  Target supports vector masked stores.

`vect_gather_load_ifn`

  Target supports vector gather loads using internal functions (rather than via built-in functions or emulation).

`vect_scatter_store`

  Target supports vector scatter stores.

`vect_aligned_arrays`

  Target aligns arrays to vector alignment boundary.

`vect_hw_misalign`

  Target supports a vector misalign access.

`vect_no_align`

  Target does not support a vector alignment mechanism.

`vect_peeling_profitable`

  Target might require to peel loops for alignment purposes.

`vect_no_int_min_max`

  Target does not support a vector min and max instruction on `int`.

`vect_no_int_add`

  Target does not support a vector add instruction on `int`.

`vect_no_bitwise`

  Target does not support vector bitwise instructions.

`vect_bool_cmp`

  Target supports comparison of `bool` vectors for at least one vector length.

`vect_char_add`

  Target supports addition of `char` vectors for at least one vector length.

`vect_char_mult`

  Target supports `vector char` multiplication.

`vect_short_mult`

  Target supports `vector short` multiplication.

`vect_int_mult`

  Target supports `vector int` multiplication.

`vect_long_mult`

  Target supports 64 bit `vector long` multiplication.

`vect_extract_even_odd`

  Target supports vector even/odd element extraction.

`vect_extract_even_odd_wide`

  Target supports vector even/odd element extraction of vectors with elements `SImode` or larger.

`vect_interleave`

  Target supports vector interleaving.

`vect_strided`

  Target supports vector interleaving and extract even/odd.

`vect_strided_wide`

  Target supports vector interleaving and extract even/odd for wide element types.

`vect_perm`

  Target supports vector permutation.

`vect_perm_byte`

  Target supports permutation of vectors with 8-bit elements.

`vect_perm_short`

  Target supports permutation of vectors with 16-bit elements.

`vect_perm3_byte`

  Target supports permutation of vectors with 8-bit elements, and for the default vector length it is possible to permute:

      { a0, a1, a2, b0, b1, b2, ... }

  to:

      { a0, a0, a0, b0, b0, b0, ... }
      { a1, a1, a1, b1, b1, b1, ... }
      { a2, a2, a2, b2, b2, b2, ... }

  using only two-vector permutes, regardless of how long the sequence is.

`vect_perm3_int`

  Like `vect_perm3_byte`, but for 32-bit elements.

`vect_perm3_short`

  Like `vect_perm3_byte`, but for 16-bit elements.

`vect_shift`

  Target supports a hardware vector shift operation.

`vect_unaligned_possible`

  Target prefers vectors to have an alignment greater than element alignment, but also allows unaligned vector accesses in some circumstances.

`vect_variable_length`

  Target has variable-length vectors.

`vect64`

  Target supports vectors of 64 bits.

`vect32`

  Target supports vectors of 32 bits.

`vect_widen_sum_hi_to_si`

  Target supports a vector widening summation of `short` operands into `int` results, or can promote (unpack) from `short` to `int`.

`vect_widen_sum_qi_to_hi`

  Target supports a vector widening summation of `char` operands into `short` results, or can promote (unpack) from `char` to `short`.

`vect_widen_sum_qi_to_si`

  Target supports a vector widening summation of `char` operands into `int` results.

`vect_widen_mult_qi_to_hi`

  Target supports a vector widening multiplication of `char` operands into `short` results, or can promote (unpack) from `char` to `short` and perform non-widening multiplication of `short`.

`vect_widen_mult_hi_to_si`

  Target supports a vector widening multiplication of `short` operands into `int` results, or can promote (unpack) from `short` to `int` and perform non-widening multiplication of `int`.

`vect_widen_mult_si_to_di_pattern`

  Target supports a vector widening multiplication of `int` operands into `long` results.

`vect_sdot_qi`

  Target supports a vector dot-product of `signed char`.

`vect_udot_qi`

  Target supports a vector dot-product of `unsigned char`.

`vect_usdot_qi`

  Target supports a vector dot-product where one operand of the multiply is `signed char` and the other of `unsigned char`.

`vect_sdot_hi`

  Target supports a vector dot-product of `signed short`.

`vect_udot_hi`

  Target supports a vector dot-product of `unsigned short`.

`vect_pack_trunc`

  Target supports a vector demotion (packing) of `short` to `char` and from `int` to `short` using modulo arithmetic.

`vect_unpack`

  Target supports a vector promotion (unpacking) of `char` to `short` and from `char` to `int`.

`vect_intfloat_cvt`

  Target supports conversion from `signed int` to `float`.

`vect_uintfloat_cvt`

  Target supports conversion from `unsigned int` to `float`.

`vect_floatint_cvt`

  Target supports conversion from `float` to `signed int`.

`vect_floatuint_cvt`

  Target supports conversion from `float` to `unsigned int`.

`vect_intdouble_cvt`

  Target supports conversion from `signed int` to `double`.

`vect_doubleint_cvt`

  Target supports conversion from `double` to `signed int`.

`vect_max_reduc`

  Target supports max reduction for vectors.

`vect_sizes_16B_8B`

  Target supports 16- and 8-bytes vectors.

`vect_sizes_32B_16B`

  Target supports 32- and 16-bytes vectors.

`vect_logical_reduc`

  Target supports AND, IOR and XOR reduction on vectors.

`vect_fold_extract_last`

  Target supports the `fold_extract_last` optab.

`vect_len_load_store`

  Target supports the `len_load` and `len_store` optabs.

`vect_partial_vectors_usage_1`

  Target supports loop vectorization with partial vectors and `vect-partial-vector-usage` is set to 1.

`vect_partial_vectors_usage_2`

  Target supports loop vectorization with partial vectors and `vect-partial-vector-usage` is set to 2.

`vect_partial_vectors`

  Target supports loop vectorization with partial vectors and `vect-partial-vector-usage` is nonzero.

`vect_slp_v2qi_store_align`

  Target supports vectorization of 2-byte char stores with 2-byte aligned address at plain `-O2`.

`vect_slp_v4qi_store_align`

  Target supports vectorization of 4-byte char stores with 4-byte aligned address at plain `-O2`.

`vect_slp_v4qi_store_unalign`

  Target supports vectorization of 4-byte char stores with unaligned address at plain `-O2`.

`struct_4char_block_move`

  Target supports block move for 8-byte aligned 4-byte size struct initialization.

`vect_slp_v4qi_store_unalign_1`

  Target supports vectorization of 4-byte char stores with unaligned address or store them with constant pool at plain `-O2`.

`struct_8char_block_move`

  Target supports block move for 8-byte aligned 8-byte size struct initialization.

`vect_slp_v8qi_store_unalign_1`

  Target supports vectorization of 8-byte char stores with unaligned address or store them with constant pool at plain `-O2`.

`struct_16char_block_move`

  Target supports block move for 8-byte aligned 16-byte size struct initialization.

`vect_slp_v16qi_store_unalign_1`

  Target supports vectorization of 16-byte char stores with unaligned address or store them with constant pool at plain `-O2`.

`vect_slp_v2hi_store_align`

  Target supports vectorization of 4-byte short stores with 4-byte aligned addressat plain `-O2`.

`vect_slp_v2hi_store_unalign`

  Target supports vectorization of 4-byte short stores with unaligned address at plain `-O2`.

`vect_slp_v4hi_store_unalign`

  Target supports vectorization of 8-byte short stores with unaligned address at plain `-O2`.

`vect_slp_v2si_store_align`

  Target supports vectorization of 8-byte int stores with 8-byte aligned address at plain `-O2`.

`vect_slp_v4si_store_unalign`

  Target supports vectorization of 16-byte int stores with unaligned address at plain `-O2`.

#### 6.2.3.6 Thread Local Storage attributes ¶

`tls`

  Target supports thread-local storage.

`tls_link`

  Target supports linking TLS executables.

`tls_native`

  Target supports native (rather than emulated) thread-local storage.

`tls_runtime`

  Test system supports executing TLS executables.

#### 6.2.3.7 Decimal floating point attributes ¶

`dfp`

  Targets supports compiling decimal floating point extension to C.

`dfp_nocache`

  Including the options used to compile this particular test, the target supports compiling decimal floating point extension to C.

`dfprt`

  Test system can execute decimal floating point tests.

`dfprt_nocache`

  Including the options used to compile this particular test, the test system can execute decimal floating point tests.

`hard_dfp`

  Target generates decimal floating point instructions with current options.

`dfp_bid`

  Target uses the BID format for decimal floating point.

#### 6.2.3.8 ARM-specific attributes ¶

`arm32`

  ARM target generates 32-bit code.

`arm_little_endian`

  ARM target that generates little-endian code.

`arm_eabi`

  ARM target adheres to the ABI for the ARM Architecture.

`arm_fp_ok`

  ARM target defines `__ARM_FP` using `-mfloat-abi=softfp` or equivalent options. Some multilibs may be incompatible with these options.

`arm_fp_dp_ok`

  ARM target defines `__ARM_FP` with double-precision support using `-mfloat-abi=softfp` or equivalent options. Some multilibs may be incompatible with these options.

`arm_hf_eabi`

  ARM target adheres to the VFP and Advanced SIMD Register Arguments variant of the ABI for the ARM Architecture (as selected with `-mfloat-abi=hard`).

`arm_softfloat`

  ARM target uses emulated floating point operations.

`arm_hard_vfp_ok`

  ARM target supports `-mfpu=vfp -mfloat-abi=hard`. Some multilibs may be incompatible with these options.

`arm_neon`

  ARM target supports generating NEON instructions.

`arm_tune_string_ops_prefer_neon`

  Test CPU tune supports inlining string operations with NEON instructions.

`arm_neon_hw`

  Test system supports executing NEON instructions.

`arm_neonv2_hw`

  Test system supports executing NEON v2 instructions.

`arm_neon_ok`

  ARM Target supports `-mfpu=neon -mfloat-abi=softfp` or compatible options. Some multilibs may be incompatible with these options.

`arm_neon_ok_no_float_abi`

  ARM Target supports NEON with `-mfpu=neon`, but without any -mfloat-abi= option. Some multilibs may be incompatible with this option.

`arm_neonv2_ok`

  ARM Target supports `-mfpu=neon-vfpv4 -mfloat-abi=softfp` or compatible options. Some multilibs may be incompatible with these options.

`arm_fp16_ok`

  Target supports options to generate VFP half-precision floating-point instructions. Some multilibs may be incompatible with these options. This test is valid for ARM only.

`arm_fp16_hw`

  Target supports executing VFP half-precision floating-point instructions. This test is valid for ARM only.

`arm_neon_fp16_ok`

  ARM Target supports `-mfpu=neon-fp16 -mfloat-abi=softfp` or compatible options, including `-mfp16-format=ieee` if necessary to obtain the `__fp16` type. Some multilibs may be incompatible with these options.

`arm_neon_fp16_hw`

  Test system supports executing Neon half-precision float instructions. (Implies previous.)

`arm_fp16_alternative_ok`

  ARM target supports the ARM FP16 alternative format. Some multilibs may be incompatible with the options needed.

`arm_fp16_none_ok`

  ARM target supports specifying none as the ARM FP16 format.

`arm_thumb1_ok`

  ARM target generates Thumb-1 code for `-mthumb`.

`arm_thumb2_ok`

  ARM target generates Thumb-2 code for `-mthumb`.

`arm_nothumb`

  ARM target that is not using Thumb.

`arm_vfp_ok`

  ARM target supports `-mfpu=vfp -mfloat-abi=softfp`. Some multilibs may be incompatible with these options.

`arm_vfp3_ok`

  ARM target supports `-mfpu=vfp3 -mfloat-abi=softfp`. Some multilibs may be incompatible with these options.

`arm_arch_v8a_hard_ok`

  The compiler is targeting `arm*-*-*` and can compile and assemble code using the options `-march=armv8-a -mfpu=neon-fp-armv8 -mfloat-abi=hard`. This is not enough to guarantee that linking works.

`arm_arch_v8a_hard_multilib`

  The compiler is targeting `arm*-*-*` and can build programs using the options `-march=armv8-a -mfpu=neon-fp-armv8 -mfloat-abi=hard`. The target can also run the resulting binaries.

`arm_v8_vfp_ok`

  ARM target supports `-mfpu=fp-armv8 -mfloat-abi=softfp`. Some multilibs may be incompatible with these options.

`arm_v8_neon_ok`

  ARM target supports `-mfpu=neon-fp-armv8 -mfloat-abi=softfp`. Some multilibs may be incompatible with these options.

`arm_v8_1a_neon_ok`

  ARM target supports options to generate ARMv8.1-A Adv.SIMD instructions. Some multilibs may be incompatible with these options.

`arm_v8_1a_neon_hw`

  ARM target supports executing ARMv8.1-A Adv.SIMD instructions. Some multilibs may be incompatible with the options needed. Implies arm_v8_1a_neon_ok.

`arm_acq_rel`

  ARM target supports acquire-release instructions.

`arm_v8_2a_fp16_scalar_ok`

  ARM target supports options to generate instructions for ARMv8.2-A and scalar instructions from the FP16 extension. Some multilibs may be incompatible with these options.

`arm_v8_2a_fp16_scalar_hw`

  ARM target supports executing instructions for ARMv8.2-A and scalar instructions from the FP16 extension. Some multilibs may be incompatible with these options. Implies arm_v8_2a_fp16_neon_ok.

`arm_v8_2a_fp16_neon_ok`

  ARM target supports options to generate instructions from ARMv8.2-A with the FP16 extension. Some multilibs may be incompatible with these options. Implies arm_v8_2a_fp16_scalar_ok.

`arm_v8_2a_fp16_neon_hw`

  ARM target supports executing instructions from ARMv8.2-A with the FP16 extension. Some multilibs may be incompatible with these options. Implies arm_v8_2a_fp16_neon_ok and arm_v8_2a_fp16_scalar_hw.

`arm_v8_2a_dotprod_neon_ok`

  ARM target supports options to generate instructions from ARMv8.2-A with the Dot Product extension. Some multilibs may be incompatible with these options.

`arm_v8_2a_dotprod_neon_hw`

  ARM target supports executing instructions from ARMv8.2-A with the Dot Product extension. Some multilibs may be incompatible with these options. Implies arm_v8_2a_dotprod_neon_ok.

`arm_v8_2a_i8mm_neon_hw`

  ARM target supports executing instructions from ARMv8.2-A with the 8-bit Matrix Multiply extension. Some multilibs may be incompatible with these options. Implies arm_v8_2a_i8mm_ok.

`arm_fp16fml_neon_ok`

  ARM target supports extensions to generate the `VFMAL` and `VFMLS` half-precision floating-point instructions available from ARMv8.2-A and onwards. Some multilibs may be incompatible with these options.

`arm_v8_2a_bf16_neon_ok`

  ARM target supports options to generate instructions from ARMv8.2-A with the BFloat16 extension (bf16). Some multilibs may be incompatible with these options.

`arm_v8_2a_i8mm_ok`

  ARM target supports options to generate instructions from ARMv8.2-A with the 8-Bit Integer Matrix Multiply extension (i8mm). Some multilibs may be incompatible with these options.

`arm_v8_1m_mve_ok`

  ARM target supports options to generate instructions from ARMv8.1-M with the M-Profile Vector Extension (MVE). Some multilibs may be incompatible with these options.

`arm_v8_1m_mve_fp_ok`

  ARM target supports options to generate instructions from ARMv8.1-M with the Half-precision floating-point instructions (HP), Floating-point Extension (FP) along with M-Profile Vector Extension (MVE). Some multilibs may be incompatible with these options.

`arm_v8_1m_mve_nofp_ok`

  ARM target supports options to generate instructions from ARMv8.1-M with the M-Profile Vector Extension (MVE) but without the Half-precision floating-point instructions (HP) and Floating-point Extension (FP). Some multilibs may be incompatible with these options.

`arm_mve_hw`

  Test system supports executing MVE instructions.

`arm_v8m_main_cde`

  ARM target supports options to generate instructions from ARMv8-M with the Custom Datapath Extension (CDE). Some multilibs may be incompatible with these options.

`arm_v8m_main_cde_fp`

  ARM target supports options to generate instructions from ARMv8-M with the Custom Datapath Extension (CDE) and floating-point (VFP). Some multilibs may be incompatible with these options.

`arm_v8_1m_main_cde_mve`

  Arm target supports options to generate instructions from Armv8.1-M with the Custom Datapath Extension (CDE) and M-Profile Vector Extension (MVE). Some multilibs may be incompatible with these options.

`arm_v8_1m_main_cde_mve_fp`

  Arm target supports options to generate instructions from Armv8.1-M with the Custom Datapath Extension (CDE) and M-Profile Vector Extension (MVE) with floating-point support. Some multilibs may be incompatible with these options.

`arm_pacbti_hw`

  Test system supports executing Pointer Authentication and Branch Target Identification instructions.

`arm_prefer_ldrd_strd`

  ARM target prefers `LDRD` and `STRD` instructions over `LDM` and `STM` instructions.

`arm_thumb1_movt_ok`

  ARM target generates Thumb-1 code for `-mthumb` with `MOVW` and `MOVT` instructions available.

`arm_thumb1_cbz_ok`

  ARM target generates Thumb-1 code for `-mthumb` with `CBZ` and `CBNZ` instructions available.

`arm_divmod_simode`

  ARM target for which divmod transform is disabled, if it supports hardware div instruction.

`arm_cmse_ok`

  ARM target supports ARMv8-M Security Extensions, enabled by the `-mcmse` option.

`arm_cmse_hw`

  Test system supports executing CMSE instructions.

`arm_coproc1_ok`

  ARM target supports the following coprocessor instructions: `CDP`, `LDC`, `STC`, `MCR` and `MRC`.

`arm_coproc2_ok`

  ARM target supports all the coprocessor instructions also listed as supported in arm_coproc1_ok in addition to the following: `CDP2`, `LDC2`, `LDC2l`, `STC2`, `STC2l`, `MCR2` and `MRC2`.

`arm_coproc3_ok`

  ARM target supports all the coprocessor instructions also listed as supported in arm_coproc2_ok in addition the following: `MCRR` and `MRRC`.

`arm_coproc4_ok`

  ARM target supports all the coprocessor instructions also listed as supported in arm_coproc3_ok in addition the following: `MCRR2` and `MRRC2`.

`arm_simd32_ok`

  ARM Target supports options suitable for accessing the SIMD32 intrinsics from `arm_acle.h`. Some multilibs may be incompatible with these options.

`arm_sat_ok`

  ARM Target supports options suitable for accessing the saturation intrinsics from `arm_acle.h`. Some multilibs may be incompatible with these options.

`arm_dsp_ok`

  ARM Target supports options suitable for accessing the DSP intrinsics from `arm_acle.h`. Some multilibs may be incompatible with these options.

`arm_softfp_ok`

  ARM target supports the `-mfloat-abi=softfp` option.

`arm_hard_ok`

  ARM target supports the `-mfloat-abi=hard` option.

`arm_mve`

  ARM target supports generating MVE instructions.

`arm_v8_1_lob_ok`

  ARM Target supports executing the Armv8.1-M Mainline Low Overhead Loop instructions `DLS` and `LE`. Some multilibs may be incompatible with these options.

`arm_thumb2_no_arm_v8_1_lob`

  ARM target where Thumb-2 is used without options but does not support executing the Armv8.1-M Mainline Low Overhead Loop instructions `DLS` and `LE`.

`arm_thumb2_ok_no_arm_v8_1_lob`

  ARM target generates Thumb-2 code for `-mthumb` but does not support executing the Armv8.1-M Mainline Low Overhead Loop instructions `DLS` and `LE`.

`mbranch_protection_ok`

  ARM target supporting `-mbranch-protection=standard`.

`arm_pacbti_hw`

  Test system supports for executing non nop pacbti instructions.

`arm_mixed_fp`

  On Arm targets, true when the target uses hardware instructions for single-precision floatint-point values, but software emulation for double-precision values.

#### 6.2.3.9 AArch64-specific attributes ¶

`aarch64_asm_<ext>_ok`

  AArch64 assembler supports the architecture extension `ext` via the `.arch_extension` pseudo-op.

`aarch64_tiny`

  AArch64 target which generates instruction sequences for tiny memory model.

`aarch64_small`

  AArch64 target which generates instruction sequences for small memory model.

`aarch64_large`

  AArch64 target which generates instruction sequences for large memory model.

`aarch64_little_endian`

  AArch64 target which generates instruction sequences for little endian.

`aarch64_big_endian`

  AArch64 target which generates instruction sequences for big endian.

`aarch64_small_fpic`

  Binutils installed on test system supports relocation types required by -fpic for AArch64 small memory model.

`aarch64_sme`

  AArch64 target that generates instructions for SME.

`aarch64_sme2`

  AArch64 target that generates instructions for SME2.

`aarch64_sve_hw`

  AArch64 target that is able to generate and execute SVE code (regardless of whether it does so by default).

`aarch64_sve128_hw`
`aarch64_sve256_hw`
`aarch64_sve512_hw`
`aarch64_sve1024_hw`
`aarch64_sve2048_hw`

  Like `aarch64_sve_hw`, but also test for an exact hardware vector length.

`aarch64_sve2_hw`

  AArch64 target that is able to generate and execute SVE2 code (regardless of whether it does so by default).

`aarch64_sve2p1_hw`

  AArch64 target that is able to generate and execute SVE2.1 code (regardless of whether it does so by default).

`aarch64_sme_hw`

  AArch64 target that is able to generate and execute SME code (regardless of whether it does so by default).

`aarch64_fjcvtzs_hw`

  AArch64 target that is able to generate and execute armv8.3-a FJCVTZS instruction.

#### 6.2.3.10 LoongArch specific attributes ¶

`loongarch_sx`

  LoongArch target that generates instructions for SX.

`loongarch_asx`

  LoongArch target that generates instructions for ASX.

`loongarch_sx_hw`

  LoongArch target that is able to generate and execute SX code.

`loongarch_asx_hw`

  LoongArch target that is able to generate and execute ASX code.

`loongarch_call36_support`

  LoongArch binutils supports call36 relocation.

#### 6.2.3.11 MIPS-specific attributes ¶

`mips64`

  MIPS target supports 64-bit instructions.

`nomips16`

  MIPS target does not produce MIPS16 code.

`mips16_attribute`

  MIPS target can generate MIPS16 code.

`mips_loongson`

  MIPS target is a Loongson-2E or -2F target using an ABI that supports the Loongson vector modes.

`mips_msa`

  MIPS target supports `-mmsa`, MIPS SIMD Architecture (MSA).

`mips_newabi_large_long_double`

  MIPS target supports `long double` larger than `double` when using the new ABI.

`mpaired_single`

  MIPS target supports `-mpaired-single`.

#### 6.2.3.12 MSP430-specific attributes ¶

`msp430_small`

  MSP430 target has the small memory model enabled (`-msmall`).

`msp430_large`

  MSP430 target has the large memory model enabled (`-mlarge`).

#### 6.2.3.13 nvptx-specific attributes ¶

`nvptx_default_ptx_isa_version_at_least_6_0`

  nvptx code by default compiles for at least PTX ISA version 6.0.

`nvptx_runtime_alias_ptx`

  The nvptx runtime environment supports the PTX ISA directive `.alias`.

`nvptx_runtime_alloca_ptx`

  The nvptx runtime environment supports PTX ’alloca’.

`nvptx_softstack`

  nvptx `-msoft-stack` is enabled.

#### 6.2.3.14 PowerPC-specific attributes ¶

`dfp_hw`

  PowerPC target supports executing hardware DFP instructions.

`p8vector_hw`

  PowerPC target supports executing VSX instructions (ISA 2.07).

`powerpc64`

  Test system supports executing 64-bit instructions.

`powerpc_altivec`

  PowerPC target supports AltiVec.

`powerpc_altivec_ok`

  PowerPC target supports `-maltivec`.

`powerpc_eabi_ok`

  PowerPC target supports `-meabi`.

`powerpc_elfv2`

  PowerPC target supports `-mabi=elfv2`.

`powerpc_fprs`

  PowerPC target supports floating-point registers.

`powerpc_hard_double`

  PowerPC target supports hardware double-precision floating-point.

`powerpc_htm_ok`

  PowerPC target supports `-mhtm`

`powerpc_popcntb_ok`

  PowerPC target supports the `popcntb` instruction, indicating that this target supports `-mcpu=power5`.

`powerpc_ppu_ok`

  PowerPC target supports `-mcpu=cell`.

`powerpc_spe`

  PowerPC target supports PowerPC SPE.

`powerpc_spe_nocache`

  Including the options used to compile this particular test, the PowerPC target supports PowerPC SPE.

`powerpc_spu`

  PowerPC target supports PowerPC SPU.

`powerpc_vsx_ok`

  PowerPC target supports `-mvsx`.

`powerpc_405_nocache`

  Including the options used to compile this particular test, the PowerPC target supports PowerPC 405.

`ppc_recip_hw`

  PowerPC target supports executing reciprocal estimate instructions.

`vmx_hw`

  PowerPC target supports executing AltiVec instructions.

`vsx_hw`

  PowerPC target supports executing VSX instructions (ISA 2.06).

`has_arch_pwr5`

  PowerPC target pre-defines macro _ARCH_PWR5 which means the `-mcpu` setting is Power5 or later.

`has_arch_pwr6`

  PowerPC target pre-defines macro _ARCH_PWR6 which means the `-mcpu` setting is Power6 or later.

`has_arch_pwr7`

  PowerPC target pre-defines macro _ARCH_PWR7 which means the `-mcpu` setting is Power7 or later.

`has_arch_pwr8`

  PowerPC target pre-defines macro _ARCH_PWR8 which means the `-mcpu` setting is Power8 or later.

`has_arch_pwr9`

  PowerPC target pre-defines macro _ARCH_PWR9 which means the `-mcpu` setting is Power9 or later.

#### 6.2.3.15 RISC-V specific attributes ¶

`rv32`

  Test system has an integer register width of 32 bits.

`rv64`

  Test system has an integer register width of 64 bits.

`riscv_a`

  Test target architecture has support for the A extension.

`riscv_b_ok`

  Test target architecture can execute code with B extension enabled.

`riscv_v_ok`

  Test target architecture can execute code with V extension enabled.

`riscv_zaamo`

  Test target architecture has support for the zaamo extension.

`riscv_zabha`

  Test target architecture has support for the zabha extension.

`riscv_zacas`

  Test target architecture has support for the zacas extension.

`riscv_zalrsc`

  Test target architecture has support for the zalrsc extension.

`riscv_zbc`

  Test target architecture has support for the zbc extension.

`riscv_zbc_ok`

  Test target architecture can execute code with zbc extension enabled.

`riscv_zbkb`

  Test target architecture has support for the zbkb extension.

`riscv_zbkb_ok`

  Test target architecture can execute code with zbkb extension enabled.

`riscv_zbkc`

  Test target architecture has support for the zbkc extension.

`riscv_zbkc_ok`

  Test target architecture can execute code with zbkc extension enabled.

`riscv_ztso`

  Test target architecture has support for the ztso extension.

#### 6.2.3.16 CORE-V specific attributes ¶

`cv_mac`

  Test system has support for the CORE-V MAC extension.

`cv_alu`

  Test system has support for the CORE-V ALU extension.

`cv_elw`

  Test system has support for the CORE-V ELW extension.

`cv_simd`

  Test system has support for the CORE-V SIMD extension.

`cv_bi`

  Test system has support for the CORE-V BI extension.

#### 6.2.3.17 Other hardware attributes ¶

`autoincdec`

  Target supports autoincrement/decrement addressing.

`avx`

  Target supports compiling `avx` instructions.

`avx_runtime`

  Target supports the execution of `avx` instructions.

`avx10.1`

  Target supports the execution of `avx10.1` instructions.

`avx10.2`

  Target supports the execution of `avx10.2` instructions.

`avx2`

  Target supports compiling `avx2` instructions.

`avx2_runtime`

  Target supports the execution of `avx2` instructions.

`avxvnni`

  Target supports the execution of `avxvnni` instructions.

`avx512f`

  Target supports compiling `avx512f` instructions.

`avx512f_runtime`

  Target supports the execution of `avx512f` instructions.

`avx512vp2intersect`

  Target supports the execution of `avx512vp2intersect` instructions.

`avxifma`

  Target supports the execution of `avxifma` instructions.

`avxneconvert`

  Target supports the execution of `avxneconvert` instructions.

`avxvnniint8`

  Target supports the execution of `avxvnniint8` instructions.

`avxvnniint16`

  Target supports the execution of `avxvnniint16` instructions.

`amx_tile`

  Target supports the execution of `amx-tile` instructions.

`amx_int8`

  Target supports the execution of `amx-int8` instructions.

`amx_bf16`

  Target supports the execution of `amx-bf16` instructions.

`amx_avx512`

  Target supports the execution of `amx-avx512` instructions.

`amx_complex`

  Target supports the execution of `amx-complex` instructions.

`amx_fp16`

  Target supports the execution of `amx-fp16` instructions.

`amx_movrs`

  Target supports the execution of `amx-movrs` instructions.

`amx_fp8`

  Target supports the execution of `amx-fp8` instructions.

`cell_hw`

  Test system can execute AltiVec and Cell PPU instructions.

`clz`

  Target supports a clz optab on int.

`clzl`

  Target supports a clz optab on long.

`clzll`

  Target supports a clz optab on long long.

`ctz`

  Target supports a ctz optab on int.

`ctzl`

  Target supports a ctz optab on long.

`ctzll`

  Target supports a ctz optab on long long.

`cmpccxadd`

  Target supports the execution of `cmpccxadd` instructions.

`coldfire_fpu`

  Target uses a ColdFire FPU.

`divmod`

  Target supporting hardware divmod insn or divmod libcall.

`divmod_simode`

  Target supporting hardware divmod insn or divmod libcall for SImode.

`hard_float`

  Target supports FPU instructions.

`movrs`

  Target supports the execution of `movrs` instructions.

`non_strict_align`

  Target does not require strict alignment.

`opt_mstrict_align`

  Target supports `-mstrict-align` and `-mno-strict-align`.

`pie_copyreloc`

  The x86-64 target linker supports PIE with copy reloc.

`popcount`

  Target supports a popcount optab on int.

`popcountl`

  Target supports a popcount optab on long.

`popcountll`

  Target supports a popcount optab on long long.

`prefetchi`

  Target supports the execution of `prefetchi` instructions.

`raoint`

  Target supports the execution of `raoint` instructions.

`rdrand`

  Target supports x86 `rdrand` instruction.

`sha512`

  Target supports the execution of `sha512` instructions.

`sm3`

  Target supports the execution of `sm3` instructions.

`sm4`

  Target supports the execution of `sm4` instructions.

`sqrt_insn`

  Target has a square root instruction that the compiler can generate.

`sse`

  Target supports compiling `sse` instructions.

`sse_runtime`

  Target supports the execution of `sse` instructions.

`sse2`

  Target supports compiling `sse2` instructions.

`sse2_runtime`

  Target supports the execution of `sse2` instructions.

`sync_char_short`

  Target supports atomic operations on `char` and `short`.

`sync_int_long`

  Target supports atomic operations on `int` and `long`.

`ultrasparc_hw`

  Test environment appears to run executables on a simulator that accepts only `EM_SPARC` executables and chokes on `EM_SPARC32PLUS` or `EM_SPARCV9` executables.

`user_msr`

  Target supports the execution of `user_msr` instructions.

`vect_cmdline_needed`

  Target requires a command line argument to enable a SIMD instruction set.

`x86`

  Target is ia32 or x86_64.

`xorsign`

  Target supports the xorsign optab expansion.

`ifn_copysign`

  Target supports the copysign optab expansion of float and double for both scalar and vector modes.

#### 6.2.3.18 Environment attributes ¶

`alarm`

  Target supports `alarm`.

`c`

  The language for the compiler under test is C.

`c++`

  The language for the compiler under test is C++.

`c99_runtime`

  Target provides a full C99 runtime.

`cfi`

  Target supports DWARF CFI directives.

`correct_iso_cpp_string_wchar_protos`

  Target `string.h` and `wchar.h` headers provide C++ required overloads for `strchr` etc. functions.

`d_runtime`

  Target provides the D runtime.

`d_runtime_has_std_library`

  Target provides the D standard library (Phobos).

`dummy_wcsftime`

  Target uses a dummy `wcsftime` function that always returns zero.

`fd_truncate`

  Target can truncate a file from a file descriptor, as used by `libgfortran/io/unix.c:fd_truncate`; i.e. `ftruncate` or `chsize`.

`fenv`

  Target provides `fenv.h` include file.

`fenv_exceptions`

  Target supports `fenv.h` with all the standard IEEE exceptions and floating-point exceptions are raised by arithmetic operations.

`fenv_exceptions_dfp`

  Target supports `fenv.h` with all the standard IEEE exceptions and floating-point exceptions are raised by arithmetic operations for decimal floating point.

`fileio`

  Target offers such file I/O library functions as `fopen`, `fclose`, `tmpnam`, and `remove`. This is a link-time requirement for the presence of the functions in the library; even if they fail at runtime, the requirement is still regarded as satisfied.

`freestanding`

  Target is ‘`freestanding`’ as defined in section 4 of the C99 standard. Effectively, it is a target which supports no extra headers or libraries other than what is considered essential.

`hostedlib`

  Target is not ‘`freestanding`’, and, if the language is C++, `libstdc++`’s hosted mode is not disabled.

`gettimeofday`

  Target supports `gettimeofday`.

`init_priority`

  Target supports constructors with initialization priority arguments.

`inttypes_types`

  Target has the basic signed and unsigned types in `inttypes.h`. This is for tests that GCC’s notions of these types agree with those in the header, as some systems have only `inttypes.h`.

`lax_strtofp`

  Target might have errors of a few ULP in string to floating-point conversion functions and overflow is not always detected correctly by those functions.

`mempcpy`

  Target provides `mempcpy` function.

`mmap`

  Target supports `mmap`.

`newlib`

  Target supports Newlib.

`newlib_nano_io`

  GCC was configured with `--enable-newlib-nano-formatted-io`, which reduces the code size of Newlib formatted I/O functions.

`posix_memalign`

  Target supports `posix_memalign`.

`pow10`

  Target provides `pow10` function.

`pthread`

  Target can compile using `pthread.h` with no errors or warnings.

`pthread_h`

  Target has `pthread.h`.

`sleep`

  Target supports `sleep`.

`sockets`

  Target can compile using `sys/socket.h` with no errors or warnings.

`run_expensive_tests`

  Expensive testcases (usually those that consume excessive amounts of CPU time) should be run on this target. This can be enabled by setting the `GCC_TEST_RUN_EXPENSIVE` environment variable to a non-empty string.

`simulator`

  Test system runs executables on a simulator (i.e. slowly) rather than hardware (i.e. fast).

`signal`

  Target has `signal.h`.

`stabs`

  Target supports the stabs debugging format.

`stdint_types`

  Target has the basic signed and unsigned C types in `stdint.h`. This will be obsolete when GCC ensures a working `stdint.h` for all targets.

`stdint_types_mbig_endian`

  Target accepts the option `-mbig-endian` and `stdint.h` can be included without error when `-mbig-endian` is passed.

`stpcpy`

  Target provides `stpcpy` function.

`strndup`

  Target provides `strndup` function.

`sysconf`

  Target supports `sysconf`.

`trampolines`

  Target supports trampolines.

`variadic_mi_thunk`

  Target supports C++ virtual variadic function calls with multiple inheritance.

`two_plus_gigs`

  Target supports linking programs with 2+GiB of data.

`uclibc`

  Target supports uClibc.

`unwrapped`

  Target does not use a status wrapper.

`vxworks_kernel`

  Target is a VxWorks kernel.

`vxworks_rtp`

  Target is a VxWorks RTP.

`wchar`

  Target supports wide characters.

`weak_undefined`

  Target supports weak undefined symbols

#### 6.2.3.19 Other attributes ¶

`R_flag_in_section`

  Target supports the ’R’ flag in .section directive in assembly inputs.

`asm_goto_with_outputs`

  Target supports ’asm goto’ with outputs.

`automatic_stack_alignment`

  Target supports automatic stack alignment.

`branch_cost`

  Target supports `-branch-cost=N`.

`const_volatile_readonly_section`

  Target places const volatile variables in readonly sections.

`cxa_atexit`

  Target uses `__cxa_atexit`.

`default_packed`

  Target has packed layout of structure members by default.

`exceptions`

  Target supports exception handling. Note that this is orthogonal to effective-target `exceptions_enabled`.

`exceptions_enabled`

  Testing configuration has exception handling enabled. Note that this is orthogonal to effective-target `exceptions`.

`using_sjlj_exceptions`

  Target uses `setjmp` and `longjmp` for implementing exceptions.

`fgraphite`

  Target supports Graphite optimizations.

`fixed_point`

  Target supports fixed-point extension to C.

`bitint`

  Target supports _BitInt(N).

`bitint128`

  Target supports _BitInt(128).

`bitint575`

  Target supports _BitInt(575).

`bitint65535`

  Target supports _BitInt(65535).

`fopenacc`

  Target supports OpenACC via `-fopenacc`.

`fopenmp`

  Target supports OpenMP via `-fopenmp`.

`fpic`

  Target supports `-fpic` and `-fPIC`.

`freorder`

  Target supports `-freorder-blocks-and-partition`.

`fstack_protector`

  Target supports `-fstack-protector`.

`gas`

  Target uses GNU `as`.

`gc_sections`

  Target supports `--gc-sections`.

`gld`

  Target uses GNU `ld`.

`keeps_null_pointer_checks`

  Target keeps null pointer checks, either due to the use of `-fno-delete-null-pointer-checks` or hardwired into the target.

`llvm_binutils`

  Target is using an LLVM assembler and/or linker, instead of GNU Binutils.

`lra`

  Target supports local register allocator (LRA). This must not be called (results in `ERROR`) for targets that don’t do register allocation, and therefore neither use nor don’t use LRA.

`lto`

  Compiler has been configured to support link-time optimization (LTO).

`lto_incremental`

  Compiler and linker support link-time optimization relocatable linking with `-r` and `-flto` options.

`thread_fence`

  Target implements `__atomic_thread_fence` without relying on non-implemented `__sync_synchronize()`.

`naked_functions`

  Target supports the `naked` function attribute.

`named_sections`

  Target supports named sections.

`natural_alignment_32`

  Target uses natural alignment (aligned to type size) for types of 32 bits or less.

`tail_call`

  Target supports tail-call optimizations.

`target_natural_alignment_64`

  Target uses natural alignment (aligned to type size) for types of 64 bits or less.

`no_alignment_constraints`

  Target defines __BIGGEST_ALIGNMENT__=1. Hence target imposes no alignment constraints. This is similar, but not necessarily the same as default_packed. Although `BIGGEST_FIELD_ALIGNMENT` defaults to `BIGGEST_ALIGNMENT` for most targets, it is possible for a target to set those two with different values and have different alignment constraints for aggregate and non-aggregate types.

`noinit`

  Target supports the `noinit` variable attribute.

`nonpic`

  Target does not generate PIC by default.

`o_flag_in_section`

  Target supports the ’o’ flag in .section directive in assembly inputs.

`offload_gcn`

  Target has been configured for OpenACC/OpenMP offloading on AMD GCN.

`persistent`

  Target supports the `persistent` variable attribute.

`pie_enabled`

  Target generates PIE by default.

`pcc_bitfield_type_matters`

  Target defines `PCC_BITFIELD_TYPE_MATTERS`.

`pe_aligned_commons`

  Target supports `-mpe-aligned-commons`.

`pie`

  Target supports `-pie`, `-fpie` and `-fPIE`.

`linker_plugin`

  Target supports the linker plugin.

`rdynamic`

  Target supports `-rdynamic`.

`scalar_all_fma`

  Target supports all four fused multiply-add optabs for both `float` and `double`. These optabs are: `fma_optab`, `fms_optab`, `fnma_optab` and `fnms_optab`.

`section_anchors`

  Target supports section anchors.

`short_enums`

  Target defaults to short enums.

`stack_size`

  Target has limited stack size. The stack size limit can be obtained using the STACK_SIZE macro defined by `dg-add-options` feature `stack_size`.

  Note that for certain targets, stack size limits are relevant for execution only, and therefore considered only if `dg-do run` is in effect, otherwise unlimited.

`static`

  Target supports `-static`.

`static_libgfortran`

  Target supports statically linking ‘`libgfortran`’.

`string_merging`

  Target supports merging string constants at link time.

`strub`

  Target supports attribute `strub` for stack scrubbing.

`ucn`

  Target supports compiling and assembling UCN.

`ucn_nocache`

  Including the options used to compile this particular test, the target supports compiling and assembling UCN.

`unaligned_stack`

  Target does not guarantee that its `STACK_BOUNDARY` is greater than or equal to the required vector alignment.

`vector_alignment_reachable`

  Vector alignment is reachable for types of 32 bits or less.

`vector_alignment_reachable_for_64bit`

  Vector alignment is reachable for types of 64 bits or less.

`vma_equals_lma`

  Target generates executable with VMA equal to LMA for .data section.

`wchar_t_char16_t_compatible`

  Target supports `wchar_t` that is compatible with `char16_t`.

`wchar_t_char32_t_compatible`

  Target supports `wchar_t` that is compatible with `char32_t`.

`comdat_group`

  Target uses comdat groups.

`indirect_calls`

  Target supports indirect calls, i.e. calls where the target is not constant.

`lgccjit`

  Target supports -lgccjit, i.e. libgccjit.so can be linked into jit tests.

`__OPTIMIZE__`

  Optimizations are enabled (`__OPTIMIZE__`) per the current compiler flags.

#### 6.2.3.20 Local to tests in `gcc.target/i386` ¶

`3dnow`

  Target supports compiling `3dnow` instructions.

`aes`

  Target supports compiling `aes` instructions.

`fma4`

  Target supports compiling `fma4` instructions.

`mfentry`

  Target supports the `-mfentry` option that alters the position of profiling calls such that they precede the prologue.

`ms_hook_prologue`

  Target supports attribute `ms_hook_prologue`.

`pclmul`

  Target supports compiling `pclmul` instructions.

`sse3`

  Target supports compiling `sse3` instructions.

`sse4`

  Target supports compiling `sse4` instructions.

`sse4a`

  Target supports compiling `sse4a` instructions.

`ssse3`

  Target supports compiling `ssse3` instructions.

`vaes`

  Target supports compiling `vaes` instructions.

`vpclmul`

  Target supports compiling `vpclmul` instructions.

`xop`

  Target supports compiling `xop` instructions.

#### 6.2.3.21 Local to tests in `gcc.test-framework` ¶

`no`

  Always returns 0.

`yes`

  Always returns 1.