Struct llama::Type

pub struct Type<'a>(_, _);

LLVMType wrapper

Implementations

impl<'a> Type<'a>

pub fn from_inner(ptr: *mut LLVMType) -> Result<Type<'a>, Error>

Wrap an LLVMType pointer

pub fn of<T: LLVMType<'a>>(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Allows for conversion between Rust/LLVM types

pub fn by_name(
    ctx: &'a Context<'_>,
    name: impl AsRef<str>
) -> Result<Type<'a>, Error>

Get type by name

pub fn int_width(self) -> usize

Get width of integer type

pub fn context(self) -> Result<Context<'a>, Error>

Get associated context

pub fn int(ctx: &Context<'a>, bits: usize) -> Result<Type<'a>, Error>

Create int type

pub fn i64(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create i64 type

pub fn i32(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create i32 type

pub fn i16(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create i16 type

pub fn i8(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create i8 type

pub fn i1(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create i1 type

pub fn is(self, kind: TypeKind) -> bool

Returns true if the types kind matches kind

pub fn void(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create void type

pub fn label(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create label type

pub fn token(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create token type

pub fn metadata(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create metadata type

pub fn x86_mmx(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create x86MMX type

pub fn half(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create half/float16 type

pub fn float(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create float type

pub fn double(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create double type

pub fn fp128(ctx: &Context<'a>) -> Result<Type<'a>, Error>

Create FP128 type

pub fn element_type(self) -> Result<Type<'a>, Error>

Get type of element

pub fn to_func_type(self) -> Result<FuncType<'a>, Error>

Convert to function type

pub fn to_struct_type(self) -> Result<StructType<'a>, Error>

Convert to struct type

pub fn pointer(self, address_space: Option<usize>) -> Result<Type<'a>, Error>

Make pointer type

pub fn vector(self, count: usize) -> Result<Type<'a>, Error>

Make vector type

pub fn array(self, count: usize) -> Result<Type<'a>, Error>

Make array type

pub fn kind(self) -> TypeKind

Get type kind

pub fn is_sized(self) -> bool

Returns true if a type is sized

pub fn array_len(self) -> usize

Get array length

pub fn vector_len(self) -> usize

Get vector length

pub fn pointer_address_space(self) -> usize

Get pointer address space

pub fn align_of(self) -> Result<Value<'a>, Error>

Get alignment of type

pub fn size_of(self) -> Result<Value<'a>, Error>

Get size of type

Trait Implementations

impl<'a> AsRef<Type<'a>> for Type<'a>

fn as_ref(&self) -> &Type<'a>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> AsRef<Type<'a>> for FuncType<'a>

fn as_ref(&self) -> &Type<'a>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> AsRef<Type<'a>> for StructType<'a>

fn as_ref(&self) -> &Type<'a>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Type<'a>

fn clone(&self) -> Type<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Display for Type<'a>

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

Formats the value using the given formatter.

impl<'a> From<FuncType<'a>> for Type<'a>

fn from(x: FuncType<'a>) -> Type<'a>

Converts to this type from the input type.

impl<'a> From<StructType<'a>> for Type<'a>

fn from(x: StructType<'a>) -> Type<'a>

Converts to this type from the input type.

impl<'a> LLVM<LLVMType> for Type<'a>

fn llvm(&self) -> *mut LLVMType

Return a LLVM pointer

impl<'a> Copy for Type<'a>