Enum llvm_support::ty::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)

Tuple Fields of Integer

0: IntegerType

Function(FunctionType)

Tuple Fields of Function

0: FunctionType

Pointer(PointerType)

Tuple Fields of Pointer

0: PointerType

OpaquePointer(AddressSpace)

Tuple Fields of OpaquePointer

0: AddressSpace

Struct(StructType)

Tuple Fields of Struct

0: StructType

Array(ArrayType)

Tuple Fields of Array

0: ArrayType

FixedVector(VectorType)

Tuple Fields of FixedVector

0: VectorType

ScalableVector(VectorType)

Tuple Fields of ScalableVector

0: 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 copy 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<Type> for Type

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralPartialEq for Type