Struct Module 

pub struct Module<'a>(/* private fields */);

Wraps LLVMModule

Implementations

impl<'a> Module<'a>

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

Create a new module

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

Get the associated context

pub fn identifier(&self) -> Result<&str, Error>

Get the module identifier

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

Set the module source file name

pub fn source_file(&self) -> Result<&str, Error>

Get the source file name

pub fn set_target(&mut self, target: impl AsRef<str>)

Set the module target string

pub fn target(&self) -> Result<&str, Error>

Get the target string

pub fn set_data_layout(&mut self, layout: impl AsRef<str>)

Set the module data layout string

pub fn data_layout(&self) -> Result<&str, Error>

Get data layout string

pub fn set_inline_asm(&mut self, asm: impl AsRef<str>)

Set module inline assembly

pub fn append_inline_asm(&mut self, asm: impl AsRef<str>)

Append module inline assembly

pub fn inline_asm(&self) -> Result<&str, Error>

Get module inline assembly

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

Verify the module, returning an error on failure

pub fn define_function( &self, name: impl AsRef<str>, t: FuncType<'_>, ) -> Result<Func<'a>, Error>

Define a new function without declaring a function body

pub fn declare_function<T: Into<Value<'a>>, F: FnOnce(Func<'a>) -> Result<T, Error>>( &self, builder: &Builder<'a>, name: impl AsRef<str>, ft: FuncType<'_>, def: F, ) -> Result<Func<'a>, Error>

Declare a new function with function body

pub fn define_global( &self, name: impl AsRef<str>, ty: impl AsRef<Type<'a>>, ) -> Result<Value<'a>, Error>

Create a new global with an empty initializer

pub fn define_global_in_address_space( &self, name: impl AsRef<str>, ty: impl AsRef<Type<'a>>, addr: usize, ) -> Result<Value<'a>, Error>

Define a new global in the given address space with an empty initializer

pub fn declare_global( &self, name: impl AsRef<str>, t: impl AsRef<Value<'a>>, ) -> Result<Value<'a>, Error>

Create a new global with the specified initializer

pub fn declare_global_in_address_space( &self, name: impl AsRef<str>, t: impl AsRef<Value<'a>>, addr: usize, ) -> Result<Value<'a>, Error>

Create a new global in the given address space with the specified initializer

pub fn function(&self, name: impl AsRef<str>) -> Result<Func<'a>, Error>

Get a function by name

pub fn global(&self, name: impl AsRef<str>) -> Result<Value<'a>, Error>

Get a global value by name

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

Get the first global

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

Get the last global

pub fn next_global( &self, global: impl AsRef<Value<'a>>, ) -> Result<Value<'a>, Error>

Get the next global

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

Get the first function

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

Get the last function

pub fn parse_ir( ctx: &Context<'_>, mem_buf: &MemoryBuffer, ) -> Result<Module<'a>, Error>

Create a new module from existing IR

pub fn parse_bitcode( ctx: &Context<'_>, mem_buf: &MemoryBuffer, ) -> Option<Module<'a>>

Create a new module from existing bitcode

pub fn write_bitcode_to_file( &self, path: impl AsRef<Path>, ) -> Result<bool, Error>

Write module bitcode to file

pub fn write_bitcode_to_memory_buffer(&self) -> Result<MemoryBuffer, Error>

Write module bitcode to in-memory buffer

pub fn link(&self, other: &Module<'_>) -> bool

Link another module into self

pub fn set_wasm32(&mut self)

Set WASM32 target/data layout

pub fn set_target_data(&mut self, target: &TargetData<'_>)

Set target data

pub fn target_data(&self) -> Result<TargetData<'_>, Error>

Get target data

Trait Implementations

impl<'a> Clone for Module<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Display for Module<'a>

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

Formats the value using the given formatter.

impl<'a> Drop for Module<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> LLVM<LLVMModule> for Module<'a>

fn llvm(&self) -> *mut LLVMModule

Return a LLVM pointer