Struct Func

pub struct Func<'a>(pub Value<'a>);

Functions

Tuple Fields

0: Value<'a>

Implementations

impl<'a> Func<'a>

pub fn name(self) -> Result<&'a str, Error>

Get the name of a value

pub fn param_count(self) -> usize

Get the number of params

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

Get the FuncType

pub fn param(self, i: usize) -> Result<Value<'a>, Error>

Get a single param by index

pub fn params(self) -> Vec<Value<'a>>

Get all params

pub fn verify(self) -> Result<(), Error>

Verify the function, returning an error on failure

pub fn next_function(self) -> Result<Func<'a>, Error>

Get the next function

pub fn prev_function(self) -> Result<Func<'a>, Error>

Get the previous function

pub fn delete(self)

Delete a function

pub fn has_personality_fn(self) -> bool

Returns true when the value has a personality_fn

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

Returns the personality_fn

pub fn set_personality_fn(&mut self, f: impl AsRef<Value<'a>>)

Set the personality_fn

pub fn gc(self) -> Option<&'a str>

Get garbage collection scheme name

pub fn set_gc(&mut self, name: impl AsRef<str>)

Set garbage collection scheme name

pub fn call_conv(self) -> CallConv

Get calling convention

pub fn set_call_conv(&mut self, conv: CallConv)

Set calling convention

pub fn add_attribute(&mut self, index: AttributeIndex, attr: &Attribute<'a>)

Set attribute

pub fn remove_enum_atribute(&mut self, index: AttributeIndex, kind_id: u32)

Remove an enum attribute

pub fn remove_string_atribute( &mut self, index: AttributeIndex, k: impl AsRef<str>, )

Remove a string attribute

pub fn attributes(self, index: usize) -> Vec<Attribute<'a>>

Get all attributes

pub fn inline_asm_intel( t: impl AsRef<Type<'a>>, s: impl AsRef<str>, constraints: impl AsRef<str>, has_side_effects: bool, is_align_stack: bool, can_throw: bool, ) -> Result<Value<'a>, Error>

Create specified uniqued inline asm string (intel syntax)

pub fn inline_asm_att( t: impl AsRef<Type<'a>>, s: impl AsRef<str>, constraints: impl AsRef<str>, has_side_effects: bool, is_align_stack: bool, can_throw: bool, ) -> Result<Value<'a>, Error>

Create specified uniqued inline asm string (att syntax)

pub fn alignment(self) -> usize

Get value alignment

pub fn set_alignment(&mut self, align: usize)

Set value alignment

pub fn global_linkage(self) -> Linkage

Get global linkage

pub fn set_global_linkage(&mut self, l: Linkage)

Set global linkage

pub fn global_visibility(self) -> Visibility

Get global visibility

pub fn set_global_visibility(&mut self, l: Visibility)

Set global visibility

pub fn count_basic_blocks(self) -> usize

Count the number of basic blocks

pub fn basic_blocks(self) -> Vec<BasicBlock<'a>>

Get a list of all basic blocks

pub fn first_basic_block(self) -> Result<BasicBlock<'a>, Error>

Get first basic block

pub fn last_basic_block(self) -> Result<BasicBlock<'a>, Error>

Get last basic block

pub fn entry_basic_block(self) -> Result<BasicBlock<'a>, Error>

Get entry block

pub fn append_basic_block(self, bb: BasicBlock<'a>)

Append a new block

Trait Implementations

impl<'a> AsRef<Value<'a>> for Func<'a>

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

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

impl<'a> Clone for Func<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> From<Func<'a>> for Value<'a>

fn from(x: Func<'a>) -> Value<'a>

Converts to this type from the input type.

impl<'a> Copy for Func<'a>