Struct inkwell::context::ContextRef

pub struct ContextRef { /* fields omitted */ }

A ContextRef is a smart pointer allowing borrowed access to a a type's Context.

Methods from Deref<Target = Context>

pub fn create_builder(&self) -> Builder

Creates a new Builder for a Context.

Example

use inkwell::context::Context;

let context = Context::create();
let builder = context.create_builder();

pub fn create_module(&self, name: &str) -> Module

Creates a new Module for a Context.

Example

use inkwell::context::Context;

let context = Context::create();
let module = context.create_module("my_module");

pub fn create_module_from_ir(
    &self,
    memory_buffer: MemoryBuffer
) -> Result<Module, LLVMString>

Creates a new Module for the current Context from a MemoryBuffer.

Example

use inkwell::context::Context;

let context = Context::create();
let module = context.create_module("my_module");
let builder = context.create_builder();
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);
let fn_val = module.add_function("my_fn", fn_type, None);
let basic_block = fn_val.append_basic_block("entry");

builder.position_at_end(&basic_block);
builder.build_return(None);

let memory_buffer = module.write_bitcode_to_memory();

let module2 = context.create_module_from_ir(memory_buffer).unwrap();

pub fn void_type(&self) -> VoidType

Gets the VoidType. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let void_type = context.void_type();

assert_eq!(*void_type.get_context(), context);

pub fn bool_type(&self) -> IntType

Gets the IntType representing 1 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let bool_type = context.bool_type();

assert_eq!(bool_type.get_bit_width(), 1);
assert_eq!(*bool_type.get_context(), context);

pub fn i8_type(&self) -> IntType

Gets the IntType representing 8 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i8_type = context.i8_type();

assert_eq!(i8_type.get_bit_width(), 8);
assert_eq!(*i8_type.get_context(), context);

pub fn i16_type(&self) -> IntType

Gets the IntType representing 16 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i16_type = context.i16_type();

assert_eq!(i16_type.get_bit_width(), 16);
assert_eq!(*i16_type.get_context(), context);

pub fn i32_type(&self) -> IntType

Gets the IntType representing 32 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i32_type = context.i32_type();

assert_eq!(i32_type.get_bit_width(), 32);
assert_eq!(*i32_type.get_context(), context);

pub fn i64_type(&self) -> IntType

Gets the IntType representing 64 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i64_type = context.i64_type();

assert_eq!(i64_type.get_bit_width(), 64);
assert_eq!(*i64_type.get_context(), context);

pub fn i128_type(&self) -> IntType

Gets the IntType representing 128 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i128_type = context.i128_type();

assert_eq!(i128_type.get_bit_width(), 128);
assert_eq!(*i128_type.get_context(), context);

pub fn custom_width_int_type(&self, bits: u32) -> IntType

Gets the IntType representing a custom bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();
let i42_type = context.custom_width_int_type(42);

assert_eq!(i42_type.get_bit_width(), 42);
assert_eq!(*i42_type.get_context(), context);

pub fn f16_type(&self) -> FloatType

Gets the FloatType representing a 16 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();

let f16_type = context.f16_type();

assert_eq!(*f16_type.get_context(), context);

pub fn f32_type(&self) -> FloatType

Gets the FloatType representing a 32 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();

let f32_type = context.f32_type();

assert_eq!(*f32_type.get_context(), context);

pub fn f64_type(&self) -> FloatType

Gets the FloatType representing a 64 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();

let f64_type = context.f64_type();

assert_eq!(*f64_type.get_context(), context);

pub fn x86_f80_type(&self) -> FloatType

Gets the FloatType representing a 80 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();

let x86_f80_type = context.x86_f80_type();

assert_eq!(*x86_f80_type.get_context(), context);

pub fn f128_type(&self) -> FloatType

Gets the FloatType representing a 128 bit width. It will be assigned the current context.

Example

use inkwell::context::Context;

let context = Context::create();

let f128_type = context.f128_type();

assert_eq!(*f128_type.get_context(), context);

pub fn ppc_f128_type(&self) -> FloatType

Gets the FloatType representing a 128 bit width. It will be assigned the current context.

PPC is two 64 bits side by side rather than one single 128 bit float.

Example

use inkwell::context::Context;

let context = Context::create();

let f128_type = context.ppc_f128_type();

assert_eq!(*f128_type.get_context(), context);

pub fn struct_type(
    &self,
    field_types: &[BasicTypeEnum],
    packed: bool
) -> StructType

Creates a StructType definiton from heterogeneous types in the current Context.

Example

use inkwell::context::Context;

let context = Context::create();
let f32_type = context.f32_type();
let i16_type = context.i16_type();
let struct_type = context.struct_type(&[i16_type.into(), f32_type.into()], false);

assert_eq!(struct_type.get_field_types(), &[i16_type.into(), f32_type.into()]);

pub fn opaque_struct_type(&self, name: &str) -> StructType

Creates an opaque StructType with no type definition yet defined.

Example

use inkwell::context::Context;

let context = Context::create();
let f32_type = context.f32_type();
let i16_type = context.i16_type();
let struct_type = context.opaque_struct_type("my_struct");

assert_eq!(struct_type.get_field_types(), &[]);

pub fn const_struct(
    &self,
    values: &[BasicValueEnum],
    packed: bool
) -> StructValue

Creates a constant StructValue from constant values.

Example

use inkwell::context::Context;

let context = Context::create();
let f32_type = context.f32_type();
let i16_type = context.i16_type();
let f32_one = f32_type.const_float(1.);
let i16_two = i16_type.const_int(2, false);
let const_struct = context.const_struct(&[i16_two.into(), f32_one.into()], false);

