Struct rustc_ap_rustc_target::spec::TargetOptions

pub struct TargetOptions {

    pub is_builtin: bool,
    pub endian: Endian,
    pub c_int_width: String,
    pub os: String,
    pub env: String,
    pub vendor: String,
    pub linker_flavor: LinkerFlavor,
    pub linker: Option<String>,
    pub lld_flavor: LldFlavor,
    pub pre_link_args: LinkArgs,
    pub pre_link_objects: CrtObjects,
    pub post_link_objects: CrtObjects,
    pub pre_link_objects_fallback: CrtObjects,
    pub post_link_objects_fallback: CrtObjects,
    pub crt_objects_fallback: Option<CrtObjectsFallback>,
    pub late_link_args: LinkArgs,
    pub late_link_args_dynamic: LinkArgs,
    pub late_link_args_static: LinkArgs,
    pub post_link_args: LinkArgs,
    pub link_script: Option<String>,
    pub link_env: Vec<(String, String)>,
    pub link_env_remove: Vec<String>,
    pub asm_args: Vec<String>,
    pub cpu: String,
    pub features: String,
    pub dynamic_linking: bool,
    pub only_cdylib: bool,
    pub executables: bool,
    pub relocation_model: RelocModel,
    pub code_model: Option<CodeModel>,
    pub tls_model: TlsModel,
    pub disable_redzone: bool,
    pub frame_pointer: FramePointer,
    pub function_sections: bool,
    pub dll_prefix: String,
    pub dll_suffix: String,
    pub exe_suffix: String,
    pub staticlib_prefix: String,
    pub staticlib_suffix: String,
    pub families: Vec<String>,
    pub abi_return_struct_as_int: bool,
    pub is_like_osx: bool,
    pub is_like_solaris: bool,
    pub is_like_windows: bool,
    pub is_like_msvc: bool,
    pub is_like_emscripten: bool,
    pub is_like_fuchsia: bool,
    pub is_like_wasm: bool,
    pub dwarf_version: Option<u32>,
    pub linker_is_gnu: bool,
    pub allows_weak_linkage: bool,
    pub has_rpath: bool,
    pub no_default_libraries: bool,
    pub position_independent_executables: bool,
    pub static_position_independent_executables: bool,
    pub needs_plt: bool,
    pub relro_level: RelroLevel,
    pub archive_format: String,
    pub allow_asm: bool,
    pub main_needs_argc_argv: bool,
    pub has_elf_tls: bool,
    pub obj_is_bitcode: bool,
    pub forces_embed_bitcode: bool,
    pub bitcode_llvm_cmdline: String,
    pub min_atomic_width: Option<u64>,
    pub max_atomic_width: Option<u64>,
    pub atomic_cas: bool,
    pub panic_strategy: PanicStrategy,
    pub unsupported_abis: Vec<Abi>,
    pub crt_static_allows_dylibs: bool,
    pub crt_static_default: bool,
    pub crt_static_respected: bool,
    pub stack_probes: StackProbeType,
    pub min_global_align: Option<u64>,
    pub default_codegen_units: Option<u64>,
    pub trap_unreachable: bool,
    pub requires_lto: bool,
    pub singlethread: bool,
    pub no_builtins: bool,
    pub default_hidden_visibility: bool,
    pub emit_debug_gdb_scripts: bool,
    pub requires_uwtable: bool,
    pub default_uwtable: bool,
    pub simd_types_indirect: bool,
    pub limit_rdylib_exports: bool,
    pub override_export_symbols: Option<Vec<String>>,
    pub merge_functions: MergeFunctions,
    pub mcount: String,
    pub llvm_abiname: String,
    pub relax_elf_relocations: bool,
    pub llvm_args: Vec<String>,
    pub use_ctors_section: bool,
    pub eh_frame_header: bool,
    pub has_thumb_interworking: bool,
    pub split_debuginfo: SplitDebuginfo,
    pub supported_sanitizers: SanitizerSet,
    pub default_adjusted_cabi: Option<Abi>,
}

Optional aspects of a target specification.

This has an implementation of Default, see each field for what the default is. In general, these try to take “minimal defaults” that don’t assume anything about the runtime they run in.

