pub struct Context { /* private fields */ }
Expand description
A Context
is a container for all LLVM entities including Module
s.
A Context
is not thread safe and cannot be shared across threads. Multiple Context
s
can, however, execute on different threads simultaneously according to the LLVM docs.
Implementations§
source§impl Context
impl Context
sourcepub unsafe fn get_global<F, R>(func: F) -> R
pub unsafe fn get_global<F, R>(func: F) -> R
Gets a Mutex<Context>
which points to the global context singleton.
This function is marked unsafe because another program within the same
process could easily gain access to the same LLVM context pointer and bypass
our Mutex
. Therefore, using Context::create()
is the preferred context
creation function when you do not specifically need the global context.
Example
use inkwell::context::Context;
let context = unsafe {
Context::get_global(|_global_context| {
// do stuff
})
};
sourcepub fn create_builder(&self) -> Builder<'_>
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();
sourcepub fn create_module(&self, name: &str) -> Module<'_>
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");
sourcepub fn create_module_from_ir(
&self,
memory_buffer: MemoryBuffer
) -> Result<Module<'_>, LLVMString>
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 = 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();
sourcepub fn create_inline_asm<'ctx>(
&'ctx self,
ty: FunctionType<'ctx>,
assembly: String,
constraints: String,
sideeffects: bool,
alignstack: bool,
dialect: Option<InlineAsmDialect>,
can_throw: bool
) -> PointerValue<'ctx>
pub fn create_inline_asm<'ctx>( &'ctx 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"))]
builder.build_indirect_call(asm_fn, asm, params, "exit").unwrap();
builder.build_return(None).unwrap();
sourcepub fn void_type(&self) -> VoidType<'_>
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);
sourcepub fn bool_type(&self) -> IntType<'_>
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);
sourcepub fn i8_type(&self) -> IntType<'_>
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);
sourcepub fn i16_type(&self) -> IntType<'_>
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);
sourcepub fn i32_type(&self) -> IntType<'_>
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);
sourcepub fn i64_type(&self) -> IntType<'_>
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);
sourcepub fn i128_type(&self) -> IntType<'_>
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);
sourcepub fn custom_width_int_type(&self, bits: u32) -> IntType<'_>
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);
sourcepub fn metadata_type(&self) -> MetadataType<'_>
pub fn metadata_type(&self) -> MetadataType<'_>
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);
sourcepub fn ptr_sized_int_type(
&self,
target_data: &TargetData,
address_space: Option<AddressSpace>
) -> IntType<'_>
pub fn ptr_sized_int_type( &self, target_data: &TargetData, address_space: Option<AddressSpace> ) -> IntType<'_>
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);
sourcepub fn f16_type(&self) -> FloatType<'_>
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);
sourcepub fn f32_type(&self) -> FloatType<'_>
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);
sourcepub fn f64_type(&self) -> FloatType<'_>
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);
sourcepub fn x86_f80_type(&self) -> FloatType<'_>
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);
sourcepub fn f128_type(&self) -> FloatType<'_>
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);
sourcepub fn ppc_f128_type(&self) -> FloatType<'_>
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);
sourcepub fn struct_type(
&self,
field_types: &[BasicTypeEnum<'_>],
packed: bool
) -> StructType<'_>
pub fn struct_type( &self, field_types: &[BasicTypeEnum<'_>], packed: bool ) -> StructType<'_>
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()]);
sourcepub fn opaque_struct_type(&self, name: &str) -> StructType<'_>
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(), &[]);
sourcepub fn get_struct_type<'ctx>(&self, name: &str) -> Option<StructType<'ctx>>
pub fn get_struct_type<'ctx>(&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);
sourcepub fn const_struct(
&self,
values: &[BasicValueEnum<'_>],
packed: bool
) -> StructValue<'_>
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()]);
sourcepub fn append_basic_block<'ctx>(
&'ctx self,
function: FunctionValue<'ctx>,
name: &str
) -> BasicBlock<'ctx>
pub fn append_basic_block<'ctx>( &'ctx 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);
sourcepub fn insert_basic_block_after<'ctx>(
&'ctx self,
basic_block: BasicBlock<'ctx>,
name: &str
) -> BasicBlock<'ctx>
pub fn insert_basic_block_after<'ctx>( &'ctx 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);
sourcepub fn prepend_basic_block<'ctx>(
&'ctx self,
basic_block: BasicBlock<'ctx>,
name: &str
) -> BasicBlock<'ctx>
pub fn prepend_basic_block<'ctx>( &'ctx 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);
sourcepub fn metadata_node<'ctx>(
&'ctx self,
values: &[BasicMetadataValueEnum<'ctx>]
) -> MetadataValue<'ctx>
pub fn metadata_node<'ctx>( &'ctx 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);
sourcepub fn metadata_string(&self, string: &str) -> MetadataValue<'_>
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.);
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);
sourcepub fn get_kind_id(&self, key: &str) -> u32
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);
sourcepub fn create_enum_attribute(&self, kind_id: u32, val: u64) -> Attribute
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());
sourcepub fn create_string_attribute(&self, key: &str, val: &str) -> Attribute
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());
sourcepub fn create_type_attribute(
&self,
kind_id: u32,
type_ref: AnyTypeEnum<'_>
) -> Attribute
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());
sourcepub fn const_string(
&self,
string: &[u8],
null_terminated: bool
) -> ArrayValue<'_>
pub fn const_string( &self, string: &[u8], null_terminated: bool ) -> ArrayValue<'_>
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§
source§impl<'ctx> AsContextRef<'ctx> for &'ctx Context
impl<'ctx> AsContextRef<'ctx> for &'ctx Context
source§fn as_ctx_ref(&self) -> LLVMContextRef
fn as_ctx_ref(&self) -> LLVMContextRef
Acquires the underlying raw pointer belonging to this Context
type.
source§impl PartialEq<Context> for ContextRef<'_>
impl PartialEq<Context> for ContextRef<'_>
source§impl PartialEq<ContextRef<'_>> for Context
impl PartialEq<ContextRef<'_>> for Context
source§fn eq(&self, other: &ContextRef<'_>) -> bool
fn eq(&self, other: &ContextRef<'_>) -> bool
self
and other
values to be equal, and is used
by ==
.