Struct inkwell::context::ContextRef

pub struct ContextRef<'ctx> { /* private fields */ }

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

Implementations

impl<'ctx> ContextRef<'ctx>

pub fn raw(&self) -> LLVMContextRef

Get raw LLVMContextRef.

This function is exposed only for interoperability with other LLVM IR libraries. It’s not intended to be used by most users.

pub unsafe fn new(context: LLVMContextRef) -> Self

Creates a new ContextRef from LLVMContextRef.

Safety

This function is exposed only for interoperability with other LLVM IR libraries. It’s not intended to be used by most users, hence marked as unsafe.

pub fn create_builder(&self) -> Builder<'ctx>

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<'ctx>

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<'ctx>, 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 = context.append_basic_block(fn_val, "entry");

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

let memory_buffer = module.write_bitcode_to_memory();

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

pub fn create_inline_asm( &self, ty: FunctionType<'ctx>, assembly: String, constraints: String, sideeffects: bool, alignstack: bool, dialect: Option<InlineAsmDialect>, can_throw: bool, ) -> PointerValue<'ctx>

Creates a inline asm function pointer.

Example

use std::convert::TryFrom;
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 = context.append_basic_block(fn_val, "entry");

builder.position_at_end(basic_block);
let asm_fn = context.i64_type().fn_type(&[context.i64_type().into(), context.i64_type().into()], false);
let asm = context.create_inline_asm(
    asm_fn,
    "syscall".to_string(),
    "=r,{rax},{rdi}".to_string(),
    true,
    false,
    #[cfg(not(any(feature = "llvm4-0", feature = "llvm5-0", feature = "llvm6-0")))] None,
    #[cfg(not(any(
        feature = "llvm4-0",
        feature = "llvm5-0",
        feature = "llvm6-0",
        feature = "llvm7-0",
        feature = "llvm8-0",
        feature = "llvm9-0",
        feature = "llvm10-0",
        feature = "llvm11-0",
        feature = "llvm12-0"
    )))]
    false,
);
let params = &[context.i64_type().const_int(60, false).into(), context.i64_type().const_int(1, false).into()];

#[cfg(any(
    feature = "llvm4-0",
    feature = "llvm5-0",
    feature = "llvm6-0",
    feature = "llvm7-0",
    feature = "llvm8-0",
    feature = "llvm9-0",
    feature = "llvm10-0",
    feature = "llvm11-0",
    feature = "llvm12-0",
    feature = "llvm13-0",
    feature = "llvm14-0"
))]
{
    use inkwell::values::CallableValue;
    let callable_value = CallableValue::try_from(asm).unwrap();
    builder.build_call(callable_value, params, "exit").unwrap();
}

#[cfg(any(feature = "llvm15-0", feature = "llvm16-0", feature = "llvm17-0", feature = "llvm18-0"))]
builder.build_indirect_call(asm_fn, asm, params, "exit").unwrap();

builder.build_return(None).unwrap();

pub fn void_type(&self) -> VoidType<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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 metadata_type(&self) -> MetadataType<'ctx>

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

Example

use inkwell::context::Context;
use inkwell::values::IntValue;

let context = Context::create();
let md_type = context.metadata_type();

assert_eq!(md_type.get_context(), context);

pub fn ptr_sized_int_type( &self, target_data: &TargetData, address_space: Option<AddressSpace>, ) -> IntType<'ctx>

Gets the IntType representing a bit width of a pointer. It will be assigned the referenced context.

Example

use inkwell::OptimizationLevel;
use inkwell::context::Context;
use inkwell::targets::{InitializationConfig, Target};

Target::initialize_native(&InitializationConfig::default()).expect("Failed to initialize native target");

let context = Context::create();
let module = context.create_module("sum");
let execution_engine = module.create_jit_execution_engine(OptimizationLevel::None).unwrap();
let target_data = execution_engine.get_target_data();
let int_type = context.ptr_sized_int_type(&target_data, None);

