Struct llvm_plugin_inkwell::values::GlobalValue

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

Implementations

impl<'ctx> GlobalValue<'ctx>

pub fn get_name(&self) -> &CStr

Get name of the GlobalValue.

pub fn set_name(&self, name: &str)

Set name of the GlobalValue.

pub fn get_previous_global(self) -> Option<GlobalValue<'ctx>>

pub fn get_next_global(self) -> Option<GlobalValue<'ctx>>

pub fn get_dll_storage_class(self) -> DLLStorageClass

pub fn set_dll_storage_class(self, dll_storage_class: DLLStorageClass)

pub fn get_initializer(self) -> Option<BasicValueEnum<'ctx>>

pub fn set_initializer(self, value: &dyn BasicValue<'ctx>)

pub fn is_thread_local(self) -> bool

pub fn set_thread_local(self, is_thread_local: bool)

pub fn get_thread_local_mode(self) -> Option<ThreadLocalMode>

pub fn set_thread_local_mode(self, thread_local_mode: Option<ThreadLocalMode>)

pub fn is_declaration(self) -> bool

Determines whether or not a GlobalValue is a declaration or a definition.

Example

use inkwell::context::Context;

let context = Context::create();
let builder = context.create_builder();
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_func", fn_type, None);

assert!(fn_value.as_global_value().is_declaration());

context.append_basic_block(fn_value, "entry");

assert!(!fn_value.as_global_value().is_declaration());

pub fn has_unnamed_addr(self) -> bool

pub fn set_unnamed_addr(self, has_unnamed_addr: bool)

pub fn is_constant(self) -> bool

pub fn set_constant(self, is_constant: bool)

pub fn is_externally_initialized(self) -> bool

pub fn set_externally_initialized(self, externally_initialized: bool)

pub fn set_visibility(self, visibility: GlobalVisibility)

pub fn get_visibility(self) -> GlobalVisibility

pub fn get_section(&self) -> Option<&CStr>

Get section, this global value belongs to

pub fn set_section(self, section: Option<&str>)

Set section, this global value belongs to

pub unsafe fn delete(self)

pub fn as_pointer_value(self) -> PointerValue<'ctx>

pub fn get_alignment(self) -> u32

pub fn set_alignment(self, alignment: u32)

pub fn set_metadata(self, metadata: MetadataValue<'ctx>, kind_id: u32)

Sets a metadata of the given type on the GlobalValue

pub fn get_comdat(self) -> Option<Comdat>

Gets a Comdat assigned to this GlobalValue, if any.

pub fn set_comdat(self, comdat: Comdat)

Assigns a Comdat to this GlobalValue.

pub fn get_unnamed_address(self) -> UnnamedAddress

pub fn set_unnamed_address(self, address: UnnamedAddress)

pub fn get_linkage(self) -> Linkage

pub fn set_linkage(self, linkage: Linkage)

Trait Implementations

impl<'ctx> AnyValue<'ctx> for GlobalValue<'ctx>

fn as_any_value_enum(&self) -> AnyValueEnum<'ctx>

Returns an enum containing a typed version of AnyValue.

fn print_to_string(&self) -> LLVMString

Prints a value to a LLVMString

impl AsValueRef for GlobalValue<'_>

fn as_value_ref(&self) -> LLVMValueRef

impl<'ctx> BasicValue<'ctx> for GlobalValue<'ctx>

fn as_basic_value_enum(&self) -> BasicValueEnum<'ctx>

Returns an enum containing a typed version of the BasicValue.

fn as_instruction_value(&self) -> Option<InstructionValue<'ctx>>

Most BasicValues are the byproduct of an instruction and so are convertable into an InstructionValue

fn get_first_use(&self) -> Option<BasicValueUse<'_>>

fn set_name(&self, name: &str)

Sets the name of a BasicValue. If the value is a constant, this is a noop.

impl<'ctx> Clone for GlobalValue<'ctx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'ctx> Debug for GlobalValue<'ctx>

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

Formats the value using the given formatter.

impl Display for GlobalValue<'_>

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

Formats the value using the given formatter.

impl<'ctx> Hash for GlobalValue<'ctx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'ctx> PartialEq<GlobalValue<'ctx>> for GlobalValue<'ctx>

fn eq(&self, other: &GlobalValue<'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 GlobalValue<'ctx>

impl<'ctx> Eq for GlobalValue<'ctx>

impl<'ctx> StructuralEq for GlobalValue<'ctx>

impl<'ctx> StructuralPartialEq for GlobalValue<'ctx>