Struct llvm_plugin_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 unsafe fn get(&self) -> &'ctx Context

Gets a usable context object with a correct lifetime.

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 = context.append_basic_block(fn_val, "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 create_inline_asm(
    &self,
    ty: FunctionType<'_>,
    assembly: String,
    constraints: String,
    sideeffects: bool,
    alignstack: bool,
    dialect: Option<InlineAsmDialect>
) -> PointerValue<'_>

Creates a inline asm function pointer.

Example

use std::convert::TryFrom;
use inkwell::context::Context;
use inkwell::values::CallableValue;

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, None);
let params = &[context.i64_type().const_int(60, false).into(), context.i64_type().const_int(1, false).into()];
let callable_value = CallableValue::try_from(asm).unwrap();
builder.build_call(callable_value, params, "exit");
builder.build_return(None);

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 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);

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);

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<'ctx>(&'ctx 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<'_>

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: &[BasicMetadataValueEnum<'_>]
) -> 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.);
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);

assert!(md_node.is_node());

ret_instr.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.);
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);

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 const_string(
    &self,
    string: &[u8],
    null_terminated: bool
) -> VectorValue<'_>

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> Debug for ContextRef<'ctx>

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

Formats the value using the given formatter.

impl Deref for ContextRef<'_>

type Target = Context

The resulting type after dereferencing.

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

Dereferences the value.

impl<'ctx> PartialEq<ContextRef<'ctx>> 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> Eq for ContextRef<'ctx>

impl<'ctx> StructuralEq for ContextRef<'ctx>

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