assert_eq!(const_struct.get_type().get_field_types(), &[i16_type.into(), f32_type.into()]);

pub fn append_basic_block(
    &self,
    function: &FunctionValue,
    name: &str
) -> BasicBlock

Append a named BasicBlock at the end of the referenced FunctionValue.

Example

use inkwell::context::Context;

let context = Context::create();
let module = context.create_module("my_mod");
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);
let fn_value = module.add_function("my_fn", fn_type, None);
let entry_basic_block = context.append_basic_block(&fn_value, "entry");

assert_eq!(fn_value.count_basic_blocks(), 1);

let last_basic_block = context.append_basic_block(&fn_value, "last");

assert_eq!(fn_value.count_basic_blocks(), 2);
assert_eq!(fn_value.get_first_basic_block().unwrap(), entry_basic_block);
assert_eq!(fn_value.get_last_basic_block().unwrap(), last_basic_block);

pub fn insert_basic_block_after(
    &self,
    basic_block: &BasicBlock,
    name: &str
) -> BasicBlock

Append a named BasicBlock after the referenced BasicBlock.

Example

use inkwell::context::Context;

let context = Context::create();
let module = context.create_module("my_mod");
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);
let fn_value = module.add_function("my_fn", fn_type, None);
let entry_basic_block = context.append_basic_block(&fn_value, "entry");

assert_eq!(fn_value.count_basic_blocks(), 1);

let last_basic_block = context.insert_basic_block_after(&entry_basic_block, "last");

assert_eq!(fn_value.count_basic_blocks(), 2);
assert_eq!(fn_value.get_first_basic_block().unwrap(), entry_basic_block);
assert_eq!(fn_value.get_last_basic_block().unwrap(), last_basic_block);

pub fn prepend_basic_block(
    &self,
    basic_block: &BasicBlock,
    name: &str
) -> BasicBlock

Prepend a named BasicBlock before the referenced BasicBlock.

Example

use inkwell::context::Context;

let context = Context::create();
let module = context.create_module("my_mod");
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);
let fn_value = module.add_function("my_fn", fn_type, None);
let entry_basic_block = context.append_basic_block(&fn_value, "entry");

assert_eq!(fn_value.count_basic_blocks(), 1);

let first_basic_block = context.prepend_basic_block(&entry_basic_block, "first");

assert_eq!(fn_value.count_basic_blocks(), 2);
assert_eq!(fn_value.get_first_basic_block().unwrap(), first_basic_block);
assert_eq!(fn_value.get_last_basic_block().unwrap(), entry_basic_block);

pub fn metadata_node(&self, values: &[BasicValueEnum]) -> MetadataValue

Creates a MetadataValue tuple of heterogeneous types (a "Node") for the current context. It can be assigned to a value.

Example

use inkwell::context::Context;

let context = Context::create();
let i8_type = context.i8_type();
let i8_two = i8_type.const_int(2, false);
let f32_type = context.f32_type();
let f32_zero = f32_type.const_float(0.);
let md_node = context.metadata_node(&[i8_two.into(), f32_zero.into()]);
let f32_one = f32_type.const_float(1.);

assert!(md_node.is_node());

f32_one.set_metadata(md_node, 0);

pub fn metadata_string(&self, string: &str) -> MetadataValue

Creates a MetadataValue string for the current context. It can be assigned to a value.

Example

use inkwell::context::Context;

let context = Context::create();
let md_string = context.metadata_string("Floats are awesome!");
let f32_type = context.f32_type();
let f32_one = f32_type.const_float(1.);

assert!(md_string.is_string());

f32_one.set_metadata(md_string, 0);

pub fn get_kind_id(&self, key: &str) -> u32

Obtains the index of a metadata kind id. If the string doesn't exist, LLVM will add it at index FIRST_CUSTOM_METADATA_KIND_ID onward.

Example

use inkwell::context::Context;
use inkwell::values::FIRST_CUSTOM_METADATA_KIND_ID;

let context = Context::create();

assert_eq!(context.get_kind_id("dbg"), 0);
assert_eq!(context.get_kind_id("tbaa"), 1);
assert_eq!(context.get_kind_id("prof"), 2);

// Custom kind id doesn't exist in LLVM until now:
assert_eq!(context.get_kind_id("foo"), FIRST_CUSTOM_METADATA_KIND_ID);

pub fn create_enum_attribute(&self, kind_id: u32, val: u64) -> Attribute

Creates an enum Attribute in this Context.

Example

use inkwell::context::Context;

let context = Context::create();
let enum_attribute = context.create_enum_attribute(0, 10);

assert!(enum_attribute.is_enum());

pub fn create_string_attribute(&self, key: &str, val: &str) -> Attribute

Creates a string Attribute in this Context.

Example

use inkwell::context::Context;

let context = Context::create();
let string_attribute = context.create_string_attribute("my_key_123", "my_val");

assert!(string_attribute.is_string());

pub fn const_string(&self, string: &str, null_terminated: bool) -> VectorValue

Creates a const string which may be null terminated.

Example

use inkwell::context::Context;

let context = Context::create();
let string = context.const_string("my_string", false);

assert_eq!(string.print_to_string().to_string(), "[9 x i8] c\"my_string\"");

Trait Implementations

impl Eq for ContextRef

impl Drop for ContextRef

fn drop(&mut self)

Executes the destructor for this type.

impl PartialEq<ContextRef> for ContextRef

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

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

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

This method tests for !=.

impl Deref for ContextRef

type Target = Context

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl Debug for ContextRef

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.