Struct llvm_rs::Module

pub struct Module(_);

Represents a single compilation unit of code.

This is attached to the lifetime of the context that constructs it, but is owned by the CSemiBox.

Implementations

impl Module

pub fn new<'a>(name: &str, context: &'a Context) -> CSemiBox<'a, Module>

Create a new module in the context given with the name given.

The lifetime of the module will match the lifetime of the context you instance it in because the context contains it.

use llvm_rs::*;
let context = Context::new();
let context = context.as_semi();
let module = Module::new("name", &context);
println!("{:?}", module)

pub fn add_global<'a>(&'a self, name: &str, ty: &'a Type) -> &'a GlobalVariable

Add a global to the module with the given type and name.

pub fn add_global_in_address_space<'a>(
    &'a self,
    name: &str,
    ty: &'a Type,
    address: AddressSpace
) -> &'a GlobalVariable

Add a global variable to the module with the given type, name and initial value.

pub fn add_global_variable<'a>(
    &'a self,
    name: &str,
    val: &'a Value
) -> &'a GlobalVariable

Add a global variable to the module with the given type, name and initial value.

pub fn add_global_alias<'a>(
    &'a self,
    name: &str,
    val: &'a GlobalValue
) -> &'a Alias

Add a global to the module with the given type and name.

pub fn get_global<'a>(&'a self, name: &str) -> Option<&'a GlobalValue>

Get the global with the name given, or None if no global with that name exists.

pub fn parse_bitcode<'a>(
    context: &'a Context,
    path: &str
) -> Option<CSemiBox<'a, Module>>

Parse this bitcode file into a module, or return an error string.

pub fn write_bitcode(&self, path: &str) -> IoResult<()>

Write this module’s bitcode to the path given.

pub fn parse_ir_from_str<'a>(
    context: &'a Context,
    s: &str
) -> Result<CSemiBox<'a, Module>, CBox<str>>

Parse IR assembly unto a module, or return an error string.

pub fn add_function<'a>(&'a self, name: &str, sig: &'a Type) -> &'a mut Function

Add a function to the module with the name given.

pub fn get_function<'a>(&'a self, name: &str) -> Option<&'a Function>

Returns the function with the name given, or None if no function with that name exists.

pub fn get_type<'a>(&'a self, name: &str) -> Option<&'a Type>

Returns the type with the name given, or `None`` if no type with that name exists.

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

Clone this module.

pub fn optimize(&self, opt_level: usize, size_level: usize)

Optimize this module with the given optimization level and size level.

This runs passes depending on the levels given.

pub fn get_target(&self) -> &str

Returns the target data of this module represented as a string

pub fn set_target(&self, target: &str)

Set the target data of this module to the target data string given.

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

Verify that the module is safe to run, returning a string detailing the error when an error occurs.

pub fn compile(&self, path: &Path, opt_level: usize) -> IoResult<Child>

Compile the module into an object file at the given location.

Note that this uses the LLVM tool llc to do this, which may or may not be installed on the user’s machine.

pub fn link(&self, src: &Module) -> Result<(), ()>

Link a module into this module, returning an error string if an error occurs.

This does not destroy the source module.

Trait Implementations

impl Debug for Module

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

Formats the value using the given formatter.

impl DisposeRef for Module

type RefTo = LLVMModule

What a reference to this type represents as a C pointer.

unsafe fn dispose(ptr: *mut LLVMModule)

Destroy the contents at the pointer’s location.

impl<'a> From<&'a Module> for LLVMModuleRef

fn from(ty: &'a Module) -> LLVMModuleRef

Converts to this type from the input type.

impl<'a> From<&'a mut Module> for LLVMModuleRef

fn from(ty: &'a mut Module) -> LLVMModuleRef

Converts to this type from the input type.

impl<'a> From<*mut LLVMModule> for &'a Module

fn from(ty: LLVMModuleRef) -> &'a Module

Converts to this type from the input type.

impl<'a> From<*mut LLVMModule> for &'a mut Module

fn from(ty: LLVMModuleRef) -> &'a mut Module

Converts to this type from the input type.

impl GetContext for Module

fn get_context(&self) -> &Context

Returns a reference to the context that owns this value.

impl<'a> IntoIterator for &'a Module

fn into_iter(self) -> Functions<'a>

Iterate through the functions in the module

type Item = &'a Function

The type of the elements being iterated over.

type IntoIter = Functions<'a>

Which kind of iterator are we turning this into?

impl<'a> PartialEq<Module> for &'a Module

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Module> for Module

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Module