TargetOptions as a separate structure is mostly an implementation detail of Target construction, all its fields logically belong to Target and available from Target through Deref impls.

Fields

is_builtin: bool

Whether the target is built-in or loaded from a custom target specification.

endian: Endian

Used as the target_endian cfg variable. Defaults to little endian.

c_int_width: String

Width of c_int type. Defaults to “32”.

os: String

OS name to use for conditional compilation (target_os). Defaults to “none”. “none” implies a bare metal target without std library. A couple of targets having std also use “unknown” as an os value, but they are exceptions.

env: String

Environment name to use for conditional compilation (target_env). Defaults to “”.

vendor: String

Vendor name to use for conditional compilation (target_vendor). Defaults to “unknown”.

linker_flavor: LinkerFlavor

Default linker flavor used if -C linker-flavor or -C linker are not passed on the command line. Defaults to LinkerFlavor::Gcc.

linker: Option<String>

Linker to invoke

lld_flavor: LldFlavor

LLD flavor used if lld (or rust-lld) is specified as a linker without clarifying its flavor in any way.

pre_link_args: LinkArgs

Linker arguments that are passed before any user-defined libraries.

pre_link_objects: CrtObjects

Objects to link before and after all other object code.

post_link_objects: CrtObjects

pre_link_objects_fallback: CrtObjects

Same as (pre|post)_link_objects, but when we fail to pull the objects with help of the target’s native gcc and fall back to the “self-contained” mode and pull them manually. See crt_objects.rs for some more detailed documentation.

post_link_objects_fallback: CrtObjects

crt_objects_fallback: Option<CrtObjectsFallback>

Which logic to use to determine whether to fall back to the “self-contained” mode or not.

late_link_args: LinkArgs

Linker arguments that are unconditionally passed after any user-defined but before post-link objects. Standard platform libraries that should be always be linked to, usually go here.

late_link_args_dynamic: LinkArgs

Linker arguments used in addition to late_link_args if at least one Rust dependency is dynamically linked.

late_link_args_static: LinkArgs

Linker arguments used in addition to late_link_args if aall Rust dependencies are statically linked.

post_link_args: LinkArgs

Linker arguments that are unconditionally passed after any user-defined libraries.

link_script: Option<String>

Optional link script applied to dylib and executable crate types. This is a string containing the script, not a path. Can only be applied to linkers where linker_is_gnu is true.

link_env: Vec<(String, String)>

Environment variables to be set for the linker invocation.

link_env_remove: Vec<String>

Environment variables to be removed for the linker invocation.

asm_args: Vec<String>

Extra arguments to pass to the external assembler (when used)

cpu: String

Default CPU to pass to LLVM. Corresponds to llc -mcpu=$cpu. Defaults to “generic”.

features: String

Default target features to pass to LLVM. These features will always be passed, and cannot be disabled even via -C. Corresponds to llc -mattr=$features.

dynamic_linking: bool

Whether dynamic linking is available on this target. Defaults to false.

only_cdylib: bool

If dynamic linking is available, whether only cdylibs are supported.

executables: bool

Whether executables are available on this target. iOS, for example, only allows static libraries. Defaults to false.

relocation_model: RelocModel

Relocation model to use in object file. Corresponds to llc -relocation-model=$relocation_model. Defaults to Pic.

code_model: Option<CodeModel>

Code model to use. Corresponds to llc -code-model=$code_model. Defaults to None which means “inherited from the base LLVM target”.

tls_model: TlsModel

TLS model to use. Options are “global-dynamic” (default), “local-dynamic”, “initial-exec” and “local-exec”. This is similar to the -ftls-model option in GCC/Clang.

disable_redzone: bool

Do not emit code that uses the “red zone”, if the ABI has one. Defaults to false.

frame_pointer: FramePointer

Frame pointer mode for this target. Defaults to MayOmit.

function_sections: bool

Emit each function in its own section. Defaults to true.

dll_prefix: String

String to prepend to the name of every dynamic library. Defaults to “lib”.

dll_suffix: String

String to append to the name of every dynamic library. Defaults to “.so”.

exe_suffix: String

String to append to the name of every executable.

staticlib_prefix: String

String to prepend to the name of every static library. Defaults to “lib”.

