Struct TargetInfo 

#[non_exhaustive]
pub struct TargetInfo {
    pub triple: Triple,
    pub pointer_width: u32,
    pub little_endian: bool,
    pub char_is_signed: bool,
    pub long_width: u32,
    pub long_double_width: u32,
    pub long_double_format: Format,
    pub wchar_width: u32,
    pub wchar_is_signed: bool,
    pub bit_int_granule: u32,
    pub object_format: ObjectFormat,
}

The facts about a target that the compiler reads instead of hard-coding.

This is the whole of what a pass is allowed to know about where its output will run. It grows, and every field added here is one fewer #[cfg] somewhere it should not be.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

triple: Triple

The triple this describes.

pointer_width: u32

Width of a pointer in bits.

little_endian: bool

Whether bytes are ordered little end first.

char_is_signed: bool

Whether a bare char is signed.

Signed on x86-64 and unsigned on AArch64 Linux, which is the classic source of code that works on one and not the other, so it is data rather than an assumption.

long_width: u32

Width of long in bits. This is the field that separates the LP64 world from Windows LLP64.

long_double_width: u32

Width of long double in bits: 80 bits of x87 stored in 128 on SysV x86-64, 64 on Apple platforms, 64 on Windows.

long_double_format: Format

The format long double actually is, which the width does not say.

It is 128 bits wide on SysV x86-64 and on AArch64 Linux and the two are not the same type: one is the x87 eighty bit format padded out to sixteen bytes and the other is true quad precision with a hundred and thirteen bits of significand. Anything that converts a constant or folds one has to know which, and the width alone cannot say.

wchar_width: u32

Width of wchar_t in bits, which decides what a wide literal is encoded in.

It is 16 on Windows, so a wide string there is UTF-16 and a character outside the basic plane takes two elements, and 32 everywhere else, where a wide string is UTF-32 and no character takes more than one.

wchar_is_signed: bool

Whether wchar_t is signed.

x86-64 Linux makes it a signed int and AArch64 Linux makes it an unsigned int, following the psABI’s rule for plain char, so L'\xffffffff' is minus one on one of them and four billion on the other.

bit_int_granule: u32

The granule a _BitInt wider than 64 bits is laid out in, in bits.

Above 64 bits the psABIs stop treating a _BitInt like a standard integer type and start treating it like an array of these, so its size is rounded up to a multiple of this and its alignment is this. It is 64 on x86-64 and RISC-V and 128 on AArch64, which is why _BitInt(65) is sixteen bytes aligned to eight on one and sixteen bytes aligned to sixteen on the other. Measured with clang 18 on x86-64 Linux and clang on AArch64 Darwin rather than read off the documents.

object_format: ObjectFormat

The object format to emit.

Implementations

impl TargetInfo

pub fn new(triple: Triple) -> Self

The description of triple.

Trait Implementations

impl Clone for TargetInfo

fn clone(&self) -> TargetInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TargetInfo

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

Formats the value using the given formatter.

impl Eq for TargetInfo

impl PartialEq for TargetInfo

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for TargetInfo