pub struct Type(_);
Expand description
The type of an SSA value.
The INVALID
type isn’t a real type, and is used as a placeholder in the IR where a type
field is present put no type is needed, such as the controlling type variable for a
non-polymorphic instruction.
Basic integer types: I8
, I16
, I32
, I64
, and I128
. These types are sign-agnostic.
Basic floating point types: F32
and F64
. IEEE single and double precision.
Boolean types: B1
, B8
, B16
, B32
, B64
, and B128
. These all encode ‘true’ or ‘false’. The
larger types use redundant bits.
SIMD vector types have power-of-two lanes, up to 256. Lanes can be any int/float/bool type.
Implementations
sourceimpl Type
impl Type
sourcepub fn lane_type(self) -> Self
pub fn lane_type(self) -> Self
Get the lane type of this SIMD vector type.
A lane type is the same as a SIMD vector type with one lane, so it returns itself.
sourcepub fn lane_of(self) -> Self
pub fn lane_of(self) -> Self
The type transformation that returns the lane type of a type variable; it is just a renaming of lane_type() to be used in context where we think in terms of type variable transformations.
sourcepub fn log2_lane_bits(self) -> u32
pub fn log2_lane_bits(self) -> u32
Get log_2 of the number of bits in a lane.
sourcepub fn bounds(self, signed: bool) -> (u128, u128)
pub fn bounds(self, signed: bool) -> (u128, u128)
Get the (minimum, maximum) values represented by each lane in the type. Note that these are returned as unsigned ‘bit patterns’.
sourcepub fn int(bits: u16) -> Option<Self>
pub fn int(bits: u16) -> Option<Self>
Get an integer type with the requested number of bits.
For the same thing but in bytes, use Self::int_with_byte_size
.
sourcepub fn int_with_byte_size(bytes: u16) -> Option<Self>
pub fn int_with_byte_size(bytes: u16) -> Option<Self>
Get an integer type with the requested number of bytes.
For the same thing but in bits, use Self::int
.
sourcepub fn as_bool_pedantic(self) -> Self
pub fn as_bool_pedantic(self) -> Self
Get a type with the same number of lanes as this type, but with the lanes replaced by booleans of the same size.
Lane types are treated as vectors with one lane, so they are converted to the multi-bit boolean types.
sourcepub fn as_bool(self) -> Self
pub fn as_bool(self) -> Self
Get a type with the same number of lanes as this type, but with the lanes replaced by booleans of the same size.
Scalar types are all converted to b1
which is usually what you want.
sourcepub fn as_int(self) -> Self
pub fn as_int(self) -> Self
Get a type with the same number of lanes as this type, but with the lanes replaced by integers of the same size.
Scalar types follow this same rule, but b1
is converted into i8
sourcepub fn half_width(self) -> Option<Self>
pub fn half_width(self) -> Option<Self>
Get a type with the same number of lanes as this type, but with lanes that are half the number of bits.
sourcepub fn double_width(self) -> Option<Self>
pub fn double_width(self) -> Option<Self>
Get a type with the same number of lanes as this type, but with lanes that are twice the number of bits.
sourcepub fn is_invalid(self) -> bool
pub fn is_invalid(self) -> bool
Is this the INVALID type?
sourcepub fn is_special(self) -> bool
pub fn is_special(self) -> bool
Is this a special type?
sourcepub fn is_lane(self) -> bool
pub fn is_lane(self) -> bool
Is this a lane type?
This is a scalar type that can also appear as the lane type of a SIMD vector.
sourcepub fn is_bool_vector(self) -> bool
pub fn is_bool_vector(self) -> bool
Is this a vector boolean type?
sourcepub fn log2_lane_count(self) -> u32
pub fn log2_lane_count(self) -> u32
Get log_2 of the number of lanes in this SIMD vector type.
All SIMD types have a lane count that is a power of two and no larger than 256, so this will be a number in the range 0-8.
A scalar type is the same as a SIMD vector type with one lane, so it returns 0.
sourcepub fn lane_count(self) -> u32
pub fn lane_count(self) -> u32
Get the number of lanes in this SIMD vector type.
A scalar type is the same as a SIMD vector type with one lane, so it returns 1.
sourcepub fn by(self, n: u32) -> Option<Self>
pub fn by(self, n: u32) -> Option<Self>
Get a SIMD vector type with n
times more lanes than this one.
If this is a scalar type, this produces a SIMD type with this as a lane type and n
lanes.
If this is already a SIMD vector type, this produces a SIMD vector type with n * self.lane_count()
lanes.
sourcepub fn half_vector(self) -> Option<Self>
pub fn half_vector(self) -> Option<Self>
Get a SIMD vector with half the number of lanes.
There is no double_vector()
method. Use t.by(2)
instead.
sourcepub fn split_lanes(self) -> Option<Self>
pub fn split_lanes(self) -> Option<Self>
Split the lane width in half and double the number of lanes to maintain the same bit-width.
If this is a scalar type of n
bits, it produces a SIMD vector type of (n/2)x2
.
sourcepub fn merge_lanes(self) -> Option<Self>
pub fn merge_lanes(self) -> Option<Self>
Merge lanes to half the number of lanes and double the lane width to maintain the same bit-width.
If this is a scalar type, it will return None
.
sourcepub fn wider_or_equal(self, other: Self) -> bool
pub fn wider_or_equal(self, other: Self) -> bool
True iff:
self.lane_count() == other.lane_count()
andself.lane_bits() >= other.lane_bits()
sourcepub fn triple_pointer_type(triple: &Triple) -> Self
pub fn triple_pointer_type(triple: &Triple) -> Self
Return the pointer type for the given target triple.
sourcepub fn coerce_bools_to_ints(self) -> Self
pub fn coerce_bools_to_ints(self) -> Self
Coerces boolean types (scalar and vectors) into their integer counterparts. B1 is converted into I8.
Trait Implementations
impl Copy for Type
impl Eq for Type
impl StructuralEq for Type
impl StructuralPartialEq for Type
Auto Trait Implementations
impl RefUnwindSafe for Type
impl Send for Type
impl Sync for Type
impl Unpin for Type
impl UnwindSafe for Type
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
impl<Q, K> Equivalent<K> for Q where
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,
sourcefn equivalent(&self, key: &K) -> bool
fn equivalent(&self, key: &K) -> bool
Compare self to key
and return true
if they are equal.