pub fn f16_type(&self) -> FloatType<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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<'ctx>

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 ptr_type(&self, address_space: AddressSpace) -> PointerType<'ctx>

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

Example

use inkwell::context::Context;
use inkwell::AddressSpace;

let context = Context::create();
let ptr_type = context.ptr_type(AddressSpace::default());

assert_eq!(ptr_type.get_address_space(), AddressSpace::default());
assert_eq!(ptr_type.get_context(), context);

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

Creates a StructType definition 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<'ctx>

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 get_struct_type(&self, name: &str) -> Option<StructType<'ctx>>

Gets a named StructType from this Context.

Example

use inkwell::context::Context;

let context = Context::create();

assert!(context.get_struct_type("foo").is_none());

let opaque = context.opaque_struct_type("foo");

assert_eq!(context.get_struct_type("foo").unwrap(), opaque);

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

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<'ctx>, name: &str, ) -> BasicBlock<'ctx>

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<'ctx>, name: &str, ) -> BasicBlock<'ctx>

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<'ctx>, name: &str, ) -> BasicBlock<'ctx>

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: &[BasicMetadataValueEnum<'ctx>], ) -> MetadataValue<'ctx>

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.);
let void_type = context.void_type();

let builder = context.create_builder();
let module = context.create_module("my_mod");
let fn_type = void_type.fn_type(&[f32_type.into()], false);
let fn_value = module.add_function("my_func", fn_type, None);
let entry_block = context.append_basic_block(fn_value, "entry");

builder.position_at_end(entry_block);

let ret_instr = builder.build_return(None).unwrap();

assert!(md_node.is_node());

ret_instr.set_metadata(md_node, 0);

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

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.);
let void_type = context.void_type();

let builder = context.create_builder();
let module = context.create_module("my_mod");
let fn_type = void_type.fn_type(&[f32_type.into()], false);
let fn_value = module.add_function("my_func", fn_type, None);
let entry_block = context.append_basic_block(fn_value, "entry");

builder.position_at_end(entry_block);

let ret_instr = builder.build_return(None).unwrap();

assert!(md_string.is_string());

ret_instr.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 create_type_attribute( &self, kind_id: u32, type_ref: AnyTypeEnum<'_>, ) -> Attribute

Create an enum Attribute with an AnyTypeEnum attached to it.

Example

use inkwell::context::Context;
use inkwell::attributes::Attribute;
use inkwell::types::AnyType;

let context = Context::create();
let kind_id = Attribute::get_named_enum_kind_id("sret");
let any_type = context.i32_type().as_any_type_enum();
let type_attribute = context.create_type_attribute(
    kind_id,
    any_type,
);

assert!(type_attribute.is_type());
assert_eq!(type_attribute.get_type_value(), any_type);
assert_ne!(type_attribute.get_type_value(), context.i64_type().as_any_type_enum());

pub fn const_string( &self, string: &[u8], null_terminated: bool, ) -> ArrayValue<'ctx>

Creates a const string which may be null terminated.

Example

use inkwell::context::Context;
use inkwell::values::AnyValue;

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

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

Trait Implementations

impl<'ctx> AsContextRef<'ctx> for ContextRef<'ctx>

fn as_ctx_ref(&self) -> LLVMContextRef

Acquires the underlying raw pointer belonging to this ContextRef type.

impl<'ctx> Clone for ContextRef<'ctx>

fn clone(&self) -> ContextRef<'ctx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'ctx> Debug for ContextRef<'ctx>

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

Formats the value using the given formatter.

impl PartialEq<Context> for ContextRef<'_>

fn eq(&self, other: &Context) -> 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<ContextRef<'_>> for Context

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: &Rhs) -> bool

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

impl<'ctx> PartialEq for ContextRef<'ctx>

fn eq(&self, other: &ContextRef<'ctx>) -> 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<'ctx> Copy for ContextRef<'ctx>

impl<'ctx> Eq for ContextRef<'ctx>

impl<'ctx> StructuralPartialEq for ContextRef<'ctx>