Struct Triple 

pub struct Triple {
    pub arch: Arch,
    pub os: Os,
    pub env: Env,
}

A target triple.

We accept the LLVM-style arch-vendor-os-env form because that is what build systems pass, and we normalise it to the three fields we actually branch on. The vendor field is parsed and discarded: no decision in the compiler depends on it, and keeping it would invite one.

Fields

arch: Arch

The architecture.

os: Os

The operating system.

env: Env

The runtime and ABI variant.

Implementations

impl Triple

pub const fn new(arch: Arch, os: Os, env: Env) -> Self

A triple from its three parts.

pub fn tuple(self) -> TargetTuple

The same machine as a TargetTuple, which is what the layout and ABI descriptions are written over.

The tuple carries ten fields and this carries three, so this fills the other seven in from their defaults, and every one of those defaults is the answer for the targets this type can spell. There is no x32 here and no big-endian AArch64, so the data model and the byte order follow the architecture, and the sub-architecture, the versions and the float ABI have nothing to say about any of the combinations.

The environment is narrowed rather than copied across. This type will hold Triple { os: Darwin, env: Gnu }, because its parser takes the fields by content and aarch64-apple-darwin-gnu is a string somebody can type, and that is not a machine: a Darwin target has one libc and it is not glibc. A tuple refuses to describe one, so the pairs that are not machines are mapped to the environment the operating system actually has.

Panics

Never, for a triple this type can hold, which every_triple_describes_a_machine checks by building all forty eight of them.

pub fn from_tuple(target: TargetTuple) -> Option<Triple>

The triple that describes the same machine as target, if this type can spell it.

The inverse of Triple::tuple, and computed by running that function over every triple there is rather than by writing the narrowing out a second time. A second table would be a second thing to keep in step, and the failure it invites is not a compile error: it is one row of the matrix quietly answering as a neighbour.

It returns None for most of the target table, and that is the honest answer rather than a gap to be papered over. rucc-abi describes the scalar layout of all forty two rows, and this type holds three fields with three architectures in the first, so seventeen of those rows have a TargetInfo and the other twenty five do not. Anything that needs to lay a record out for s390x-linux-gnu needs that gap closed rather than an approximation of it.

The environment of the answer is the narrowed one, so the triple this gives back is the canonical spelling of that machine: Env::None on Darwin and on a freestanding target, never the Env::Gnu that a parser will accept from a string somebody typed.

pub fn host() -> Option<Self>

The triple of the machine this compiler is running on.

Used as the default target, which is what makes rucc hello.c work with no flags. Unknown host combinations are not an error here: they are reported by the driver, where there is somewhere to report them to.

Trait Implementations

impl Clone for Triple

fn clone(&self) -> Triple

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Triple

impl Debug for Triple

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

Formats the value using the given formatter.

impl Display for Triple

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

Formats the value using the given formatter.

impl Eq for Triple

impl FromStr for Triple

type Err = ParseTripleError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Triple

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Triple

fn cmp(&self, other: &Triple) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Triple

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Triple

fn partial_cmp(&self, other: &Triple) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Triple