Struct Target

pub struct Target {
    pub llvm_target: Cow<'static, str>,
    pub metadata: TargetMetadata,
    pub pointer_width: u32,
    pub arch: Cow<'static, str>,
    pub data_layout: Cow<'static, str>,
    pub options: TargetOptions,
}

Everything rustc knows about how to compile for a specific target.

Every field here must be specified, and has no default value.

Fields

llvm_target: Cow<'static, str>

Unversioned target tuple to pass to LLVM.

Target tuples can optionally contain an OS version (notably Apple targets), which rustc cannot know without querying the environment.

Use rustc_codegen_ssa::back::versioned_llvm_target if you need the full LLVM target.

metadata: TargetMetadata

Metadata about a target, for example the description or tier. Used for generating target documentation.

pointer_width: u32

Number of bits in a pointer. Influences the target_pointer_width cfg variable.

arch: Cow<'static, str>

Architecture to use for ABI considerations. Valid options include: “x86”, “x86_64”, “arm”, “aarch64”, “mips”, “powerpc”, “powerpc64”, and others.

data_layout: Cow<'static, str>

Data layout to pass to LLVM.

options: TargetOptions

Optional settings with defaults.

Implementations

impl Target

pub fn from_json(obj: Json) -> Result<(Target, TargetWarnings), String>

Loads a target descriptor from a JSON object.

impl Target

pub fn parse_data_layout( &self, ) -> Result<TargetDataLayout, TargetDataLayoutErrors<'_>>

impl Target

pub fn adjust_abi(&self, abi: Abi, c_variadic: bool) -> Abi

Given a function ABI, turn it into the correct ABI for this target.

pub fn is_abi_supported(&self, abi: Abi) -> bool

pub fn min_atomic_width(&self) -> u64

Minimum integer size in bits that this target can perform atomic operations on.

pub fn max_atomic_width(&self) -> u64

Maximum integer size in bits that this target can perform atomic operations on.

fn check_consistency(&self, kind: TargetKind) -> Result<(), String>

Check some basic consistency of the current target. For JSON targets we are less strict; some of these checks are more guidelines than strict rules.

fn can_use_os_unknown(&self) -> bool

pub fn expect_builtin(target_tuple: &TargetTuple) -> Target

Load a built-in target

pub fn search( target_tuple: &TargetTuple, sysroot: &Path, ) -> Result<(Target, TargetWarnings), String>

Search for a JSON file specifying the given target tuple.

If none is found in $RUST_TARGET_PATH, look for a file called target.json inside the sysroot under the target-tuple’s rustlib directory. Note that it could also just be a bare filename already, so also check for that. If one of the hardcoded targets we know about, just return it directly.

The error string could come from any of the APIs called, including filesystem access and JSON decoding.

pub fn small_data_threshold_support(&self) -> SmallDataThresholdSupport

Return the target’s small data threshold support, converting DefaultForArch into a concrete value.

impl Target

pub fn rust_target_features( &self, ) -> &'static [(&'static str, StabilityUncomputed, &'static [&'static str])]

pub fn features_for_correct_vector_abi(&self) -> &'static [(u64, &'static str)]

pub fn tied_target_features(&self) -> &'static [&'static [&'static str]]

pub fn implied_target_features( &self, base_features: impl Iterator<Item = Symbol>, ) -> FxHashSet<Symbol>

Methods from Deref<Target = TargetOptions>

pub fn supports_comdat(&self) -> bool

fn add_pre_link_args(&mut self, flavor: LinkerFlavor, args: &[&'static str])

fn update_from_cli(&mut self)

fn update_to_cli(&mut self)

pub(crate) fn has_feature(&self, search_feature: &str) -> bool

pub(crate) fn has_neg_feature(&self, search_feature: &str) -> bool

Trait Implementations

impl Clone for Target

fn clone(&self) -> Target

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Target

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

Formats the value using the given formatter.

impl Deref for Target

TargetOptions being a separate type is basically an implementation detail of Target that is used for providing defaults. Perhaps there’s a way to merge TargetOptions into Target so this Deref implementation is no longer necessary.

type Target = TargetOptions

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Target

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl HasTargetSpec for Target

fn target_spec(&self) -> &Target

impl PartialEq for Target

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToJson for Target

fn to_json(&self) -> Json

impl StructuralPartialEq for Target

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 1344 bytes