staticlib_suffix: String

String to append to the name of every static library. Defaults to “.a”.

families: Vec<String>

Values of the target_family cfg set for this target.

Common options are: “unix”, “windows”. Defaults to no families.

See https://doc.rust-lang.org/reference/conditional-compilation.html#target_family.

abi_return_struct_as_int: bool

Whether the target toolchain’s ABI supports returning small structs as an integer.

is_like_osx: bool

Whether the target toolchain is like macOS’s. Only useful for compiling against iOS/macOS, in particular running dsymutil and some other stuff like -dead_strip. Defaults to false.

is_like_solaris: bool

Whether the target toolchain is like Solaris’s. Only useful for compiling against Illumos/Solaris, as they have a different set of linker flags. Defaults to false.

is_like_windows: bool

Whether the target is like Windows. This is a combination of several more specific properties represented as a single flag:

• The target uses a Windows ABI,
• uses PE/COFF as a format for object code,
• uses Windows-style dllexport/dllimport for shared libraries,
• uses import libraries and .def files for symbol exports,
• executables support setting a subsystem.

is_like_msvc: bool

Whether the target is like MSVC. This is a combination of several more specific properties represented as a single flag:

• The target has all the properties from is_like_windows (for in-tree targets “is_like_msvc ⇒ is_like_windows” is ensured by a unit test),
• has some MSVC-specific Windows ABI properties,
• uses a link.exe-like linker,
• uses CodeView/PDB for debuginfo and natvis for its visualization,
• uses SEH-based unwinding,
• supports control flow guard mechanism.

is_like_emscripten: bool

Whether the target toolchain is like Emscripten’s. Only useful for compiling with Emscripten toolchain. Defaults to false.

is_like_fuchsia: bool

Whether the target toolchain is like Fuchsia’s.

is_like_wasm: bool

Whether a target toolchain is like WASM.

dwarf_version: Option<u32>

Version of DWARF to use if not using the default. Useful because some platforms (osx, bsd) only want up to DWARF2.

linker_is_gnu: bool

Whether the linker support GNU-like arguments such as -O. Defaults to true.

allows_weak_linkage: bool

The MinGW toolchain has a known issue that prevents it from correctly handling COFF object files with more than 2¹⁵ sections. Since each weak symbol needs its own COMDAT section, weak linkage implies a large number sections that easily exceeds the given limit for larger codebases. Consequently we want a way to disallow weak linkage on some platforms.

has_rpath: bool

Whether the linker support rpaths or not. Defaults to false.

no_default_libraries: bool

Whether to disable linking to the default libraries, typically corresponds to -nodefaultlibs. Defaults to true.

position_independent_executables: bool

Dynamically linked executables can be compiled as position independent if the default relocation model of position independent code is not changed. This is a requirement to take advantage of ASLR, as otherwise the functions in the executable are not randomized and can be used during an exploit of a vulnerability in any code.

static_position_independent_executables: bool

Executables that are both statically linked and position-independent are supported.

needs_plt: bool

Determines if the target always requires using the PLT for indirect library calls or not. This controls the default value of the -Z plt flag.

relro_level: RelroLevel

Either partial, full, or off. Full RELRO makes the dynamic linker resolve all symbols at startup and marks the GOT read-only before starting the program, preventing overwriting the GOT.

archive_format: String

Format that archives should be emitted in. This affects whether we use LLVM to assemble an archive or fall back to the system linker, and currently only “gnu” is used to fall into LLVM. Unknown strings cause the system linker to be used.

allow_asm: bool

Is asm!() allowed? Defaults to true.

main_needs_argc_argv: bool

Whether the runtime startup code requires the main function be passed argc and argv values.

has_elf_tls: bool

