Enum Type

pub enum Type {
    Half,
    BFloat,
    Float,
    Double,
    Metadata,
    X86Fp80,
    Fp128,
    PpcFp128,
    Void,
    Label,
    X86Mmx,
    X86Amx,
    Token,
    Integer(IntegerType),
    Function(FunctionType),
    Pointer(PointerType),
    OpaquePointer(AddressSpace),
    Struct(StructType),
    Array(ArrayType),
    FixedVector(VectorType),
    ScalableVector(VectorType),
}

A representation of LLVM’s types.

See TypeId for documentation of each variant.

Variants

Half

BFloat

Float

Double

Metadata

X86Fp80

Fp128

PpcFp128

Void

Label

X86Mmx

X86Amx

Token

Integer(IntegerType)

Function(FunctionType)

Pointer(PointerType)

OpaquePointer(AddressSpace)

Struct(StructType)

Array(ArrayType)

FixedVector(VectorType)

ScalableVector(VectorType)

Implementations

impl Type

pub fn is_floating(&self) -> bool

Returns whether this type is one of the floating point types.

use llvm_support::Type;

assert!(Type::BFloat.is_floating());
assert!(Type::Float.is_floating());
assert!(Type::Double.is_floating());
assert!(Type::X86Fp80.is_floating());
assert!(Type::Fp128.is_floating());
assert!(Type::PpcFp128.is_floating());
assert!(!Type::Metadata.is_floating());

pub fn is_pointee(&self) -> bool

Returns whether this type is a valid “pointee” type, i.e. suitable as the inner type for a pointer type.

pub fn is_array_element(&self) -> bool

Returns whether this type is a valid array element type, i.e. is suitable as the inner type for an array type.

pub fn is_struct_element(&self) -> bool

Returns whether this type is a valid structure element type, i.e. is suitable as a field type within a structure type.

pub fn is_vector_element(&self) -> bool

Returns whether this type is a valid vector element type, i.e. is suitable as the inner type for a vector type.

use llvm_support::{AddressSpace, Type};

assert!(Type::Float.is_vector_element());
assert!(Type::new_integer(32).unwrap().is_vector_element());
assert!(
    Type::new_pointer(Type::new_integer(8).unwrap(), AddressSpace::default())
    .unwrap()
    .is_vector_element()
);
assert!(!Type::Metadata.is_vector_element());

pub fn is_argument(&self) -> bool

Returns whether this type is a valid argument type, i.e. is suitable as an argument within a function type.

use llvm_support::Type;

assert!(Type::Float.is_argument());
assert!(!Type::Void.is_argument());

pub fn is_return(&self) -> bool

Returns whether this type is a valid return type, i.e. is suitable as the return type within a function type.

pub fn new_struct( name: Option<String>, fields: Vec<Type>, is_packed: bool, ) -> Result<Self, StructTypeError>

Create a new struct type with the given fields.

pub fn new_integer(bit_width: u32) -> Result<Self, IntegerTypeError>

Create a new integral type from the given bit width.

pub fn new_pointer( pointee: Type, address_space: AddressSpace, ) -> Result<Self, PointerTypeError>

Create a new pointer type from the given pointee type and address space.

pub fn new_array( num_elements: u64, element_type: Type, ) -> Result<Self, ArrayTypeError>

Create a new array type of the given size and element type.

pub fn new_scalable_vector( num_elements: u64, element_type: Type, ) -> Result<Self, VectorTypeError>

Create a new scalable vector type of the given size and element type.

pub fn new_vector( num_elements: u64, element_type: Type, ) -> Result<Self, VectorTypeError>

Create a new (fixed) vector type of the given size and element type.

pub fn new_function( return_type: Type, param_types: Vec<Type>, is_vararg: bool, ) -> Result<Self, FunctionTypeError>

Create a new function type of the given return type, parameter types, and variadic disposition.

Trait Implementations

impl Clone for Type

fn clone(&self) -> Type

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Type

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

Formats the value using the given formatter.

impl PartialEq for Type

fn eq(&self, other: &Type) -> 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 StructuralPartialEq for Type