Flag indicating whether ELF TLS (e.g., #thread_local) is available for this target.

obj_is_bitcode: bool

forces_embed_bitcode: bool

Whether the target requires that emitted object code includes bitcode.

bitcode_llvm_cmdline: String

Content of the LLVM cmdline section associated with embedded bitcode.

min_atomic_width: Option<u64>

Don’t use this field; instead use the .min_atomic_width() method.

max_atomic_width: Option<u64>

Don’t use this field; instead use the .max_atomic_width() method.

atomic_cas: bool

Whether the target supports atomic CAS operations natively

panic_strategy: PanicStrategy

Panic strategy: “unwind” or “abort”

unsupported_abis: Vec<Abi>

A list of ABIs unsupported by the current target. Note that generic ABIs are considered to be supported on all platforms and cannot be marked unsupported.

crt_static_allows_dylibs: bool

Whether or not linking dylibs to a static CRT is allowed.

crt_static_default: bool

Whether or not the CRT is statically linked by default.

crt_static_respected: bool

Whether or not crt-static is respected by the compiler (or is a no-op).

stack_probes: StackProbeType

The implementation of stack probes to use.

min_global_align: Option<u64>

The minimum alignment for global symbols.

default_codegen_units: Option<u64>

Default number of codegen units to use in debug mode

trap_unreachable: bool

Whether to generate trap instructions in places where optimization would otherwise produce control flow that falls through into unrelated memory.

requires_lto: bool

This target requires everything to be compiled with LTO to emit a final executable, aka there is no native linker for this target.

singlethread: bool

This target has no support for threads.

no_builtins: bool

Whether library functions call lowering/optimization is disabled in LLVM for this target unconditionally.

default_hidden_visibility: bool

The default visibility for symbols in this target should be “hidden” rather than “default”

emit_debug_gdb_scripts: bool

Whether a .debug_gdb_scripts section will be added to the output object file

requires_uwtable: bool

Whether or not to unconditionally uwtable attributes on functions, typically because the platform needs to unwind for things like stack unwinders.

default_uwtable: bool

Whether or not to emit uwtable attributes on functions if -C force-unwind-tables is not specified and uwtable is not required on this target.

simd_types_indirect: bool

Whether or not SIMD types are passed by reference in the Rust ABI, typically required if a target can be compiled with a mixed set of target features. This is true by default, and false for targets like wasm32 where the whole program either has simd or not.

limit_rdylib_exports: bool

Pass a list of symbol which should be exported in the dylib to the linker.

override_export_symbols: Option<Vec<String>>

If set, have the linker export exactly these symbols, instead of using the usual logic to figure this out from the crate itself.

merge_functions: MergeFunctions

Determines how or whether the MergeFunctions LLVM pass should run for this target. Either “disabled”, “trampolines”, or “aliases”. The MergeFunctions pass is generally useful, but some targets may need to opt out. The default is “aliases”.

Workaround for: https://github.com/rust-lang/rust/issues/57356

mcount: String

Use platform dependent mcount function

llvm_abiname: String

LLVM ABI name, corresponds to the ‘-mabi’ parameter available in multilib C compilers

relax_elf_relocations: bool

Whether or not RelaxElfRelocation flag will be passed to the linker

llvm_args: Vec<String>

Additional arguments to pass to LLVM, similar to the -C llvm-args codegen option.

use_ctors_section: bool

Whether to use legacy .ctors initialization hooks rather than .init_array. Defaults to false (uses .init_array).

eh_frame_header: bool

Whether the linker is instructed to add a GNU_EH_FRAME ELF header used to locate unwinding information is passed (only has effect if the linker is ld-like).

has_thumb_interworking: bool

Is true if the target is an ARM architecture using thumb v1 which allows for thumb and arm interworking.

split_debuginfo: SplitDebuginfo

How to handle split debug information, if at all. Specifying None has target-specific meaning.

supported_sanitizers: SanitizerSet

The sanitizers supported by this target

Note that the support here is at a codegen level. If the machine code with sanitizer enabled can generated on this target, but the necessary supporting libraries are not distributed with the target, the sanitizer should still appear in this list for the target.

default_adjusted_cabi: Option<Abi>

If present it’s a default value to use for adjusting the C ABI.

Trait Implementations

impl Clone for TargetOptions

fn clone(&self) -> TargetOptions

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TargetOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TargetOptions

fn default() -> TargetOptions

Creates a set of “sane defaults” for any target. This is still incomplete, and if used for compilation, will certainly not work.

impl PartialEq<TargetOptions> for TargetOptions

fn eq(&self, other: &TargetOptions) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &TargetOptions) -> bool

This method tests for !=.

impl StructuralPartialEq for TargetOptions