Module: LLVM::C

Extended by:

FFI::Library

Defined in:

lib/llvm/target.rb,
lib/llvm/core_ffi.rb,
lib/llvm/linker_ffi.rb,
lib/llvm/target_ffi.rb,
lib/llvm/core_ffi_v2.rb,
lib/llvm/analysis_ffi.rb,
lib/llvm/pass_builder.rb,
lib/llvm/core/bitcode_ffi.rb,
lib/llvm/execution_engine_ffi.rb

Defined Under Namespace

Classes: MCJITCompilerOptions, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMCJITMemoryManager, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, Target

Class Method Summary

• ._callback_diagnostic_handler_(diagnostic_info_ref, void) ⇒ FFI::Pointer(DiagnosticInfoRef)

  Contexts are execution states for the core LLVM IR system.

• ._callback_memory_manager_allocate_code_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name) ⇒ Integer

  – Operations on memory managers ————————————-===.

• ._callback_memory_manager_allocate_data_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name, is_read_only) ⇒ Integer

  (Not documented).

• ._callback_memory_manager_finalize_memory_callback_(bool, opaque, err_msg) ⇒ Integer

  (Not documented).

• ._callback_yield_callback_(context_ref, void) ⇒ FFI::Pointer(ContextRef)

  (Not documented).

• ._enum_atomic_ordering_ ⇒ Symbol

  (Not documented).

• ._enum_atomic_rmw_bin_op_ ⇒ Symbol

  (Not documented).

• ._enum_attribute_ ⇒ Symbol

  (Not documented).

• ._enum_byte_ordering_ ⇒ Symbol

  (Not documented).

• ._enum_call_conv_ ⇒ Symbol

  (Not documented).

• ._enum_code_gen_file_type_ ⇒ Symbol

  (Not documented).

• ._enum_code_gen_opt_level_ ⇒ Symbol

  (Not documented).

• ._enum_code_model_ ⇒ Symbol

  (Not documented).

• ._enum_diagnostic_severity_ ⇒ Symbol

  (Not documented).

• ._enum_dll_storage_class_ ⇒ Symbol

  (Not documented).

• ._enum_int_predicate_ ⇒ Symbol

  (Not documented).

• ._enum_landing_pad_clause_ty_ ⇒ Symbol

  (Not documented).

• ._enum_linkage_ ⇒ Symbol

  (Not documented).

• ._enum_linker_mode_ ⇒ Symbol

  This enum is provided for backwards-compatibility only.

• ._enum_opcode_ ⇒ Symbol

  (Not documented).

• ._enum_real_predicate_ ⇒ Symbol

  (Not documented).

• ._enum_reloc_mode_ ⇒ Symbol

  (Not documented).

• ._enum_thread_local_mode_ ⇒ Symbol

  (Not documented).

• ._enum_type_kind_ ⇒ Symbol

  (Not documented).

• ._enum_verifier_failure_action_ ⇒ Symbol

  @{.

• ._enum_visibility_ ⇒ Symbol

  (Not documented).

• .abi_alignment_of_type(td, ty) ⇒ Integer

  (Not documented).

• .abi_size_of_type(td, ty) ⇒ Integer

  (Not documented).

• .add_analysis_passes(t, pm) ⇒ nil

  Adds the target-specific analysis passes to the pass manager.

• .add_case(switch, on_val, dest) ⇒ nil

  Add a case to the switch instruction.

• .add_clause(landing_pad, clause_val) ⇒ nil

  Add a catch or filter clause to the landingpad instruction.

• .add_destination(indirect_br, dest) ⇒ nil

  Add a destination to the indirectbr instruction.

• .add_function(m, name, function_ty) ⇒ FFI::Pointer(ValueRef)

  Add a function to a module under a specified name.

• .add_global(m, ty, name) ⇒ FFI::Pointer(ValueRef)

  This group contains functions that operate on global variable values.

• .add_global_in_address_space(m, ty, name, address_space) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .add_global_mapping(ee, global, addr) ⇒ nil

  (Not documented).

• .add_incoming(phi_node, incoming_values, incoming_blocks, count) ⇒ nil

  Add an incoming value to the end of a PHI list.

• .add_module(ee, m) ⇒ nil

  (Not documented).

• .add_named_metadata_operand(m, name, val) ⇒ nil

  Add an operand to named metadata.

• .add_symbol(symbol_name, symbol_value) ⇒ nil

  (Not documented).

• .add_target_dependent_function_attr(fn, a, v) ⇒ nil

  Add a target-dependent attribute to a function.

• .add_target_library_info(tli, pm) ⇒ nil

  (Not documented).

• .align_of(ty) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .append_basic_block(fn, name) ⇒ FFI::Pointer(BasicBlockRef)

  Append a basic block to the end of a function using the global context.

• .append_basic_block_in_context(c, fn, name) ⇒ FFI::Pointer(BasicBlockRef)

  Append a basic block to the end of a function.

• .array_type(element_type, element_count) ⇒ FFI::Pointer(TypeRef)

  Create a fixed size array type that refers to a specific type.

• .basic_block_as_value(bb) ⇒ FFI::Pointer(ValueRef)

  Convert a basic block instance to a value type.

• .block_address(f, bb) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_a_shr(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  Arithmetic.

• .build_addr_space_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_aggregate_ret(builder_ref, ret_vals, n) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_alloca(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_and(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_array_alloca(builder_ref, ty, val, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_array_malloc(builder_ref, ty, val, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_atomic_rmw(b, op, ptr, val, ordering, single_thread) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_bin_op(b, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_br(builder_ref, dest) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_cast(b, op, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_cond_br(builder_ref, if_, then_, else_) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_exact_s_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_extract_element(builder_ref, vec_val, index, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_extract_value(builder_ref, agg_val, index, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_cmp(builder_ref, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_neg(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_f_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fence(b, ordering, single_thread, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fp_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fp_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fp_to_si(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fp_to_ui(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_fp_trunc(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_free(builder_ref, pointer_val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_global_string(b, str, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_global_string_ptr(b, str, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_i_cmp(builder_ref, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  Comparisons.

• .build_indirect_br(b, addr, num_dests) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_insert_element(builder_ref, vec_val, elt_val, index, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_insert_value(builder_ref, agg_val, elt_val, index, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_int_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_int_to_ptr(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_is_not_null(builder_ref, val, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_is_null(builder_ref, val, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_l_shr(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_landing_pad(b, ty, pers_fn, num_clauses, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_malloc(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

  Memory.

• .build_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_neg(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_not(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nsw_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nsw_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nsw_neg(b, v, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nsw_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nuw_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nuw_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nuw_neg(b, v, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_nuw_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_or(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_phi(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

  Miscellaneous instructions.

• .build_pointer_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_ptr_to_int(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_resume(b, exn) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_ret(builder_ref, v) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_ret_void(builder_ref) ⇒ FFI::Pointer(ValueRef)

  Terminators.

• .build_s_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_s_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_s_ext_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_s_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_select(builder_ref, if_, then_, else_, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_shl(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_shuffle_vector(builder_ref, v1, v2, mask, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_si_to_fp(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_store(builder_ref, val, ptr) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_switch(builder_ref, v, else_, num_cases) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_trunc(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  Casts.

• .build_trunc_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_u_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_u_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_ui_to_fp(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_unreachable(builder_ref) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_va_arg(builder_ref, list, ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_xor(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_z_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .build_z_ext_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .byte_order(td) ⇒ Symbol from _enum_byte_ordering_

  (Not documented).

• .call_frame_alignment_of_type(td, ty) ⇒ Integer

  (Not documented).

• .clear_insertion_position(builder) ⇒ nil

  (Not documented).

• .clone_module(m) ⇒ FFI::Pointer(ModuleRef)

  Return an exact copy of the specified module.

• .const_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_addr_space_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_all_ones(ty) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value referring to the instance of a type consisting of all ones.

• .const_array(element_ty, constant_vals, length) ⇒ FFI::Pointer(ValueRef)

  Create a ConstantArray from values.

• .const_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_extract_element(vector_constant, index_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_inline_asm(ty, asm_string, constraints, has_side_effects, is_align_stack) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_insert_element(vector_constant, element_value_constant, index_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_int(int_ty, n, sign_extend) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value for an integer type.

• .const_int_get_s_ext_value(constant_val) ⇒ Integer

  Obtain the sign extended value for an integer constant value.

• .const_int_get_z_ext_value(constant_val) ⇒ Integer

  Obtain the zero extended value for an integer constant value.

• .const_int_of_arbitrary_precision(int_ty, num_words, words) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value for an integer of arbitrary precision.

• .const_int_of_string(int_ty, text, radix) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value for an integer parsed from a string.

• .const_int_of_string_and_size(int_ty, text, s_len, radix) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value for an integer parsed from a string with specified length.

• .const_int_to_ptr(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_named_struct(struct_ty, constant_vals, count) ⇒ FFI::Pointer(ValueRef)

  Create a non-anonymous ConstantStruct from values.

• .const_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_not(constant_val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nsw_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nsw_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nsw_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nsw_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_null(ty) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value referring to the null instance of a type.

• .const_nuw_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nuw_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nuw_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_nuw_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_pointer_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_pointer_null(ty) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant that is a constant pointer pointing to NULL for a specified type.

• .const_ptr_to_int(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_real(real_ty, n) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value referring to a double floating point value.

• .const_real_get_double(constant_val, loses_info) ⇒ Float

  Obtain the double value for an floating point constant value.

• .const_real_of_string(real_ty, text) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant for a floating point value parsed from a string.

• .const_real_of_string_and_size(real_ty, text, s_len) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant for a floating point value parsed from a string.

• .const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_string(str, length, dont_null_terminate) ⇒ FFI::Pointer(ValueRef)

  Create a ConstantDataSequential with string content in the global context.

• .const_string_in_context(c, str, length, dont_null_terminate) ⇒ FFI::Pointer(ValueRef)

  Create a ConstantDataSequential and initialize it with a string.

• .const_struct(constant_vals, count, packed) ⇒ FFI::Pointer(ValueRef)

  Create a ConstantStruct in the global Context.

• .const_struct_in_context(c, constant_vals, count, packed) ⇒ FFI::Pointer(ValueRef)

  Create an anonymous ConstantStruct with the specified values.

• .const_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_trunc(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_trunc_or_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .const_vector(scalar_constant_vals, size) ⇒ FFI::Pointer(ValueRef)

  Create a ConstantVector from values.

• .const_xor(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .context_create ⇒ FFI::Pointer(ContextRef)

  Create a new context.

• .context_dispose(c) ⇒ nil

  Destroy a context instance.

• .context_set_diagnostic_handler(c, handler, diagnostic_context) ⇒ nil

  Set the diagnostic handler for this context.

• .context_set_yield_callback(c, callback, opaque_handle) ⇒ nil

  Set the yield callback function for this context.

• .copy_string_rep_of_target_data(td) ⇒ String

  (Not documented).

• .count_basic_blocks(fn) ⇒ Integer

  Obtain the number of basic blocks in a function.

• .count_incoming(phi_node) ⇒ Integer

  Obtain the number of incoming basic blocks to a PHI node.

• .count_param_types(function_ty) ⇒ Integer

  Obtain the number of parameters this function accepts.

• .count_params(fn) ⇒ Integer

  Obtain the number of parameters in a function.

• .count_struct_element_types(struct_ty) ⇒ Integer

  Get the number of elements defined inside the structure.

• .create_builder ⇒ FFI::Pointer(BuilderRef)

  (Not documented).

• .create_builder_in_context(c) ⇒ FFI::Pointer(BuilderRef)

  An instruction builder represents a point within a basic block and is the exclusive means of building instructions using the C interface.

• .create_execution_engine_for_module(out_ee, m, out_error) ⇒ Integer

  – Operations on execution engines ———————————–===.

• .create_function_pass_manager(mp) ⇒ FFI::Pointer(PassManagerRef)

  Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

• .create_function_pass_manager_for_module(m) ⇒ FFI::Pointer(PassManagerRef)

  Constructs a new function-by-function pass pipeline over the module provider.

• .create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

  (Not documented).

• .create_generic_value_of_int(ty, n, is_signed) ⇒ OpaqueGenericValue

  – Operations on generic values ————————————–===.

• .create_generic_value_of_pointer(p) ⇒ OpaqueGenericValue

  (Not documented).

• .create_interpreter_for_module(out_interp, m, out_error) ⇒ Integer

  (Not documented).

• .create_jit_compiler_for_module(out_jit, m, opt_level, out_error) ⇒ Integer

  (Not documented).

• .create_mcjit_compiler_for_module(out_jit, m, options, size_of_options, out_error) ⇒ Integer

  Create an MCJIT execution engine for a module, with the given options.

• .create_memory_buffer_with_contents_of_file(path, out_mem_buf, out_message) ⇒ Integer

  @{.

• .create_memory_buffer_with_memory_range(input_data, input_data_length, buffer_name, requires_null_terminator) ⇒ FFI::Pointer(MemoryBufferRef)

  (Not documented).

• .create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name) ⇒ FFI::Pointer(MemoryBufferRef)

  (Not documented).

• .create_memory_buffer_with_stdin(out_mem_buf, out_message) ⇒ Integer

  (Not documented).

• .create_message(message) ⇒ String

  – Error handling —————————————————-===.

• .create_module_provider_for_existing_module(m) ⇒ FFI::Pointer(ModuleProviderRef)

  Changes the type of M so it can be passed to FunctionPassManagers and the JIT.

• .create_pass_manager ⇒ FFI::Pointer(PassManagerRef)

  Constructs a new whole-module pass pipeline.

• .create_simple_mcjit_memory_manager(opaque, allocate_code_section, allocate_data_section, finalize_memory, destroy) ⇒ OpaqueMCJITMemoryManager

  Create a simple custom MCJIT memory manager.

• .create_target_data(string_rep) ⇒ OpaqueTargetData

  (Not documented).

• .create_target_data_layout(t) ⇒ OpaqueTargetData

  Create a DataLayout based on the targetMachine.

• .create_target_machine(t, triple, cpu, features, level, reloc, code_model) ⇒ OpaqueTargetMachine

  Creates a new llvm::TargetMachine.

• .delete_basic_block(bb) ⇒ nil

  Remove a basic block from a function and delete it.

• .delete_function(fn) ⇒ nil

  This group contains function that operate on global alias values.

• .delete_global(global_var) ⇒ nil

  (Not documented).

• .dispose_builder(builder) ⇒ nil

  (Not documented).

• .dispose_execution_engine(ee) ⇒ nil

  (Not documented).

• .dispose_generic_value(gen_val) ⇒ nil

  (Not documented).

• .dispose_mcjit_memory_manager(mm) ⇒ nil

  (Not documented).

• .dispose_memory_buffer(mem_buf) ⇒ nil

  (Not documented).

• .dispose_message(message) ⇒ nil

  (Not documented).

• .dispose_module(m) ⇒ nil

  Destroy a module instance.

• .dispose_module_provider(m) ⇒ nil

  Destroys the module M.

• .dispose_pass_manager(pm) ⇒ nil

  Frees the memory of a pass pipeline.

• .dispose_target_data(td) ⇒ nil

  (Not documented).

• .dispose_target_machine(t) ⇒ nil

  Dispose the LLVMTargetMachineRef instance generated by LLVMCreateTargetMachine.

• .double_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .double_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 64-bit floating point type from a context.

• .dump_module(m) ⇒ nil

  Dump a representation of a module to stderr.

• .dump_type(val) ⇒ nil

  Dump a representation of a type to stderr.

• .dump_value(val) ⇒ nil

  Dump a representation of a value to stderr.

• .element_at_offset(td, struct_ty, offset) ⇒ Integer

  (Not documented).

• .finalize_function_pass_manager(fpm) ⇒ Integer

  Finalizes all of the function passes scheduled in in the function pass manager.

• .find_function(ee, name, out_fn) ⇒ Integer

  (Not documented).

• .float_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .float_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 32-bit floating point type from a context.

• .fp128_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .fp128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 128-bit floating point type (112-bit mantissa) from a context.

• .free_machine_code_for_function(ee, f) ⇒ nil

  (Not documented).

• .function_type(return_type, param_types, param_count, is_var_arg) ⇒ FFI::Pointer(TypeRef)

  Obtain a function type consisting of a specified signature.

• .generic_value_int_width(gen_val_ref) ⇒ Integer

  (Not documented).

• .generic_value_to_float(ty_ref, gen_val) ⇒ Float

  (Not documented).

• .generic_value_to_int(gen_val, is_signed) ⇒ Integer

  (Not documented).

• .generic_value_to_pointer(gen_val) ⇒ FFI::Pointer(*Void)

  (Not documented).

• .get_alignment(v) ⇒ Integer

  Obtain the preferred alignment of the value.

• .get_array_length(array_ty) ⇒ Integer

  Obtain the length of an array type.

• .get_as_string(c, out) ⇒ String

  Get the given constant data sequential as a string.

• .get_basic_block_parent(bb) ⇒ FFI::Pointer(ValueRef)

  Obtain the function to which a basic block belongs.

• .get_basic_block_terminator(bb) ⇒ FFI::Pointer(ValueRef)

  Obtain the terminator instruction for a basic block.

• .get_basic_blocks(fn, basic_blocks) ⇒ nil

  Obtain all of the basic blocks in a function.

• .get_bitcode_module(mem_buf, out_m, out_message) ⇒ Integer

  (Not documented).

• .get_bitcode_module2(mem_buf, out_m) ⇒ Integer

  (Not documented).

• .get_bitcode_module_in_context(context_ref, mem_buf, out_m, out_message) ⇒ Integer

  (Not documented).

• .get_bitcode_module_in_context2(context_ref, mem_buf, out_m) ⇒ Integer

  (Not documented).

• .get_buffer_size(mem_buf) ⇒ Integer

  (Not documented).

• .get_buffer_start(mem_buf) ⇒ String

  (Not documented).

• .get_condition(branch) ⇒ FFI::Pointer(ValueRef)

  Return the condition of a branch instruction.

• .get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

  Functions in this group correspond to APIs on llvm::ConstantExpr.

• .get_current_debug_location(builder) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_data_layout(m) ⇒ String

  Obtain the data layout for a module.

• .get_default_target_triple ⇒ String

  Get a triple for the host machine as a string.

• .get_diag_info_description(di) ⇒ String

  Return a string representation of the DiagnosticInfo.

• .get_diag_info_severity(di) ⇒ Symbol from _enum_diagnostic_severity_

  Return an enum LLVMDiagnosticSeverity.

• .get_dll_storage_class(global) ⇒ Symbol from _enum_dll_storage_class_

  (Not documented).

• .get_element_as_constant(c, idx) ⇒ FFI::Pointer(ValueRef)

  Get an element at specified index as a constant.

• .get_element_type(ty) ⇒ FFI::Pointer(TypeRef)

  Obtain the type of elements within a sequential type.

• .get_entry_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain the basic block that corresponds to the entry point of a function.

• .get_execution_engine_target_data(ee) ⇒ FFI::Pointer(TargetDataRef)

  (Not documented).

• .get_execution_engine_target_machine(ee) ⇒ FFI::Pointer(TargetMachineRef)

  (Not documented).

• .get_f_cmp_predicate(inst) ⇒ Symbol from _enum_real_predicate_

  Obtain the float predicate of an instruction.

• .get_first_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain the first basic block in a function.

• .get_first_function(m) ⇒ FFI::Pointer(ValueRef)

  Obtain an iterator to the first Function in a Module.

• .get_first_global(m) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_first_instruction(bb) ⇒ FFI::Pointer(ValueRef)

  Obtain the first instruction in a basic block.

• .get_first_param(fn) ⇒ FFI::Pointer(ValueRef)

  Obtain the first parameter to a function.

• .get_first_target ⇒ Target

  Returns the first llvm::Target in the registered targets list.

• .get_first_use(val) ⇒ FFI::Pointer(UseRef)

  Obtain the first use of a value.

• .get_function_address(ee, name) ⇒ Integer

  (Not documented).

• .get_function_call_conv(fn) ⇒ Integer

  Obtain the calling function of a function.

• .get_gc(fn) ⇒ String

  Obtain the name of the garbage collector to use during code generation.

• .get_global_context ⇒ FFI::Pointer(ContextRef)

  Obtain the global context instance.

• .get_global_parent(global) ⇒ FFI::Pointer(ModuleRef)

  This group contains functions that operate on global values.

• .get_global_value_address(ee, name) ⇒ Integer

  (Not documented).

• .get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

  Obtain the predicate of an instruction.

• .get_incoming_block(phi_node, index) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.

• .get_incoming_value(phi_node, index) ⇒ FFI::Pointer(ValueRef)

  Obtain an incoming value to a PHI node as an LLVMValueRef.

• .get_initializer(global_var) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_insert_block(builder) ⇒ FFI::Pointer(BasicBlockRef)

  (Not documented).

• .get_instruction_call_conv(instr) ⇒ Integer

  Obtain the calling convention for a call instruction.

• .get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

  Obtain the code opcode for an individual instruction.

• .get_instruction_parent(inst) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain the basic block to which an instruction belongs.

• .get_int_type_width(integer_ty) ⇒ Integer

  (Not documented).

• .get_intrinsic_id(fn) ⇒ Integer

  Obtain the ID number from a function instance.

• .get_last_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain the last basic block in a function.

• .get_last_function(m) ⇒ FFI::Pointer(ValueRef)

  Obtain an iterator to the last Function in a Module.

• .get_last_global(m) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_last_instruction(bb) ⇒ FFI::Pointer(ValueRef)

  Obtain the last instruction in a basic block.

• .get_last_param(fn) ⇒ FFI::Pointer(ValueRef)

  Obtain the last parameter to a function.

• .get_linkage(global) ⇒ Symbol from _enum_linkage_

  (Not documented).

• .get_md_kind_id(name, s_len) ⇒ Integer

  (Not documented).

• .get_md_kind_id_in_context(c, name, s_len) ⇒ Integer

  (Not documented).

• .get_md_node_num_operands(v) ⇒ Object

  Obtain the number of operands from an MDNode value.

• .get_md_node_operands(v, dest) ⇒ nil

  Obtain the given MDNode’s operands.

• .get_md_string(v, len) ⇒ Object

  Obtain the underlying string from a MDString value.

• .get_metadata(val, kind_id) ⇒ FFI::Pointer(ValueRef)

  Return metadata associated with an instruction value.

• .get_module_context(m) ⇒ FFI::Pointer(ContextRef)

  Obtain the context to which this module is associated.

• .get_module_data_layout(m) ⇒ OpaqueTargetData

  (Not documented).

• .get_named_function(m, name) ⇒ FFI::Pointer(ValueRef)

  Obtain a Function value from a Module by its name.

• .get_named_global(m, name) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_named_metadata_num_operands(m, name) ⇒ Integer

  Obtain the number of operands for named metadata in a module.

• .get_named_metadata_operands(m, name, dest) ⇒ nil

  Obtain the named metadata operands for a module.

• .get_next_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

  Advance a basic block iterator.

• .get_next_function(fn) ⇒ FFI::Pointer(ValueRef)

  Advance a Function iterator to the next Function.

• .get_next_global(global_var) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_next_instruction(inst) ⇒ FFI::Pointer(ValueRef)

  Obtain the instruction that occurs after the one specified.

• .get_next_param(arg) ⇒ FFI::Pointer(ValueRef)

  Obtain the next parameter to a function.

• .get_next_target(t) ⇒ Target

  Returns the next llvm::Target given a previous one (or null if there’s none).

• .get_next_use(u) ⇒ FFI::Pointer(UseRef)

  Obtain the next use of a value.

• .get_num_operands(val) ⇒ Integer

  Obtain the number of operands in a llvm::User value.

• .get_num_successors(term) ⇒ Integer

  Return the number of successors that this terminator has.

• .get_operand(val, index) ⇒ FFI::Pointer(ValueRef)

  Obtain an operand at a specific index in a llvm::User value.

• .get_operand_use(val, index) ⇒ FFI::Pointer(UseRef)

  Obtain the use of an operand at a specific index in a llvm::User value.

• .get_ordering(memory_access_inst) ⇒ Symbol from _enum_atomic_ordering_

  (Not documented).

• .get_param(fn, index) ⇒ FFI::Pointer(ValueRef)

  Obtain the parameter at the specified index.

• .get_param_parent(inst) ⇒ FFI::Pointer(ValueRef)

  Obtain the function to which this argument belongs.

• .get_param_types(function_ty, dest) ⇒ nil

  Obtain the types of a function’s parameters.

• .get_params(fn, params) ⇒ nil

  Obtain the parameters in a function.

• .get_personality_fn(fn) ⇒ FFI::Pointer(ValueRef)

  Obtain the personality function attached to the function.

• .get_pointer_address_space(pointer_ty) ⇒ Integer

  Obtain the address space of a pointer type.

• .get_pointer_to_global(ee, global) ⇒ FFI::Pointer(*Void)

  (Not documented).

• .get_previous_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

  Go backwards in a basic block iterator.

• .get_previous_function(fn) ⇒ FFI::Pointer(ValueRef)

  Decrement a Function iterator to the previous Function.

• .get_previous_global(global_var) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .get_previous_instruction(inst) ⇒ FFI::Pointer(ValueRef)

  Obtain the instruction that occurred before this one.

• .get_previous_param(arg) ⇒ FFI::Pointer(ValueRef)

  Obtain the previous parameter to a function.

• .get_return_type(function_ty) ⇒ FFI::Pointer(TypeRef)

  Obtain the Type this function Type returns.

• .get_section(global) ⇒ String

  (Not documented).

• .get_struct_element_types(struct_ty, dest) ⇒ nil

  Get the elements within a structure.

• .get_struct_name(ty) ⇒ String

  Obtain the name of a structure.

• .get_successor(term, i) ⇒ FFI::Pointer(BasicBlockRef)

  Return the specified successor.

• .get_switch_default_dest(switch_instr) ⇒ FFI::Pointer(BasicBlockRef)

  Obtain the default destination basic block of a switch instruction.

• .get_target(m) ⇒ String

  Obtain the target triple for a module.

• .get_target_description(t) ⇒ String

  Returns the description of a target.

• .get_target_from_name(name) ⇒ Target

  Finds the target corresponding to the given name and stores it in p T.

• .get_target_from_triple(triple, t, error_message) ⇒ Integer

  Finds the target corresponding to the given triple and stores it in p T.

• .get_target_machine_cpu(t) ⇒ String

  Returns the cpu used creating this target machine.

• .get_target_machine_feature_string(t) ⇒ String

  Returns the feature string used creating this target machine.

• .get_target_machine_target(t) ⇒ Target

  Returns the Target used in a TargetMachine.

• .get_target_machine_triple(t) ⇒ String

  Returns the triple used creating this target machine.

• .get_target_name(t) ⇒ String

  Returns the name of a target.

• .get_thread_local_mode(global_var) ⇒ Symbol from _enum_thread_local_mode_

  (Not documented).

• .get_type_by_name(m, name) ⇒ FFI::Pointer(TypeRef)

  Obtain a Type from a module by its registered name.

• .get_type_context(ty) ⇒ FFI::Pointer(ContextRef)

  Obtain the context to which this type instance is associated.

• .get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

  Obtain the enumerated type of a Type instance.

• .get_undef(ty) ⇒ FFI::Pointer(ValueRef)

  Obtain a constant value referring to an undefined value of a type.

• .get_used_value(u) ⇒ FFI::Pointer(ValueRef)

  Obtain the value this use corresponds to.

• .get_user(u) ⇒ FFI::Pointer(ValueRef)

  Obtain the user value for a user.

• .get_value_name(val) ⇒ String

  Obtain the string name of a value.

• .get_vector_size(vector_ty) ⇒ Integer

  Obtain the number of elements in a vector type.

• .get_visibility(global) ⇒ Symbol from _enum_visibility_

  (Not documented).

• .get_volatile(memory_access_inst) ⇒ Integer

  (Not documented).

• .half_type ⇒ FFI::Pointer(TypeRef)

  Obtain a floating point type from the global context.

• .half_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 16-bit floating point type from a context.

• .has_metadata(val) ⇒ Integer

  Determine whether an instruction has any metadata attached.

• .has_unnamed_addr(global) ⇒ Integer

  (Not documented).

• .initialize_all_asm_parsers ⇒ nil

  (Not documented).

• .initialize_all_asm_printers ⇒ nil

  (Not documented).

• .initialize_all_disassemblers ⇒ nil

  (Not documented).

• .initialize_all_target_infos ⇒ nil

  (Not documented).

• .initialize_all_target_m_cs ⇒ nil

  (Not documented).

• .initialize_all_targets ⇒ nil

  (Not documented).

• .initialize_function_pass_manager(fpm) ⇒ Integer

  Initializes all of the function passes scheduled in the function pass manager.

• .initialize_mcjit_compiler_options(options, size_of_options) ⇒ nil

  (Not documented).

• .initialize_native_asm_parser ⇒ Integer

  (Not documented).

• .initialize_native_asm_printer ⇒ Integer

  (Not documented).

• .initialize_native_disassembler ⇒ Integer

  (Not documented).

• .initialize_native_target ⇒ Integer

  (Not documented).

• .insert_basic_block(insert_before_bb, name) ⇒ FFI::Pointer(BasicBlockRef)

  Insert a basic block in a function using the global context.

• .insert_basic_block_in_context(c, bb, name) ⇒ FFI::Pointer(BasicBlockRef)

  Insert a basic block in a function before another basic block.

• .insert_into_builder(builder, instr) ⇒ nil

  (Not documented).

• .insert_into_builder_with_name(builder, instr, name) ⇒ nil

  (Not documented).

• .instruction_clone(inst) ⇒ FFI::Pointer(ValueRef)

  Create a copy of ‘this’ instruction that is identical in all ways except the following: * The instruction has no parent * The instruction has no name.

• .instruction_erase_from_parent(inst) ⇒ nil

  Remove and delete an instruction.

• .int128_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int16_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int16_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int1_type ⇒ FFI::Pointer(TypeRef)

  Obtain an integer type from the global context with a specified bit width.

• .int1_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain an integer type from a context with specified bit width.

• .int32_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int32_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int64_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int64_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int8_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int8_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_ptr_type(td) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_ptr_type_for_as(td, as) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_ptr_type_for_as_in_context(c, td, as) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_ptr_type_in_context(c, td) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_type(num_bits) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .int_type_in_context(c, num_bits) ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .is_a_addr_space_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_alloca_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_argument(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_basic_block(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_binary_operator(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_bit_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_block_address(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_branch_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_call_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_catch_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_catch_return_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_cleanup_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_cleanup_return_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_aggregate_zero(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_array(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_data_array(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_data_sequential(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_data_vector(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_expr(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_fp(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_int(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_pointer_null(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_struct(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_token_none(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_constant_vector(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_dbg_declare_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_dbg_info_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_extract_element_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_extract_value_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_funclet_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_function(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_get_element_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_global_alias(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_global_object(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_global_value(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_global_variable(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_indirect_br_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_inline_asm(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_insert_element_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_insert_value_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_instruction(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_int_to_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_intrinsic_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_invoke_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_landing_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_load_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_mem_cpy_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_mem_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_mem_move_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_mem_set_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_ptr_to_int_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_resume_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_return_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_select_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_shuffle_vector_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_store_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_switch_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_terminator_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_unary_instruction(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_undef_value(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_unreachable_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_a_user(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_af_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_afp_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_afp_to_si_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_afp_to_ui_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_afp_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_ai_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_amd_node(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_amd_string(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_aphi_node(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_as_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_asi_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_aui_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_ava_arg_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_az_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .is_conditional(branch) ⇒ Integer

  Return if a branch is conditional.

• .is_constant(val) ⇒ Integer

  Determine whether the specified constant instance is constant.

• .is_constant_string(c) ⇒ Integer

  Returns true if the specified constant is an array of i8.

• .is_declaration(global) ⇒ Integer

  (Not documented).

• .is_externally_initialized(global_var) ⇒ Integer

  (Not documented).

• .is_function_var_arg(function_ty) ⇒ Integer

  Returns whether a function type is variadic.

• .is_global_constant(global_var) ⇒ Integer

  (Not documented).

• .is_literal_struct(struct_ty) ⇒ Bool

  Determine whether a structure is literal.

• .is_multithreaded ⇒ Integer

  Check whether LLVM is executing in thread-safe mode or not.

• .is_null(val) ⇒ Integer

  Determine whether a value instance is null.

• .is_opaque_struct(struct_ty) ⇒ Bool

  Determine whether a structure is opaque.

• .is_packed_struct(struct_ty) ⇒ Bool

  Determine whether a structure is packed.

• .is_tail_call(call_inst) ⇒ Integer

  Obtain whether a call instruction is a tail call.

• .is_thread_local(global_var) ⇒ Integer

  (Not documented).

• .is_undef(val) ⇒ Integer

  Determine whether a value instance is undefined.

• .label_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .label_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Create a label type in a context.

• .link_in_interpreter ⇒ nil

  (Not documented).

• .link_in_mcjit ⇒ nil

  @{.

• .link_modules2(dest, src) ⇒ Integer

  Links the source module into the destination module.

• .load_library_permanently(filename) ⇒ Integer

  (Not documented).

• .md_node(vals, count) ⇒ FFI::Pointer(ValueRef)

  Obtain a MDNode value from the global context.

• .md_node_in_context(c, vals, count) ⇒ FFI::Pointer(ValueRef)

  Obtain a MDNode value from a context.

• .md_string(str, s_len) ⇒ FFI::Pointer(ValueRef)

  Obtain a MDString value from the global context.

• .md_string_in_context(c, str, s_len) ⇒ FFI::Pointer(ValueRef)

  Obtain a MDString value from a context.

• .module_create_with_name(module_id) ⇒ FFI::Pointer(ModuleRef)

  Create a new, empty module in the global context.

• .module_create_with_name_in_context(module_id, c) ⇒ FFI::Pointer(ModuleRef)

  Create a new, empty module in a specific context.

• .move_basic_block_after(bb, move_pos) ⇒ nil

  Move a basic block to after another one.

• .move_basic_block_before(bb, move_pos) ⇒ nil

  Move a basic block to before another one.

• .offset_of_element(td, struct_ty, element) ⇒ Integer

  (Not documented).

• .parse_bitcode(mem_buf, out_module, out_message) ⇒ Integer

  (Not documented).

• .parse_bitcode2(mem_buf, out_module) ⇒ Integer

  (Not documented).

• .parse_bitcode_in_context(context_ref, mem_buf, out_module, out_message) ⇒ Integer

  (Not documented).

• .parse_bitcode_in_context2(context_ref, mem_buf, out_module) ⇒ Integer

  (Not documented).

• .parse_command_line_options(argc, argv, overview) ⇒ nil

  This function parses the given arguments using the LLVM command line parser.

• .pointer_size(td) ⇒ Integer

  (Not documented).

• .pointer_size_for_as(td, as) ⇒ Integer

  (Not documented).

• .pointer_type(element_type, address_space) ⇒ FFI::Pointer(TypeRef)

  Create a pointer type that points to a defined type.

• .position_builder(builder, block, instr) ⇒ nil

  (Not documented).

• .position_builder_at_end(builder, block) ⇒ nil

  (Not documented).

• .position_builder_before(builder, instr) ⇒ nil

  (Not documented).

• .ppcfp128_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .ppcfp128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 128-bit floating point type (two 64-bits) from a context.

• .preferred_alignment_of_global(td, global_var) ⇒ Integer

  (Not documented).

• .preferred_alignment_of_type(td, ty) ⇒ Integer

  (Not documented).

• .print_module_to_file(m, filename, error_message) ⇒ Integer

  Print a representation of a module to a file.

• .print_module_to_string(m) ⇒ String

  Return a string representation of the module.

• .print_type_to_string(val) ⇒ String

  Return a string representation of the type.

• .print_value_to_string(val) ⇒ String

  Return a string representation of the value.

• .recompile_and_relink_function(ee, fn) ⇒ FFI::Pointer(*Void)

  (Not documented).

• .remove_basic_block_from_parent(bb) ⇒ nil

  Remove a basic block from a function.

• .remove_module(ee, m, out_mod, out_error) ⇒ Integer

  (Not documented).

• .replace_all_uses_with(old_val, new_val) ⇒ nil

  Replace all uses of a value with another one.

• .run_function(ee, f, num_args, args) ⇒ OpaqueGenericValue

  (Not documented).

• .run_function_as_main(ee, f, arg_c, arg_v, env_p) ⇒ Integer

  (Not documented).

• .run_function_pass_manager(fpm, f) ⇒ Integer

  Executes all of the function passes scheduled in the function pass manager on the provided function.

• .run_pass_manager(pm, m) ⇒ Integer

  Initializes, executes on the provided module, and finalizes all of the passes scheduled in the pass manager.

• .run_passes(pmb, opt_level) ⇒ nil

  /** * Construct and run a set of passes over a module * * This function takes a string with the passes that should be used.

• .run_static_constructors(ee) ⇒ nil

  (Not documented).

• .run_static_destructors(ee) ⇒ nil

  (Not documented).

• .search_for_address_of_symbol(symbol_name) ⇒ FFI::Pointer(*Void)

  (Not documented).

• .set_alignment(v, bytes) ⇒ nil

  Set the preferred alignment of the value.

• .set_cleanup(landing_pad, val) ⇒ nil

  Set the ‘cleanup’ flag in the landingpad instruction.

• .set_condition(branch, cond) ⇒ nil

  Set the condition of a branch instruction.

• .set_current_debug_location(builder, l) ⇒ nil

  Metadata.

• .set_data_layout(m, triple) ⇒ nil

  Set the data layout for a module.

• .set_dll_storage_class(global, class_) ⇒ nil

  (Not documented).

• .set_externally_initialized(global_var, is_ext_init) ⇒ nil

  (Not documented).

• .set_function_call_conv(fn, cc) ⇒ nil

  Set the calling convention of a function.

• .set_gc(fn, name) ⇒ nil

  Define the garbage collector to use during code generation.

• .set_global_constant(global_var, is_constant) ⇒ nil

  (Not documented).

• .set_initializer(global_var, constant_val) ⇒ nil

  (Not documented).

• .set_inst_debug_location(builder, inst) ⇒ nil

  (Not documented).

• .set_instr_param_alignment(instr, index, align) ⇒ nil

  (Not documented).

• .set_instruction_call_conv(instr, cc) ⇒ nil

  Set the calling convention for a call instruction.

• .set_linkage(global, linkage) ⇒ nil

  (Not documented).

• .set_metadata(val, kind_id, node) ⇒ nil

  Set metadata associated with an instruction value.

• .set_module_data_layout(m, dl) ⇒ nil

  (Not documented).

• .set_module_inline_asm(m, asm) ⇒ nil

  Set inline assembly for a module.

• .set_operand(user, index, val) ⇒ nil

  Set an operand at a specific index in a llvm::User value.

• .set_ordering(memory_access_inst, ordering) ⇒ nil

  (Not documented).

• .set_param_alignment(arg, align) ⇒ nil

  Set the alignment for a function parameter.

• .set_personality_fn(fn, personality_fn) ⇒ nil

  Set the personality function attached to the function.

• .set_section(global, section) ⇒ nil

  (Not documented).

• .set_successor(term, i, block) ⇒ nil

  Update the specified successor to point at the provided block.

• .set_tail_call(call_inst, is_tail_call) ⇒ nil

  Set whether a call instruction is a tail call.

• .set_target(m, triple) ⇒ nil

  Set the target triple for a module.

• .set_target_machine_asm_verbosity(t, verbose_asm) ⇒ nil

  Set the target machine’s ASM verbosity.

• .set_thread_local(global_var, is_thread_local) ⇒ nil

  (Not documented).

• .set_thread_local_mode(global_var, mode) ⇒ nil

  (Not documented).

• .set_unnamed_addr(global, has_unnamed_addr) ⇒ nil

  (Not documented).

• .set_value_name(val, name) ⇒ nil

  Set the string name of a value.

• .set_visibility(global, viz) ⇒ nil

  (Not documented).

• .set_volatile(memory_access_inst, is_volatile) ⇒ nil

  (Not documented).

• .shutdown ⇒ nil

  @}.

• .size_of(ty) ⇒ FFI::Pointer(ValueRef)

  (Not documented).

• .size_of_type_in_bits(td, ty) ⇒ Integer

  (Not documented).

• .start_multithreaded ⇒ Integer

  Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THREADS.

• .stop_multithreaded ⇒ nil

  Deprecated: Multi-threading can only be enabled/disabled with the compile time define LLVM_ENABLE_THREADS.

• .store_size_of_type(td, ty) ⇒ Integer

  (Not documented).

• .struct_create_named(c, name) ⇒ FFI::Pointer(TypeRef)

  Create an empty structure in a context having a specified name.

• .struct_get_type_at_index(struct_ty, i) ⇒ FFI::Pointer(TypeRef)

  Get the type of the element at a given index in the structure.

• .struct_set_body(struct_ty, element_types, element_count, packed) ⇒ nil

  Set the contents of a structure type.

• .struct_type(element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

  Create a new structure type in the global context.

• .struct_type_in_context(c, element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

  Create a new structure type in a context.

• .target_has_asm_backend(t) ⇒ Integer

  Returns if the target as an ASM backend (required for emitting output).

• .target_has_jit(t) ⇒ Integer

  Returns if the target has a JIT.

• .target_has_target_machine(t) ⇒ Integer

  Returns if the target has a TargetMachine associated.

• .target_machine_emit_to_file(t, m, filename, codegen, error_message) ⇒ Integer

  Emits an asm or object file for the given module to the filename.

• .target_machine_emit_to_memory_buffer(t, m, codegen, error_message, out_mem_buf) ⇒ Integer

  Compile the LLVM IR stored in p M and store the result in p OutMemBuf.

• .type_is_sized(ty) ⇒ Integer

  Whether the type has a known size.

• .type_of(val) ⇒ FFI::Pointer(TypeRef)

  Obtain the type of a value.

• .value_as_basic_block(val) ⇒ FFI::Pointer(BasicBlockRef)

  Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

• .value_is_basic_block(val) ⇒ Integer

  Determine whether an LLVMValueRef is itself a basic block.

• .vector_type(element_type, element_count) ⇒ FFI::Pointer(TypeRef)

  Create a vector type that contains a defined type and has a specific number of elements.

• .verify_function(fn, action) ⇒ Integer

  Verifies that a single function is valid, taking the specified action.

• .verify_module(m, action, out_message) ⇒ Integer

  Verifies that a module is valid, taking the specified action if not.

• .view_function_cfg(fn) ⇒ nil

  Open up a ghostview window that displays the CFG of the current function.

• .view_function_cfg_only(fn) ⇒ nil

  (Not documented).

• .void_type ⇒ FFI::Pointer(TypeRef)

  These are similar to the above functions except they operate on the global context.

• .void_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Create a void type in a context.

• .write_bitcode_to_fd(m, fd, should_close, unbuffered) ⇒ Integer

  Writes a module to an open file descriptor.

• .write_bitcode_to_file(m, path) ⇒ Integer

  Writes a module to the specified path.

• .write_bitcode_to_file_handle(m, handle) ⇒ Integer

  Deprecated for LLVMWriteBitcodeToFD.

• .write_bitcode_to_memory_buffer(m) ⇒ FFI::Pointer(MemoryBufferRef)

  Writes a module to a new memory buffer and returns it.

• .x86amx_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .x86fp80_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .x86fp80_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Obtain a 80-bit floating point type (X87) from a context.

• .x86mmx_type ⇒ FFI::Pointer(TypeRef)

  (Not documented).

• .x86mmx_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

  Create a X86 MMX type in a context.

Class Method Details

._callback_diagnostic_handler_(diagnostic_info_ref, void) ⇒ FFI::Pointer(DiagnosticInfoRef)

Contexts are execution states for the core LLVM IR system.

Most types are tied to a context instance. Multiple contexts can exist simultaneously. A single context is not thread safe. However, different contexts can execute on different threads simultaneously.

@{

This entry is only for documentation and no real method.

Parameters:

• diagnostic_info_ref (FFI::Pointer(DiagnosticInfoRef))
• void (FFI::Pointer(*Void))

Returns:

• (FFI::Pointer(DiagnosticInfoRef))

# File 'lib/llvm/core_ffi.rb', line 808

callback :diagnostic_handler, [:pointer, :pointer], :pointer

._callback_memory_manager_allocate_code_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name) ⇒ Integer

– Operations on memory managers ————————————-===

This entry is only for documentation and no real method.

Parameters:

• uint8_t (Integer)
• opaque (FFI::Pointer(*Void))
• size (Integer)
• alignment (Integer)
• section_id (Integer)
• section_name (String)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 357

callback :memory_manager_allocate_code_section_callback, [:uchar, :pointer, :ulong, :uint, :uint, :string], :uchar

._callback_memory_manager_allocate_data_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name, is_read_only) ⇒ Integer

(Not documented)

This entry is only for documentation and no real method.

Parameters:

• uint8_t (Integer)
• opaque (FFI::Pointer(*Void))
• size (Integer)
• alignment (Integer)
• section_id (Integer)
• section_name (String)
• is_read_only (Integer)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 373

callback :memory_manager_allocate_data_section_callback, [:uchar, :pointer, :ulong, :uint, :uint, :string, :int], :uchar

._callback_memory_manager_finalize_memory_callback_(bool, opaque, err_msg) ⇒ Integer

(Not documented)

This entry is only for documentation and no real method.

Parameters:

• bool (Integer)
• opaque (FFI::Pointer(*Void))
• err_msg (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 385

callback :memory_manager_finalize_memory_callback, [:int, :pointer, :pointer], :int

._callback_yield_callback_(context_ref, void) ⇒ FFI::Pointer(ContextRef)

(Not documented)

This entry is only for documentation and no real method.

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• void (FFI::Pointer(*Void))

Returns:

• (FFI::Pointer(ContextRef))

# File 'lib/llvm/core_ffi.rb', line 819

callback :yield_callback, [:pointer, :pointer], :pointer

._enum_atomic_ordering_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:atomic_ordering).

Options:

:not_atomic

:unordered

< A load or store which is not atomic

:monotonic

< Lowest level of atomicity, guarantees

somewhat sane results, lock free.

:acquire

< guarantees that if you take all the

operations affecting a specific address,
a consistent ordering exists

:release

< Acquire provides a barrier of the sort

necessary to acquire a lock to access other
memory with normal loads and stores.

:acquire_release

< Release is similar to Acquire, but with

a barrier of the sort necessary to release
a lock.

:sequentially_consistent

< provides both an Acquire and a

Release barrier (for fences and
operations which both read and write
 memory).

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 730

enum :atomic_ordering, [
  :not_atomic, 0,
  :unordered, 1,
  :monotonic, 2,
  :acquire, 4,
  :release, 5,
  :acquire_release, 6,
  :sequentially_consistent, 7
]

._enum_atomic_rmw_bin_op_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:atomic_rmw_bin_op).

Options:

:xchg

:add

< Set the new value and return the one old

:sub

< Add a value and return the old one

:and_

< Subtract a value and return the old one

:nand

< And a value and return the old one

:or_

< Not-And a value and return the old one

:xor

< OR a value and return the old one

:max

< Xor a value and return the old one

:min

< Sets the value if it’s greater than the

original using a signed comparison and return
the old one

:u_max

< Sets the value if it’s Smaller than the

original using a signed comparison and return
the old one

:u_min

< Sets the value if it’s greater than the

original using an unsigned comparison and return
the old one

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi_v2.rb', line 243

enum :atomic_rmw_bin_op, [
  :xchg,
  :add,
  :sub,
  :and,
  :nand,
  :or,
  :xor,
  :max,
  :min,
  :umax,
  :umin,
  :fadd,
  :fsub,
  :fmax,
  :fmin,
  :uincwrap,
  :udecwrap,
]

._enum_attribute_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:attribute).

Options:

:z_ext_attribute

:s_ext_attribute

:no_return_attribute

:in_reg_attribute

:struct_ret_attribute

:no_unwind_attribute

:no_alias_attribute

:by_val_attribute

:nest_attribute

:read_none_attribute

:read_only_attribute

:no_inline_attribute

:always_inline_attribute

:optimize_for_size_attribute

:stack_protect_attribute

:stack_protect_req_attribute

:alignment

:no_capture_attribute

:no_red_zone_attribute

:no_implicit_float_attribute

:naked_attribute

:inline_hint_attribute

:stack_alignment

:returns_twice

:uw_table

:non_lazy_bind

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 110

enum :attribute, [
  :z_ext_attribute, 1,
  :s_ext_attribute, 2,
  :no_return_attribute, 4,
  :in_reg_attribute, 8,
  :struct_ret_attribute, 16,
  :no_unwind_attribute, 32,
  :no_alias_attribute, 64,
  :by_val_attribute, 128,
  :nest_attribute, 256,
  :read_none_attribute, 512,
  :read_only_attribute, 1024,
  :no_inline_attribute, 2048,
  :always_inline_attribute, 4096,
  :optimize_for_size_attribute, 8192,
  :stack_protect_attribute, 16384,
  :stack_protect_req_attribute, 32768,
  :alignment, 2031616,
  :no_capture_attribute, 2097152,
  :no_red_zone_attribute, 4194304,
  :no_implicit_float_attribute, 8388608,
  :naked_attribute, 16777216,
  :inline_hint_attribute, 33554432,
  :stack_alignment, 469762048,
  :returns_twice, 536870912,
  :uw_table, 1073741824,
  :non_lazy_bind, 2147483648
]

._enum_byte_ordering_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:byte_ordering).

Options:

:big_endian

:little_endian

Returns:

• (Symbol)

# File 'lib/llvm/target_ffi.rb', line 21

enum :byte_ordering, [
  :big_endian, 0,
  :little_endian, 1
]

._enum_call_conv_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:call_conv).

Options:

:c

:fast

:cold

:web_kit_js

:any_reg

:x86_stdcall

:x86_fastcall

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 540

enum :call_conv, [
  :c, 0,
  :fast, 8,
  :cold, 9,
  :web_kit_js, 12,
  :any_reg, 13,
  :x86_stdcall, 64,
  :x86_fastcall, 65
]

._enum_code_gen_file_type_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_gen_file_type).

Options:

:assembly

:object

Returns:

• (Symbol)

# File 'lib/llvm/target_ffi.rb', line 400

enum :code_gen_file_type, [
  :assembly, 0,
  :object, 1
]

._enum_code_gen_opt_level_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_gen_opt_level).

Options:

:none

:less

:default

:aggressive

Returns:

• (Symbol)

# File 'lib/llvm/target_ffi.rb', line 326

enum :code_gen_opt_level, [
  :none, 0,
  :less, 1,
  :default, 2,
  :aggressive, 3
]

._enum_code_model_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:code_model).

Options:

:default

:jit_default

:small

:kernel

:medium

:large

Returns:

• (Symbol)

# File 'lib/llvm/target_ffi.rb', line 378

enum :code_model, [
  :default, 0,
  :jit_default, 1,
  :small, 2,
  :kernel, 3,
  :medium, 4,
  :large, 5
]

._enum_diagnostic_severity_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:diagnostic_severity).

Options:

:ds_error

:ds_warning

:ds_remark

:ds_note

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 757

enum :diagnostic_severity, [
  :ds_error, 0,
  :ds_warning, 1,
  :ds_remark, 2,
  :ds_note, 3
]

._enum_dll_storage_class_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:dll_storage_class).

Options:

:default

:dll_import

:dll_export

< Function to be imported from DLL.

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 511

enum :dll_storage_class, [
  :default, 0,
  :dll_import, 1,
  :dll_export, 2
]

._enum_int_predicate_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:int_predicate).

Options:

:eq

:ne

< equal

:ugt

< not equal

:uge

< unsigned greater than

:ult

< unsigned greater or equal

:ule

< unsigned less than

:sgt

< unsigned less or equal

:sge

< signed greater than

:slt

< signed greater or equal

:sle

< signed less than

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 579

enum :int_predicate, [
  :eq, 32,
  :ne, 33,
  :ugt, 34,
  :uge, 35,
  :ult, 36,
  :ule, 37,
  :sgt, 38,
  :sge, 39,
  :slt, 40,
  :sle, 41
]

._enum_landing_pad_clause_ty_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:landing_pad_clause_ty).

Options:

:catch

:filter

< A catch clause

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 665

enum :landing_pad_clause_ty, [
  :catch, 0,
  :filter, 1
]

._enum_linkage_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linkage).

Options:

:external

:available_externally

< Externally visible function

:link_once_any

:link_once_odr

< Keep one copy of function when linking (inline)

:link_once_odr_auto_hide

< Same, but only replaced by something

equivalent.

:weak_any

< Obsolete

:weak_odr

< Keep one copy of function when linking (weak)

:appending

< Same, but only replaced by something

equivalent.

:internal

< Special purpose, only applies to global arrays

:private

< Rename collisions when linking (static

functions)

:dll_import

< Like Internal, but omit from symbol table

:dll_export

< Obsolete

:external_weak

< Obsolete

:ghost

< ExternalWeak linkage description

:common

< Obsolete

:linker_private

< Tentative definitions

:linker_private_weak

< Like Private, but linker removes.

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 455

enum :linkage, [
  :external, 0,
  :available_externally, 1,
  :link_once_any, 2,
  :link_once_odr, 3,
  :link_once_odr_auto_hide, 4,
  :weak_any, 5,
  :weak_odr, 6,
  :appending, 7,
  :internal, 8,
  :private, 9,
  :dll_import, 10,
  :dll_export, 11,
  :external_weak, 12,
  :ghost, 13,
  :common, 14,
  :linker_private, 15,
  :linker_private_weak, 16
]

._enum_linker_mode_ ⇒ Symbol

This enum is provided for backwards-compatibility only. It has no effect.

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linker_mode).

Options:

:destroy_source

:preserve_source_removed

This is the default behavior.

Returns:

• (Symbol)

# File 'lib/llvm/linker_ffi.rb', line 21

enum :linker_mode, [
  :destroy_source, 0,
  :preserve_source_removed, 1
]

._enum_opcode_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:opcode).

Options:

:ret

Terminator Instructions

:br

:switch

:indirect_br

:invoke

:unreachable

removed 6 due to API changes

:add

Standard Binary Operators

:f_add

:sub

:f_sub

:mul

:f_mul

:u_div

:s_div

:f_div

:u_rem

:s_rem

:f_rem

:shl

Logical Operators

:l_shr

:a_shr

:and_

:or_

:xor

:alloca

Memory Operators

:load

:store

:get_element_ptr

:trunc

Cast Operators

:z_ext

:s_ext

:fp_to_ui

:fp_to_si

:ui_to_fp

:si_to_fp

:fp_trunc

:fp_ext

:ptr_to_int

:int_to_ptr

:bit_cast

:addr_space_cast

:i_cmp

Other Operators

:f_cmp

:phi

:call

:select

:user_op1

:user_op2

:va_arg

:extract_element

:insert_element

:shuffle_vector

:extract_value

:insert_value

:fence

Atomic operators

:atomic_cmp_xchg

:atomic_rmw

:resume

Exception Handling Operators

:landing_pad

:cleanup_ret

:catch_ret

:catch_pad

:cleanup_pad

:catch_switch

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 276

enum :opcode, [
  :ret, 1,
  :br, 2,
  :switch, 3,
  :indirect_br, 4,
  :invoke, 5,
  :unreachable, 7,
  :add, 8,
  :f_add, 9,
  :sub, 10,
  :f_sub, 11,
  :mul, 12,
  :f_mul, 13,
  :u_div, 14,
  :s_div, 15,
  :f_div, 16,
  :u_rem, 17,
  :s_rem, 18,
  :f_rem, 19,
  :shl, 20,
  :l_shr, 21,
  :a_shr, 22,
  :and_, 23,
  :or_, 24,
  :xor, 25,
  :alloca, 26,
  :load, 27,
  :store, 28,
  :get_element_ptr, 29,
  :trunc, 30,
  :z_ext, 31,
  :s_ext, 32,
  :fp_to_ui, 33,
  :fp_to_si, 34,
  :ui_to_fp, 35,
  :si_to_fp, 36,
  :fp_trunc, 37,
  :fp_ext, 38,
  :ptr_to_int, 39,
  :int_to_ptr, 40,
  :bit_cast, 41,
  :addr_space_cast, 60,
  :i_cmp, 42,
  :f_cmp, 43,
  :phi, 44,
  :call, 45,
  :select, 46,
  :user_op1, 47,
  :user_op2, 48,
  :va_arg, 49,
  :extract_element, 50,
  :insert_element, 51,
  :shuffle_vector, 52,
  :extract_value, 53,
  :insert_value, 54,
  :fence, 55,
  :atomic_cmp_xchg, 56,
  :atomic_rmw, 57,
  :resume, 58,
  :landing_pad, 59,
  :cleanup_ret, 61,
  :catch_ret, 62,
  :catch_pad, 63,
  :cleanup_pad, 64,
  :catch_switch, 65
]

._enum_real_predicate_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:real_predicate).

Options:

:predicate_false

:oeq

< Always false (always folded)

:ogt

< True if ordered and equal

:oge

< True if ordered and greater than

:olt

< True if ordered and greater than or equal

:ole

< True if ordered and less than

:one

< True if ordered and less than or equal

:ord

< True if ordered and operands are unequal

:uno

< True if ordered (no nans)

:ueq

< True if unordered: isnan(X) | isnan(Y)

:ugt

< True if unordered or equal

:uge

< True if unordered or greater than

:ult

< True if unordered, greater than, or equal

:ule

< True if unordered or less than

:une

< True if unordered, less than, or equal

:predicate_true

< True if unordered or not equal

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 633

enum :real_predicate, [
  :predicate_false, 0,
  :oeq, 1,
  :ogt, 2,
  :oge, 3,
  :olt, 4,
  :ole, 5,
  :one, 6,
  :ord, 7,
  :uno, 8,
  :ueq, 9,
  :ugt, 10,
  :uge, 11,
  :ult, 12,
  :ule, 13,
  :une, 14,
  :predicate_true, 15
]

._enum_reloc_mode_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:reloc_mode).

Options:

:default

:static

:pic

:dynamic_no_pic

Returns:

• (Symbol)

# File 'lib/llvm/target_ffi.rb', line 350

enum :reloc_mode, [
  :default, 0,
  :static, 1,
  :pic, 2,
  :dynamic_no_pic, 3
]

._enum_thread_local_mode_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:thread_local_mode).

Options:

:not_thread_local

:general_dynamic_tls_model

:local_dynamic_tls_model

:initial_exec_tls_model

:local_exec_tls_model

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 689

enum :thread_local_mode, [
  :not_thread_local, 0,
  :general_dynamic_tls_model, 1,
  :local_dynamic_tls_model, 2,
  :initial_exec_tls_model, 3,
  :local_exec_tls_model, 4
]

._enum_type_kind_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:type_kind).

Options:

:void

:half

< type with no size

:float

< 16 bit floating point type

:double

< 32 bit floating point type

:x86_fp80

< 64 bit floating point type

:fp128

< 80 bit floating point type (X87)

:ppc_fp128

< 128 bit floating point type (112-bit mantissa)

:label

< 128 bit floating point type (two 64-bits)

:integer

< Labels

:function

< Arbitrary bit width integers

:struct

< Functions

:array

< Structures

:pointer

< Arrays

:vector

< Pointers

:metadata

< SIMD ‘packed’ format, or other vector type

:x86_mmx

< Metadata

:token

< X86 MMX

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 386

enum :type_kind, [
  :void, 0,
  :half, 1,
  :float, 2,
  :double, 3,
  :x86_fp80, 4,
  :fp128, 5,
  :ppc_fp128, 6,
  :label, 7,
  :integer, 8,
  :function, 9,
  :struct, 10,
  :array, 11,
  :pointer, 12,
  :vector, 13,
  :metadata, 14,
  :x86_mmx, 15,
  :token, 16,
  :scalable_vector, 17,
  :bfloat, 18,
  :x86_amx, 19,
]

._enum_verifier_failure_action_ ⇒ Symbol

@{

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:verifier_failure_action).

Options:

:abort_process

:print_message

verifier will print to stderr and abort()

:return_status

verifier will print to stderr and return 1

Returns:

• (Symbol)

# File 'lib/llvm/analysis_ffi.rb', line 26

enum :verifier_failure_action, [
  :abort_process, 0,
  :print_message, 1,
  :return_status, 2
]

._enum_visibility_ ⇒ Symbol

(Not documented)

This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:visibility).

Options:

:default

:hidden

< The GV is visible

:protected

< The GV is hidden

Returns:

• (Symbol)

# File 'lib/llvm/core_ffi.rb', line 490

enum :visibility, [
  :default, 0,
  :hidden, 1,
  :protected, 2
]

.abi_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 251

attach_function :abi_alignment_of_type, :LLVMABIAlignmentOfType, [OpaqueTargetData, :pointer], :uint

.abi_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 242

attach_function :abi_size_of_type, :LLVMABISizeOfType, [OpaqueTargetData, :pointer], :ulong_long

.add_analysis_passes(t, pm) ⇒ nil

Adds the target-specific analysis passes to the pass manager.

Parameters:

• t (OpaqueTargetMachine)
• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 600

attach_function :add_analysis_passes, :LLVMAddAnalysisPasses, [OpaqueTargetMachine, :pointer], :void

.add_case(switch, on_val, dest) ⇒ nil

Add a case to the switch instruction

Parameters:

• switch (FFI::Pointer(ValueRef))
• on_val (FFI::Pointer(ValueRef))
• dest (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4410

attach_function :add_case, :LLVMAddCase, [:pointer, :pointer, :pointer], :void

.add_clause(landing_pad, clause_val) ⇒ nil

Add a catch or filter clause to the landingpad instruction

Parameters:

• landing_pad (FFI::Pointer(ValueRef))
• clause_val (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4428

attach_function :add_clause, :LLVMAddClause, [:pointer, :pointer], :void

.add_destination(indirect_br, dest) ⇒ nil

Add a destination to the indirectbr instruction

Parameters:

• indirect_br (FFI::Pointer(ValueRef))
• dest (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4419

attach_function :add_destination, :LLVMAddDestination, [:pointer, :pointer], :void

.add_function(m, name, function_ty) ⇒ FFI::Pointer(ValueRef)

Add a function to a module under a specified name.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)
• function_ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Functionllvm::Function::Create()

# File 'lib/llvm/core_ffi.rb', line 1114

attach_function :add_function, :LLVMAddFunction, [:pointer, :string, :pointer], :pointer

.add_global(m, ty, name) ⇒ FFI::Pointer(ValueRef)

This group contains functions that operate on global variable values.

@{

Parameters:

• m (FFI::Pointer(ModuleRef))
• ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::GlobalVariable

# File 'lib/llvm/core_ffi.rb', line 3207

attach_function :add_global, :LLVMAddGlobal, [:pointer, :pointer, :string], :pointer

.add_global_in_address_space(m, ty, name, address_space) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))
• ty (FFI::Pointer(TypeRef))
• name (String)
• address_space (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3218

attach_function :add_global_in_address_space, :LLVMAddGlobalInAddressSpace, [:pointer, :pointer, :string, :uint], :pointer

.add_global_mapping(ee, global, addr) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• global (FFI::Pointer(ValueRef))
• addr (FFI::Pointer(*Void))

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 315

attach_function :add_global_mapping, :LLVMAddGlobalMapping, [OpaqueExecutionEngine, :pointer, :pointer], :void

.add_incoming(phi_node, incoming_values, incoming_blocks, count) ⇒ nil

Add an incoming value to the end of a PHI list.

Parameters:

• phi_node (FFI::Pointer(ValueRef))
• incoming_values (FFI::Pointer(*ValueRef))
• incoming_blocks (FFI::Pointer(*BasicBlockRef))
• count (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4160

attach_function :add_incoming, :LLVMAddIncoming, [:pointer, :pointer, :pointer, :uint], :void

.add_module(ee, m) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• m (FFI::Pointer(ModuleRef))

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 259

attach_function :add_module, :LLVMAddModule, [OpaqueExecutionEngine, :pointer], :void

.add_named_metadata_operand(m, name, val) ⇒ nil

Add an operand to named metadata.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)
• val (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Modulellvm::Module::getNamedMetadata()
• llvmllvm::MDNodellvm::MDNode::addOperand()

# File 'lib/llvm/core_ffi.rb', line 1102

attach_function :add_named_metadata_operand, :LLVMAddNamedMetadataOperand, [:pointer, :string, :pointer], :void

.add_symbol(symbol_name, symbol_value) ⇒ nil

(Not documented)

Parameters:

• symbol_name (String)
• symbol_value (FFI::Pointer(*Void))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 47

attach_function :add_symbol, :LLVMAddSymbol, [:string, :pointer], :void

.add_target_dependent_function_attr(fn, a, v) ⇒ nil

Add a target-dependent attribute to a function

Parameters:

• fn (FFI::Pointer(ValueRef))
• a (String)
• v (String)

Returns:

• (nil)

See Also:

• llvmllvm::AttrBuilderllvm::AttrBuilder::addAttribute()

# File 'lib/llvm/core_ffi.rb', line 3444

attach_function :add_target_dependent_function_attr, :LLVMAddTargetDependentFunctionAttr, [:pointer, :string, :string], :void

.add_target_library_info(tli, pm) ⇒ nil

(Not documented)

Parameters:

• tli (OpaqueTargetLibraryInfotData)
• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 146

attach_function :add_target_library_info, :LLVMAddTargetLibraryInfo, [OpaqueTargetLibraryInfotData, :pointer], :void

.align_of(ty) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2815

attach_function :align_of, :LLVMAlignOf, [:pointer], :pointer

.append_basic_block(fn, name) ⇒ FFI::Pointer(BasicBlockRef)

Append a basic block to the end of a function using the global context.

Parameters:

• fn (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::Create()

# File 'lib/llvm/core_ffi.rb', line 3786

attach_function :append_basic_block, :LLVMAppendBasicBlock, [:pointer, :string], :pointer

.append_basic_block_in_context(c, fn, name) ⇒ FFI::Pointer(BasicBlockRef)

Append a basic block to the end of a function.

Parameters:

• c (FFI::Pointer(ContextRef))
• fn (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::Create()

# File 'lib/llvm/core_ffi.rb', line 3774

attach_function :append_basic_block_in_context, :LLVMAppendBasicBlockInContext, [:pointer, :pointer, :string], :pointer

.array_type(element_type, element_count) ⇒ FFI::Pointer(TypeRef)

Create a fixed size array type that refers to a specific type.

The created type will exist in the context that its element type exists in.

Parameters:

• element_type (FFI::Pointer(TypeRef))
• element_count (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::ArrayTypellvm::ArrayType::get()

# File 'lib/llvm/core_ffi.rb', line 1611

attach_function :array_type, :LLVMArrayType, [:pointer, :uint], :pointer

.basic_block_as_value(bb) ⇒ FFI::Pointer(ValueRef)

Convert a basic block instance to a value type.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3647

attach_function :basic_block_as_value, :LLVMBasicBlockAsValue, [:pointer], :pointer

.block_address(f, bb) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• f (FFI::Pointer(ValueRef))
• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3058

attach_function :block_address, :LLVMBlockAddress, [:pointer, :pointer], :pointer

.build_a_shr(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4679

attach_function :build_a_shr, :LLVMBuildAShr, [:pointer, :pointer, :pointer, :string], :pointer

.build_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

Arithmetic

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4448

attach_function :build_add, :LLVMBuildAdd, [:pointer, :pointer, :pointer, :string], :pointer

.build_addr_space_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5032

attach_function :build_addr_space_cast, :LLVMBuildAddrSpaceCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_aggregate_ret(builder_ref, ret_vals, n) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ret_vals (FFI::Pointer(*ValueRef))
• n (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4330

attach_function :build_aggregate_ret, :LLVMBuildAggregateRet, [:pointer, :pointer, :uint], :pointer

.build_alloca(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4805

attach_function :build_alloca, :LLVMBuildAlloca, [:pointer, :pointer, :string], :pointer

.build_and(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4690

attach_function :build_and, :LLVMBuildAnd, [:pointer, :pointer, :pointer, :string], :pointer

.build_array_alloca(builder_ref, ty, val, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• val (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4816

attach_function :build_array_alloca, :LLVMBuildArrayAlloca, [:pointer, :pointer, :pointer, :string], :pointer

.build_array_malloc(builder_ref, ty, val, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• val (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4795

attach_function :build_array_malloc, :LLVMBuildArrayMalloc, [:pointer, :pointer, :pointer, :string], :pointer

.build_atomic_rmw(b, op, ptr, val, ordering, single_thread) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• op (Symbol from _enum_atomic_rmw_bin_op_)
• ptr (FFI::Pointer(ValueRef))
• val (FFI::Pointer(ValueRef))
• ordering (Symbol from _enum_atomic_ordering_)
• single_thread (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi_v2.rb', line 274

attach_function :build_atomic_rmw, :LLVMBuildAtomicRMW, [:pointer, :atomic_rmw_bin_op, :pointer, :pointer, :atomic_ordering, :int], :pointer

.build_bin_op(b, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• op (Symbol from _enum_opcode_)
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4724

attach_function :build_bin_op, :LLVMBuildBinOp, [:pointer, :opcode, :pointer, :pointer, :string], :pointer

.build_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5021

attach_function :build_bit_cast, :LLVMBuildBitCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_br(builder_ref, dest) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• dest (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4339

attach_function :build_br, :LLVMBuildBr, [:pointer, :pointer], :pointer

.build_cast(b, op, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• op (Symbol from _enum_opcode_)
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5077

attach_function :build_cast, :LLVMBuildCast, [:pointer, :opcode, :pointer, :pointer, :string], :pointer

.build_cond_br(builder_ref, if_, then_, else_) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• if_ (FFI::Pointer(ValueRef))
• then_ (FFI::Pointer(BasicBlockRef))
• else_ (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4350

attach_function :build_cond_br, :LLVMBuildCondBr, [:pointer, :pointer, :pointer, :pointer], :pointer

.build_exact_s_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4602

attach_function :build_exact_s_div, :LLVMBuildExactSDiv, [:pointer, :pointer, :pointer, :string], :pointer

.build_extract_element(builder_ref, vec_val, index, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• vec_val (FFI::Pointer(ValueRef))
• index (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5178

attach_function :build_extract_element, :LLVMBuildExtractElement, [:pointer, :pointer, :pointer, :string], :pointer

.build_extract_value(builder_ref, agg_val, index, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• agg_val (FFI::Pointer(ValueRef))
• index (Integer)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5213

attach_function :build_extract_value, :LLVMBuildExtractValue, [:pointer, :pointer, :uint, :string], :pointer

.build_f_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4481

attach_function :build_f_add, :LLVMBuildFAdd, [:pointer, :pointer, :pointer, :string], :pointer

.build_f_cmp(builder_ref, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• op (Symbol from _enum_real_predicate_)
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5134

attach_function :build_f_cmp, :LLVMBuildFCmp, [:pointer, :real_predicate, :pointer, :pointer, :string], :pointer

.build_f_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4613

attach_function :build_f_div, :LLVMBuildFDiv, [:pointer, :pointer, :pointer, :string], :pointer

.build_f_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4569

attach_function :build_f_mul, :LLVMBuildFMul, [:pointer, :pointer, :pointer, :string], :pointer

.build_f_neg(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4764

attach_function :build_f_neg, :LLVMBuildFNeg, [:pointer, :pointer, :string], :pointer

.build_f_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4646

attach_function :build_f_rem, :LLVMBuildFRem, [:pointer, :pointer, :pointer, :string], :pointer

.build_f_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4525

attach_function :build_f_sub, :LLVMBuildFSub, [:pointer, :pointer, :pointer, :string], :pointer

.build_fence(b, ordering, single_thread, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• ordering (Symbol from _enum_atomic_ordering_)
• single_thread (Integer)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5256

attach_function :build_fence, :LLVMBuildFence, [:pointer, :atomic_ordering, :int, :string], :pointer

.build_fp_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5110

attach_function :build_fp_cast, :LLVMBuildFPCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_fp_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4988

attach_function :build_fp_ext, :LLVMBuildFPExt, [:pointer, :pointer, :pointer, :string], :pointer

.build_fp_to_si(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4944

attach_function :build_fp_to_si, :LLVMBuildFPToSI, [:pointer, :pointer, :pointer, :string], :pointer

.build_fp_to_ui(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4933

attach_function :build_fp_to_ui, :LLVMBuildFPToUI, [:pointer, :pointer, :pointer, :string], :pointer

.build_fp_trunc(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4977

attach_function :build_fp_trunc, :LLVMBuildFPTrunc, [:pointer, :pointer, :pointer, :string], :pointer

.build_free(builder_ref, pointer_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• pointer_val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4825

attach_function :build_free, :LLVMBuildFree, [:pointer, :pointer], :pointer

.build_global_string(b, str, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• str (String)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4845

attach_function :build_global_string, :LLVMBuildGlobalString, [:pointer, :string, :string], :pointer

.build_global_string_ptr(b, str, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• str (String)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4855

attach_function :build_global_string_ptr, :LLVMBuildGlobalStringPtr, [:pointer, :string, :string], :pointer

.build_i_cmp(builder_ref, op, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

Comparisons

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• op (Symbol from _enum_int_predicate_)
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5122

attach_function :build_i_cmp, :LLVMBuildICmp, [:pointer, :int_predicate, :pointer, :pointer, :string], :pointer

.build_indirect_br(b, addr, num_dests) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• addr (FFI::Pointer(ValueRef))
• num_dests (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4371

attach_function :build_indirect_br, :LLVMBuildIndirectBr, [:pointer, :pointer, :uint], :pointer

.build_insert_element(builder_ref, vec_val, elt_val, index, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• vec_val (FFI::Pointer(ValueRef))
• elt_val (FFI::Pointer(ValueRef))
• index (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5190

attach_function :build_insert_element, :LLVMBuildInsertElement, [:pointer, :pointer, :pointer, :pointer, :string], :pointer

.build_insert_value(builder_ref, agg_val, elt_val, index, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• agg_val (FFI::Pointer(ValueRef))
• elt_val (FFI::Pointer(ValueRef))
• index (Integer)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5225

attach_function :build_insert_value, :LLVMBuildInsertValue, [:pointer, :pointer, :pointer, :uint, :string], :pointer

.build_int_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5099

attach_function :build_int_cast, :LLVMBuildIntCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_int_to_ptr(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5010

attach_function :build_int_to_ptr, :LLVMBuildIntToPtr, [:pointer, :pointer, :pointer, :string], :pointer

.build_is_not_null(builder_ref, val, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5245

attach_function :build_is_not_null, :LLVMBuildIsNotNull, [:pointer, :pointer, :string], :pointer

.build_is_null(builder_ref, val, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5235

attach_function :build_is_null, :LLVMBuildIsNull, [:pointer, :pointer, :string], :pointer

.build_l_shr(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4668

attach_function :build_l_shr, :LLVMBuildLShr, [:pointer, :pointer, :pointer, :string], :pointer

.build_landing_pad(b, ty, pers_fn, num_clauses, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• pers_fn (FFI::Pointer(ValueRef))
• num_clauses (Integer)
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4383

attach_function :build_landing_pad, :LLVMBuildLandingPad, [:pointer, :pointer, :pointer, :uint, :string], :pointer

.build_malloc(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

Memory

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4784

attach_function :build_malloc, :LLVMBuildMalloc, [:pointer, :pointer, :string], :pointer

.build_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4536

attach_function :build_mul, :LLVMBuildMul, [:pointer, :pointer, :pointer, :string], :pointer

.build_neg(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4734

attach_function :build_neg, :LLVMBuildNeg, [:pointer, :pointer, :string], :pointer

.build_not(builder_ref, v, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4774

attach_function :build_not, :LLVMBuildNot, [:pointer, :pointer, :string], :pointer

.build_nsw_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4459

attach_function :build_nsw_add, :LLVMBuildNSWAdd, [:pointer, :pointer, :pointer, :string], :pointer

.build_nsw_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4547

attach_function :build_nsw_mul, :LLVMBuildNSWMul, [:pointer, :pointer, :pointer, :string], :pointer

.build_nsw_neg(b, v, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4744

attach_function :build_nsw_neg, :LLVMBuildNSWNeg, [:pointer, :pointer, :string], :pointer

.build_nsw_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4503

attach_function :build_nsw_sub, :LLVMBuildNSWSub, [:pointer, :pointer, :pointer, :string], :pointer

.build_nuw_add(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4470

attach_function :build_nuw_add, :LLVMBuildNUWAdd, [:pointer, :pointer, :pointer, :string], :pointer

.build_nuw_mul(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4558

attach_function :build_nuw_mul, :LLVMBuildNUWMul, [:pointer, :pointer, :pointer, :string], :pointer

.build_nuw_neg(b, v, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4754

attach_function :build_nuw_neg, :LLVMBuildNUWNeg, [:pointer, :pointer, :string], :pointer

.build_nuw_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4514

attach_function :build_nuw_sub, :LLVMBuildNUWSub, [:pointer, :pointer, :pointer, :string], :pointer

.build_or(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4701

attach_function :build_or, :LLVMBuildOr, [:pointer, :pointer, :pointer, :string], :pointer

.build_phi(builder_ref, ty, name) ⇒ FFI::Pointer(ValueRef)

Miscellaneous instructions

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5144

attach_function :build_phi, :LLVMBuildPhi, [:pointer, :pointer, :string], :pointer

.build_pointer_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5088

attach_function :build_pointer_cast, :LLVMBuildPointerCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_ptr_to_int(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4999

attach_function :build_ptr_to_int, :LLVMBuildPtrToInt, [:pointer, :pointer, :pointer, :string], :pointer

.build_resume(b, exn) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• b (FFI::Pointer(BuilderRef))
• exn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4392

attach_function :build_resume, :LLVMBuildResume, [:pointer, :pointer], :pointer

.build_ret(builder_ref, v) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4320

attach_function :build_ret, :LLVMBuildRet, [:pointer, :pointer], :pointer

.build_ret_void(builder_ref) ⇒ FFI::Pointer(ValueRef)

Terminators

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4311

attach_function :build_ret_void, :LLVMBuildRetVoid, [:pointer], :pointer

.build_s_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4591

attach_function :build_s_div, :LLVMBuildSDiv, [:pointer, :pointer, :pointer, :string], :pointer

.build_s_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4922

attach_function :build_s_ext, :LLVMBuildSExt, [:pointer, :pointer, :pointer, :string], :pointer

.build_s_ext_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5054

attach_function :build_s_ext_or_bit_cast, :LLVMBuildSExtOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_s_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4635

attach_function :build_s_rem, :LLVMBuildSRem, [:pointer, :pointer, :pointer, :string], :pointer

.build_select(builder_ref, if_, then_, else_, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• if_ (FFI::Pointer(ValueRef))
• then_ (FFI::Pointer(ValueRef))
• else_ (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5156

attach_function :build_select, :LLVMBuildSelect, [:pointer, :pointer, :pointer, :pointer, :string], :pointer

.build_shl(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4657

attach_function :build_shl, :LLVMBuildShl, [:pointer, :pointer, :pointer, :string], :pointer

.build_shuffle_vector(builder_ref, v1, v2, mask, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v1 (FFI::Pointer(ValueRef))
• v2 (FFI::Pointer(ValueRef))
• mask (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5202

attach_function :build_shuffle_vector, :LLVMBuildShuffleVector, [:pointer, :pointer, :pointer, :pointer, :string], :pointer

.build_si_to_fp(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4966

attach_function :build_si_to_fp, :LLVMBuildSIToFP, [:pointer, :pointer, :pointer, :string], :pointer

.build_store(builder_ref, val, ptr) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• ptr (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4835

attach_function :build_store, :LLVMBuildStore, [:pointer, :pointer, :pointer], :pointer

.build_sub(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4492

attach_function :build_sub, :LLVMBuildSub, [:pointer, :pointer, :pointer, :string], :pointer

.build_switch(builder_ref, v, else_, num_cases) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• v (FFI::Pointer(ValueRef))
• else_ (FFI::Pointer(BasicBlockRef))
• num_cases (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4361

attach_function :build_switch, :LLVMBuildSwitch, [:pointer, :pointer, :pointer, :uint], :pointer

.build_trunc(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

Casts

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4900

attach_function :build_trunc, :LLVMBuildTrunc, [:pointer, :pointer, :pointer, :string], :pointer

.build_trunc_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5065

attach_function :build_trunc_or_bit_cast, :LLVMBuildTruncOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

.build_u_div(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4580

attach_function :build_u_div, :LLVMBuildUDiv, [:pointer, :pointer, :pointer, :string], :pointer

.build_u_rem(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4624

attach_function :build_u_rem, :LLVMBuildURem, [:pointer, :pointer, :pointer, :string], :pointer

.build_ui_to_fp(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4955

attach_function :build_ui_to_fp, :LLVMBuildUIToFP, [:pointer, :pointer, :pointer, :string], :pointer

.build_unreachable(builder_ref) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4400

attach_function :build_unreachable, :LLVMBuildUnreachable, [:pointer], :pointer

.build_va_arg(builder_ref, list, ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• list (FFI::Pointer(ValueRef))
• ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5167

attach_function :build_va_arg, :LLVMBuildVAArg, [:pointer, :pointer, :pointer, :string], :pointer

.build_xor(builder_ref, lhs, rhs, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• lhs (FFI::Pointer(ValueRef))
• rhs (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4712

attach_function :build_xor, :LLVMBuildXor, [:pointer, :pointer, :pointer, :string], :pointer

.build_z_ext(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4911

attach_function :build_z_ext, :LLVMBuildZExt, [:pointer, :pointer, :pointer, :string], :pointer

.build_z_ext_or_bit_cast(builder_ref, val, dest_ty, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder_ref (FFI::Pointer(BuilderRef))
• val (FFI::Pointer(ValueRef))
• dest_ty (FFI::Pointer(TypeRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 5043

attach_function :build_z_ext_or_bit_cast, :LLVMBuildZExtOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

.byte_order(td) ⇒ Symbol from _enum_byte_ordering_

(Not documented)

Parameters:

• td (OpaqueTargetData)

Returns:

• (Symbol from _enum_byte_ordering_)

# File 'lib/llvm/target_ffi.rb', line 162

attach_function :byte_order, :LLVMByteOrder, [OpaqueTargetData], :byte_ordering

.call_frame_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 260

attach_function :call_frame_alignment_of_type, :LLVMCallFrameAlignmentOfType, [OpaqueTargetData, :pointer], :uint

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4250

attach_function :clear_insertion_position, :LLVMClearInsertionPosition, [:pointer], :void

.clone_module(m) ⇒ FFI::Pointer(ModuleRef)

Return an exact copy of the specified module.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ModuleRef))

# File 'lib/llvm/core_ffi.rb', line 943

attach_function :clone_module, :LLVMCloneModule, [:pointer], :pointer

.const_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2864

attach_function :const_add, :LLVMConstAdd, [:pointer, :pointer], :pointer

.const_addr_space_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2990

attach_function :const_addr_space_cast, :LLVMConstAddrSpaceCast, [:pointer, :pointer], :pointer

.const_all_ones(ty) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value referring to the instance of a type consisting of all ones.

This is only valid for integer types.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Constantllvm::Constant::getAllOnesValue()

# File 'lib/llvm/core_ffi.rb', line 2540

attach_function :const_all_ones, :LLVMConstAllOnes, [:pointer], :pointer

.const_array(element_ty, constant_vals, length) ⇒ FFI::Pointer(ValueRef)

Create a ConstantArray from values.

Parameters:

• element_ty (FFI::Pointer(TypeRef))
• constant_vals (FFI::Pointer(*ValueRef))
• length (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantArrayllvm::ConstantArray::get()

# File 'lib/llvm/core_ffi.rb', line 2759

attach_function :const_array, :LLVMConstArray, [:pointer, :pointer, :uint], :pointer

.const_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2981

attach_function :const_bit_cast, :LLVMConstBitCast, [:pointer, :pointer], :pointer

.const_extract_element(vector_constant, index_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• vector_constant (FFI::Pointer(ValueRef))
• index_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3017

attach_function :const_extract_element, :LLVMConstExtractElement, [:pointer, :pointer], :pointer

.const_inline_asm(ty, asm_string, constraints, has_side_effects, is_align_stack) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• ty (FFI::Pointer(TypeRef))
• asm_string (String)
• constraints (String)
• has_side_effects (Integer)
• is_align_stack (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3049

attach_function :const_inline_asm, :LLVMConstInlineAsm, [:pointer, :string, :string, :int, :int], :pointer

.const_insert_element(vector_constant, element_value_constant, index_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• vector_constant (FFI::Pointer(ValueRef))
• element_value_constant (FFI::Pointer(ValueRef))
• index_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3027

attach_function :const_insert_element, :LLVMConstInsertElement, [:pointer, :pointer, :pointer], :pointer

.const_int(int_ty, n, sign_extend) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value for an integer type.

The returned value corresponds to a llvm::ConstantInt.

Parameters:

• IntTy —

  Integer type to obtain value of.

• N —

  The value the returned instance should refer to.

• SignExtend —

  Whether to sign extend the produced value.

• int_ty (FFI::Pointer(TypeRef))
• n (Integer)
• sign_extend (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

# File 'lib/llvm/core_ffi.rb', line 2577

attach_function :const_int, :LLVMConstInt, [:pointer, :ulong_long, :int], :pointer

.const_int_get_s_ext_value(constant_val) ⇒ Integer

Obtain the sign extended value for an integer constant value.

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::getSExtValue()

# File 'lib/llvm/core_ffi.rb', line 2670

attach_function :const_int_get_s_ext_value, :LLVMConstIntGetSExtValue, [:pointer], :long_long

.const_int_get_z_ext_value(constant_val) ⇒ Integer

Obtain the zero extended value for an integer constant value.

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::getZExtValue()

# File 'lib/llvm/core_ffi.rb', line 2660

attach_function :const_int_get_z_ext_value, :LLVMConstIntGetZExtValue, [:pointer], :ulong_long

.const_int_of_arbitrary_precision(int_ty, num_words, words) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value for an integer of arbitrary precision.

Parameters:

• int_ty (FFI::Pointer(TypeRef))
• num_words (Integer)
• words (FFI::Pointer(*U_long))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

# File 'lib/llvm/core_ffi.rb', line 2589

attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [:pointer, :uint, :pointer], :pointer

.const_int_of_string(int_ty, text, radix) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value for an integer parsed from a string.

A similar API, LLVMConstIntOfStringAndSize is also available. If the string’s length is available, it is preferred to call that function instead.

Parameters:

• int_ty (FFI::Pointer(TypeRef))
• text (String)
• radix (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

# File 'lib/llvm/core_ffi.rb', line 2605

attach_function :const_int_of_string, :LLVMConstIntOfString, [:pointer, :string, :uchar], :pointer

.const_int_of_string_and_size(int_ty, text, s_len, radix) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value for an integer parsed from a string with specified length.

Parameters:

• int_ty (FFI::Pointer(TypeRef))
• text (String)
• s_len (Integer)
• radix (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

# File 'lib/llvm/core_ffi.rb', line 2619

attach_function :const_int_of_string_and_size, :LLVMConstIntOfStringAndSize, [:pointer, :string, :uint, :uchar], :pointer

.const_int_to_ptr(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2972

attach_function :const_int_to_ptr, :LLVMConstIntToPtr, [:pointer, :pointer], :pointer

.const_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2918

attach_function :const_mul, :LLVMConstMul, [:pointer, :pointer], :pointer

.const_named_struct(struct_ty, constant_vals, count) ⇒ FFI::Pointer(ValueRef)

Create a non-anonymous ConstantStruct from values.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))
• constant_vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantStructllvm::ConstantStruct::get()

# File 'lib/llvm/core_ffi.rb', line 2771

attach_function :const_named_struct, :LLVMConstNamedStruct, [:pointer, :pointer, :uint], :pointer

.const_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2831

attach_function :const_neg, :LLVMConstNeg, [:pointer], :pointer

.const_not(constant_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2855

attach_function :const_not, :LLVMConstNot, [:pointer], :pointer

.const_nsw_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2873

attach_function :const_nsw_add, :LLVMConstNSWAdd, [:pointer, :pointer], :pointer

.const_nsw_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2927

attach_function :const_nsw_mul, :LLVMConstNSWMul, [:pointer, :pointer], :pointer

.const_nsw_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2839

attach_function :const_nsw_neg, :LLVMConstNSWNeg, [:pointer], :pointer

.const_nsw_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2900

attach_function :const_nsw_sub, :LLVMConstNSWSub, [:pointer, :pointer], :pointer

.const_null(ty) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value referring to the null instance of a type.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Constantllvm::Constant::getNullValue()

# File 'lib/llvm/core_ffi.rb', line 2527

attach_function :const_null, :LLVMConstNull, [:pointer], :pointer

.const_nuw_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2882

attach_function :const_nuw_add, :LLVMConstNUWAdd, [:pointer, :pointer], :pointer

.const_nuw_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2936

attach_function :const_nuw_mul, :LLVMConstNUWMul, [:pointer, :pointer], :pointer

.const_nuw_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2847

attach_function :const_nuw_neg, :LLVMConstNUWNeg, [:pointer], :pointer

.const_nuw_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2909

attach_function :const_nuw_sub, :LLVMConstNUWSub, [:pointer, :pointer], :pointer

.const_pointer_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3008

attach_function :const_pointer_cast, :LLVMConstPointerCast, [:pointer, :pointer], :pointer

.const_pointer_null(ty) ⇒ FFI::Pointer(ValueRef)

Obtain a constant that is a constant pointer pointing to NULL for a specified type.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2559

attach_function :const_pointer_null, :LLVMConstPointerNull, [:pointer], :pointer

.const_ptr_to_int(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2963

attach_function :const_ptr_to_int, :LLVMConstPtrToInt, [:pointer, :pointer], :pointer

.const_real(real_ty, n) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value referring to a double floating point value.

Parameters:

• real_ty (FFI::Pointer(TypeRef))
• n (Float)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2628

attach_function :const_real, :LLVMConstReal, [:pointer, :double], :pointer

.const_real_get_double(constant_val, loses_info) ⇒ Float

Obtain the double value for an floating point constant value. losesInfo indicates if some precision was lost in the conversion.

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• loses_info (FFI::Pointer(*Bool))

Returns:

• (Float)

See Also:

• llvmllvm::ConstantFPllvm::ConstantFP::getDoubleValue

# File 'lib/llvm/core_ffi.rb', line 2682

attach_function :const_real_get_double, :LLVMConstRealGetDouble, [:pointer, :pointer], :double

.const_real_of_string(real_ty, text) ⇒ FFI::Pointer(ValueRef)

Obtain a constant for a floating point value parsed from a string.

A similar API, LLVMConstRealOfStringAndSize is also available. It should be used if the input string’s length is known.

Parameters:

• real_ty (FFI::Pointer(TypeRef))
• text (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2640

attach_function :const_real_of_string, :LLVMConstRealOfString, [:pointer, :string], :pointer

.const_real_of_string_and_size(real_ty, text, s_len) ⇒ FFI::Pointer(ValueRef)

Obtain a constant for a floating point value parsed from a string.

Parameters:

• real_ty (FFI::Pointer(TypeRef))
• text (String)
• s_len (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2650

attach_function :const_real_of_string_and_size, :LLVMConstRealOfStringAndSize, [:pointer, :string, :uint], :pointer

.const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• vector_a_constant (FFI::Pointer(ValueRef))
• vector_b_constant (FFI::Pointer(ValueRef))
• mask_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3037

attach_function :const_shuffle_vector, :LLVMConstShuffleVector, [:pointer, :pointer, :pointer], :pointer

.const_string(str, length, dont_null_terminate) ⇒ FFI::Pointer(ValueRef)

Create a ConstantDataSequential with string content in the global context.

This is the same as LLVMConstStringInContext except it operates on the global context.

Parameters:

• str (String)
• length (Integer)
• dont_null_terminate (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• LLVMConstStringInContext()
• llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()

# File 'lib/llvm/core_ffi.rb', line 2698

attach_function :const_string, :LLVMConstString, [:string, :uint, :int], :pointer

.const_string_in_context(c, str, length, dont_null_terminate) ⇒ FFI::Pointer(ValueRef)

Create a ConstantDataSequential and initialize it with a string.

Parameters:

• c (FFI::Pointer(ContextRef))
• str (String)
• length (Integer)
• dont_null_terminate (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()

# File 'lib/llvm/core_ffi_v2.rb', line 287

attach_function :const_string_in_context2, :LLVMConstStringInContext2, [:pointer, :string, :size_t, :int], :pointer

.const_struct(constant_vals, count, packed) ⇒ FFI::Pointer(ValueRef)

Create a ConstantStruct in the global Context.

This is the same as LLVMConstStructInContext except it operates on the global Context.

Parameters:

• constant_vals (FFI::Pointer(*ValueRef))
• count (Integer)
• packed (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• LLVMConstStructInContext()

# File 'lib/llvm/core_ffi.rb', line 2747

attach_function :const_struct, :LLVMConstStruct, [:pointer, :uint, :int], :pointer

.const_struct_in_context(c, constant_vals, count, packed) ⇒ FFI::Pointer(ValueRef)

Create an anonymous ConstantStruct with the specified values.

Parameters:

• c (FFI::Pointer(ContextRef))
• constant_vals (FFI::Pointer(*ValueRef))
• count (Integer)
• packed (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantStructllvm::ConstantStruct::getAnon()

# File 'lib/llvm/core_ffi.rb', line 2732

attach_function :const_struct_in_context, :LLVMConstStructInContext, [:pointer, :pointer, :uint, :int], :pointer

.const_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2891

attach_function :const_sub, :LLVMConstSub, [:pointer, :pointer], :pointer

.const_trunc(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2954

attach_function :const_trunc, :LLVMConstTrunc, [:pointer, :pointer], :pointer

.const_trunc_or_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• constant_val (FFI::Pointer(ValueRef))
• to_type (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2999

attach_function :const_trunc_or_bit_cast, :LLVMConstTruncOrBitCast, [:pointer, :pointer], :pointer

.const_vector(scalar_constant_vals, size) ⇒ FFI::Pointer(ValueRef)

Create a ConstantVector from values.

Parameters:

• scalar_constant_vals (FFI::Pointer(*ValueRef))
• size (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::ConstantVectorllvm::ConstantVector::get()

# File 'lib/llvm/core_ffi.rb', line 2793

attach_function :const_vector, :LLVMConstVector, [:pointer, :uint], :pointer

.const_xor(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• lhs_constant (FFI::Pointer(ValueRef))
• rhs_constant (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2945

attach_function :const_xor, :LLVMConstXor, [:pointer, :pointer], :pointer

.context_create ⇒ FFI::Pointer(ContextRef)

Create a new context.

Every call to this function should be paired with a call to LLVMContextDispose() or the context will leak memory.

Returns:

• (FFI::Pointer(ContextRef))

# File 'lib/llvm/core_ffi.rb', line 829

attach_function :context_create, :LLVMContextCreate, [], :pointer

.context_dispose(c) ⇒ nil

Destroy a context instance.

This should be called for every call to LLVMContextCreate() or memory will be leaked.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 869

attach_function :context_dispose, :LLVMContextDispose, [:pointer], :void

.context_set_diagnostic_handler(c, handler, diagnostic_context) ⇒ nil

Set the diagnostic handler for this context.

Parameters:

• c (FFI::Pointer(ContextRef))
• handler (Proc(_callback_diagnostic_handler_))
• diagnostic_context (FFI::Pointer(*Void))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 846

attach_function :context_set_diagnostic_handler, :LLVMContextSetDiagnosticHandler, [:pointer, :diagnostic_handler, :pointer], :void

.context_set_yield_callback(c, callback, opaque_handle) ⇒ nil

Set the yield callback function for this context.

Parameters:

• c (FFI::Pointer(ContextRef))
• callback (Proc(_callback_yield_callback_))
• opaque_handle (FFI::Pointer(*Void))

Returns:

• (nil)

See Also:

• LLVMContext::setYieldCallback()

# File 'lib/llvm/core_ffi.rb', line 858

attach_function :context_set_yield_callback, :LLVMContextSetYieldCallback, [:pointer, :yield_callback, :pointer], :void

.copy_string_rep_of_target_data(td) ⇒ String

(Not documented)

Parameters:

• td (OpaqueTargetData)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 154

attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :string

.count_basic_blocks(fn) ⇒ Integer

Obtain the number of basic blocks in a function.

Parameters:

• Fn —

  Function value to operate on.

• fn (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3698

attach_function :count_basic_blocks, :LLVMCountBasicBlocks, [:pointer], :uint

.count_incoming(phi_node) ⇒ Integer

Obtain the number of incoming basic blocks to a PHI node.

Parameters:

• phi_node (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 4168

attach_function :count_incoming, :LLVMCountIncoming, [:pointer], :uint

.count_param_types(function_ty) ⇒ Integer

Obtain the number of parameters this function accepts.

Parameters:

• function_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 1469

attach_function :count_param_types, :LLVMCountParamTypes, [:pointer], :uint

.count_params(fn) ⇒ Integer

Obtain the number of parameters in a function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::arg_size()

# File 'lib/llvm/core_ffi.rb', line 3454

attach_function :count_params, :LLVMCountParams, [:pointer], :uint

.count_struct_element_types(struct_ty) ⇒ Integer

Get the number of elements defined inside the structure.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

See Also:

• llvmllvm::StructTypellvm::StructType::getNumElements()

# File 'lib/llvm/core_ffi.rb', line 1558

attach_function :count_struct_element_types, :LLVMCountStructElementTypes, [:pointer], :uint

.create_builder ⇒ FFI::Pointer(BuilderRef)

(Not documented)

Returns:

• (FFI::Pointer(BuilderRef))

# File 'lib/llvm/core_ffi.rb', line 4206

attach_function :create_builder, :LLVMCreateBuilder, [], :pointer

.create_builder_in_context(c) ⇒ FFI::Pointer(BuilderRef)

An instruction builder represents a point within a basic block and is the exclusive means of building instructions using the C interface.

@{

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(BuilderRef))

# File 'lib/llvm/core_ffi.rb', line 4199

attach_function :create_builder_in_context, :LLVMCreateBuilderInContext, [:pointer], :pointer

.create_execution_engine_for_module(out_ee, m, out_error) ⇒ Integer

– Operations on execution engines ———————————–===

Parameters:

• out_ee (FFI::Pointer(*ExecutionEngineRef))
• m (FFI::Pointer(ModuleRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 138

attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int

.create_function_pass_manager(mp) ⇒ FFI::Pointer(PassManagerRef)

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

• mp (FFI::Pointer(ModuleProviderRef))

Returns:

• (FFI::Pointer(PassManagerRef))

# File 'lib/llvm/core_ffi.rb', line 5367

attach_function :create_function_pass_manager, :LLVMCreateFunctionPassManager, [:pointer], :pointer

.create_function_pass_manager_for_module(m) ⇒ FFI::Pointer(PassManagerRef)

Constructs a new function-by-function pass pipeline over the module

provider. It does not take ownership of the module provider. This type of
pipeline is suitable for code generation and JIT compilation tasks.
@see llvm::FunctionPassManager::FunctionPassManager

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(PassManagerRef))

# File 'lib/llvm/core_ffi.rb', line 5359

attach_function :create_function_pass_manager_for_module, :LLVMCreateFunctionPassManagerForModule, [:pointer], :pointer

.create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

• ty (FFI::Pointer(TypeRef))
• n (Float)

Returns:

• (OpaqueGenericValue)

# File 'lib/llvm/execution_engine_ffi.rb', line 86

attach_function :create_generic_value_of_float, :LLVMCreateGenericValueOfFloat, [:pointer, :double], OpaqueGenericValue

.create_generic_value_of_int(ty, n, is_signed) ⇒ OpaqueGenericValue

– Operations on generic values ————————————–===

Parameters:

• ty (FFI::Pointer(TypeRef))
• n (Integer)
• is_signed (Integer)

Returns:

• (OpaqueGenericValue)

# File 'lib/llvm/execution_engine_ffi.rb', line 69

attach_function :create_generic_value_of_int, :LLVMCreateGenericValueOfInt, [:pointer, :ulong_long, :int], OpaqueGenericValue

.create_generic_value_of_pointer(p) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

• p (FFI::Pointer(*Void))

Returns:

• (OpaqueGenericValue)

# File 'lib/llvm/execution_engine_ffi.rb', line 77

attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], OpaqueGenericValue

.create_interpreter_for_module(out_interp, m, out_error) ⇒ Integer

(Not documented)

Parameters:

• out_interp (FFI::Pointer(*ExecutionEngineRef))
• m (FFI::Pointer(ModuleRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 148

attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int

.create_jit_compiler_for_module(out_jit, m, opt_level, out_error) ⇒ Integer

(Not documented)

Parameters:

• out_jit (FFI::Pointer(*ExecutionEngineRef))
• m (FFI::Pointer(ModuleRef))
• opt_level (Integer)
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 159

attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int

.create_mcjit_compiler_for_module(out_jit, m, options, size_of_options, out_error) ⇒ Integer

Create an MCJIT execution engine for a module, with the given options. It is the responsibility of the caller to ensure that all fields in Options up to the given SizeOfOptions are initialized. It is correct to pass a smaller value of SizeOfOptions that omits some fields. The canonical way of using this is:

LLVMMCJITCompilerOptions options; LLVMInitializeMCJITCompilerOptions(&options, sizeof(options)); … fill in those options you care about LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),

&error);

Note that this is also correct, though possibly suboptimal:

LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);

Parameters:

• out_jit (FFI::Pointer(*ExecutionEngineRef))
• m (FFI::Pointer(ModuleRef))
• options (MCJITCompilerOptions)
• size_of_options (Integer)
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 194

attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, :pointer, MCJITCompilerOptions, :ulong, :pointer], :int

.create_memory_buffer_with_contents_of_file(path, out_mem_buf, out_message) ⇒ Integer

@{

Parameters:

• path (String)
• out_mem_buf (FFI::Pointer(*MemoryBufferRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5285

attach_function :create_memory_buffer_with_contents_of_file, :LLVMCreateMemoryBufferWithContentsOfFile, [:string, :pointer, :pointer], :int

.create_memory_buffer_with_memory_range(input_data, input_data_length, buffer_name, requires_null_terminator) ⇒ FFI::Pointer(MemoryBufferRef)

(Not documented)

Parameters:

• input_data (String)
• input_data_length (Integer)
• buffer_name (String)
• requires_null_terminator (Integer)

Returns:

• (FFI::Pointer(MemoryBufferRef))

# File 'lib/llvm/core_ffi.rb', line 5305

attach_function :create_memory_buffer_with_memory_range, :LLVMCreateMemoryBufferWithMemoryRange, [:string, :ulong, :string, :int], :pointer

.create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name) ⇒ FFI::Pointer(MemoryBufferRef)

(Not documented)

Parameters:

• input_data (String)
• input_data_length (Integer)
• buffer_name (String)

Returns:

• (FFI::Pointer(MemoryBufferRef))

# File 'lib/llvm/core_ffi.rb', line 5315

attach_function :create_memory_buffer_with_memory_range_copy, :LLVMCreateMemoryBufferWithMemoryRangeCopy, [:string, :ulong, :string], :pointer

.create_memory_buffer_with_stdin(out_mem_buf, out_message) ⇒ Integer

(Not documented)

Parameters:

• out_mem_buf (FFI::Pointer(*MemoryBufferRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5294

attach_function :create_memory_buffer_with_stdin, :LLVMCreateMemoryBufferWithSTDIN, [:pointer, :pointer], :int

.create_message(message) ⇒ String

– Error handling —————————————————-===

Parameters:

• message (String)

Returns:

• (String)

# File 'lib/llvm/core_ffi.rb', line 781

attach_function :create_message, :LLVMCreateMessage, [:string], :string

.create_module_provider_for_existing_module(m) ⇒ FFI::Pointer(ModuleProviderRef)

Changes the type of M so it can be passed to FunctionPassManagers and the JIT. They take ModuleProviders for historical reasons.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ModuleProviderRef))

# File 'lib/llvm/core_ffi.rb', line 5265

attach_function :create_module_provider_for_existing_module, :LLVMCreateModuleProviderForExistingModule, [:pointer], :pointer

.create_pass_manager ⇒ FFI::Pointer(PassManagerRef)

Constructs a new whole-module pass pipeline. This type of pipeline is

suitable for link-time optimization and whole-module transformations.
@see llvm::PassManager::PassManager

Returns:

• (FFI::Pointer(PassManagerRef))

# File 'lib/llvm/core_ffi.rb', line 5348

attach_function :create_pass_manager, :LLVMCreatePassManager, [], :pointer

.create_simple_mcjit_memory_manager(opaque, allocate_code_section, allocate_data_section, finalize_memory, destroy) ⇒ OpaqueMCJITMemoryManager

Create a simple custom MCJIT memory manager. This memory manager can intercept allocations in a module-oblivious way. This will return NULL if any of the passed functions are NULL.

Parameters:

• Opaque —

  An opaque client object to pass back to the callbacks.

• AllocateCodeSection —

  Allocate a block of memory for executable code.

• AllocateDataSection —

  Allocate a block of memory for data.

• FinalizeMemory —

  Set page permissions and flush cache. Return 0 on success, 1 on error.

• opaque (FFI::Pointer(*Void))
• allocate_code_section (Proc(_callback_memory_manager_allocate_code_section_callback_))
• allocate_data_section (Proc(_callback_memory_manager_allocate_data_section_callback_))
• finalize_memory (Proc(_callback_memory_manager_finalize_memory_callback_))
• destroy (FFI::Pointer(MemoryManagerDestroyCallback))

Returns:

• (OpaqueMCJITMemoryManager)

# File 'lib/llvm/execution_engine_ffi.rb', line 405

attach_function :create_simple_mcjit_memory_manager, :LLVMCreateSimpleMCJITMemoryManager, [:pointer, :memory_manager_allocate_code_section_callback, :memory_manager_allocate_data_section_callback, :memory_manager_finalize_memory_callback, :pointer], OpaqueMCJITMemoryManager

.create_target_data(string_rep) ⇒ OpaqueTargetData

(Not documented)

Parameters:

• string_rep (String)

Returns:

• (OpaqueTargetData)

# File 'lib/llvm/target_ffi.rb', line 129

attach_function :create_target_data, :LLVMCreateTargetData, [:string], OpaqueTargetData

.create_target_data_layout(t) ⇒ OpaqueTargetData

Create a DataLayout based on the targetMachine.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (OpaqueTargetData)

# File 'lib/llvm/target_ffi.rb', line 548

attach_function :create_target_data_layout, :LLVMCreateTargetDataLayout, [OpaqueTargetMachine], OpaqueTargetData

.create_target_machine(t, triple, cpu, features, level, reloc, code_model) ⇒ OpaqueTargetMachine

Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine

Parameters:

• t (Target)
• triple (String)
• cpu (String)
• features (String)
• level (Symbol from _enum_code_gen_opt_level_)
• reloc (Symbol from _enum_reloc_mode_)
• code_model (Symbol from _enum_code_model_)

Returns:

• (OpaqueTargetMachine)

# File 'lib/llvm/target_ffi.rb', line 493

attach_function :create_target_machine, :LLVMCreateTargetMachine, [Target, :string, :string, :string, :code_gen_opt_level, :reloc_mode, :code_model], OpaqueTargetMachine

.delete_basic_block(bb) ⇒ nil

Remove a basic block from a function and delete it.

This deletes the basic block from its containing function and deletes the basic block itself.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::eraseFromParent()

# File 'lib/llvm/core_ffi.rb', line 3825

attach_function :delete_basic_block, :LLVMDeleteBasicBlock, [:pointer], :void

.delete_function(fn) ⇒ nil

This group contains function that operate on global alias values.

@{

Remove a function from its containing module and deletes it.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::GlobalAlias
• llvmllvm::Functionllvm::Function::eraseFromParent()

# File 'lib/llvm/core_ffi.rb', line 3354

attach_function :delete_function, :LLVMDeleteFunction, [:pointer], :void

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3267

attach_function :delete_global, :LLVMDeleteGlobal, [:pointer], :void

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4277

attach_function :dispose_builder, :LLVMDisposeBuilder, [:pointer], :void

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 202

attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [OpaqueExecutionEngine], :void

.dispose_generic_value(gen_val) ⇒ nil

(Not documented)

Parameters:

• gen_val (OpaqueGenericValue)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 128

attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [OpaqueGenericValue], :void

.dispose_mcjit_memory_manager(mm) ⇒ nil

(Not documented)

Parameters:

• mm (OpaqueMCJITMemoryManager)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 413

attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 5339

attach_function :dispose_memory_buffer, :LLVMDisposeMemoryBuffer, [:pointer], :void

.dispose_message(message) ⇒ nil

(Not documented)

Parameters:

• message (String)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 789

attach_function :dispose_message, :LLVMDisposeMessage, [:string], :void

.dispose_module(m) ⇒ nil

Destroy a module instance.

This must be called for every created module or memory will be leaked.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 954

attach_function :dispose_module, :LLVMDisposeModule, [:pointer], :void

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

• m (FFI::Pointer(ModuleProviderRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 5273

attach_function :dispose_module_provider, :LLVMDisposeModuleProvider, [:pointer], :void

.dispose_pass_manager(pm) ⇒ nil

Frees the memory of a pass pipeline. For function pipelines, does not free

the module provider.
@see llvm::PassManagerBase::~PassManagerBase.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 5421

attach_function :dispose_pass_manager, :LLVMDisposePassManager, [:pointer], :void

.dispose_target_data(td) ⇒ nil

(Not documented)

Parameters:

• td (OpaqueTargetData)

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 137

attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void

.dispose_target_machine(t) ⇒ nil

Dispose the LLVMTargetMachineRef instance generated by

LLVMCreateTargetMachine.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 502

attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void

.double_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1410

attach_function :double_type, :LLVMDoubleType, [], :pointer

.double_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 64-bit floating point type from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1362

attach_function :double_type_in_context, :LLVMDoubleTypeInContext, [:pointer], :pointer

.dump_module(m) ⇒ nil

Dump a representation of a module to stderr.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (nil)

See Also:

• Module::dump()

# File 'lib/llvm/core_ffi.rb', line 1006

attach_function :dump_module, :LLVMDumpModule, [:pointer], :void

.dump_type(val) ⇒ nil

Dump a representation of a type to stderr.

Parameters:

• val (FFI::Pointer(TypeRef))

Returns:

• (nil)

See Also:

• llvmllvm::Typellvm::Type::dump()

# File 'lib/llvm/core_ffi.rb', line 1211

attach_function :dump_type, :LLVMDumpType, [:pointer], :void

.dump_value(val) ⇒ nil

Dump a representation of a value to stderr.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::dump()

# File 'lib/llvm/core_ffi.rb', line 1763

attach_function :dump_value, :LLVMDumpValue, [:pointer], :void

.element_at_offset(td, struct_ty, offset) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• struct_ty (FFI::Pointer(TypeRef))
• offset (Integer)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 288

attach_function :element_at_offset, :LLVMElementAtOffset, [OpaqueTargetData, :pointer, :ulong_long], :uint

.finalize_function_pass_manager(fpm) ⇒ Integer

Finalizes all of the function passes scheduled in in the function pass

manager. Returns 1 if any of the passes modified the module, 0 otherwise.
@see llvm::FunctionPassManager::doFinalization

Parameters:

• fpm (FFI::Pointer(PassManagerRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5411

attach_function :finalize_function_pass_manager, :LLVMFinalizeFunctionPassManager, [:pointer], :int

.find_function(ee, name, out_fn) ⇒ Integer

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• name (String)
• out_fn (FFI::Pointer(*ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 280

attach_function :find_function, :LLVMFindFunction, [OpaqueExecutionEngine, :string, :pointer], :int

.float_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1403

attach_function :float_type, :LLVMFloatType, [], :pointer

.float_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 32-bit floating point type from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1354

attach_function :float_type_in_context, :LLVMFloatTypeInContext, [:pointer], :pointer

.fp128_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1424

attach_function :fp128_type, :LLVMFP128Type, [], :pointer

.fp128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 128-bit floating point type (112-bit mantissa) from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1379

attach_function :fp128_type_in_context, :LLVMFP128TypeInContext, [:pointer], :pointer

.free_machine_code_for_function(ee, f) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• f (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 250

attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, :pointer], :void

.function_type(return_type, param_types, param_count, is_var_arg) ⇒ FFI::Pointer(TypeRef)

Obtain a function type consisting of a specified signature.

The function is defined as a tuple of a return Type, a list of parameter types, and whether the function is variadic.

Parameters:

• return_type (FFI::Pointer(TypeRef))
• param_types (FFI::Pointer(*TypeRef))
• param_count (Integer)
• is_var_arg (Integer)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1445

attach_function :function_type, :LLVMFunctionType, [:pointer, :pointer, :uint, :int], :pointer

.generic_value_int_width(gen_val_ref) ⇒ Integer

(Not documented)

Parameters:

• gen_val_ref (OpaqueGenericValue)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 94

attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [OpaqueGenericValue], :uint

.generic_value_to_float(ty_ref, gen_val) ⇒ Float

(Not documented)

Parameters:

• ty_ref (FFI::Pointer(TypeRef))
• gen_val (OpaqueGenericValue)

Returns:

• (Float)

# File 'lib/llvm/execution_engine_ffi.rb', line 120

attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, OpaqueGenericValue], :double

.generic_value_to_int(gen_val, is_signed) ⇒ Integer

(Not documented)

Parameters:

• gen_val (OpaqueGenericValue)
• is_signed (Integer)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 103

attach_function :generic_value_to_int, :LLVMGenericValueToInt, [OpaqueGenericValue, :int], :ulong_long

.generic_value_to_pointer(gen_val) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

• gen_val (OpaqueGenericValue)

Returns:

• (FFI::Pointer(*Void))

# File 'lib/llvm/execution_engine_ffi.rb', line 111

attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [OpaqueGenericValue], :pointer

.get_alignment(v) ⇒ Integer

Obtain the preferred alignment of the value.

Parameters:

• v (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::AllocaInstllvm::AllocaInst::getAlignment()
• llvmllvm::LoadInstllvm::LoadInst::getAlignment()
• llvmllvm::StoreInstllvm::StoreInst::getAlignment()
• llvmllvm::GlobalValuellvm::GlobalValue::getAlignment()

# File 'lib/llvm/core_ffi.rb', line 3178

attach_function :get_alignment, :LLVMGetAlignment, [:pointer], :uint

.get_array_length(array_ty) ⇒ Integer

Obtain the length of an array type.

This only works on types that represent arrays.

Parameters:

• array_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

See Also:

• llvmllvm::ArrayTypellvm::ArrayType::getNumElements()

# File 'lib/llvm/core_ffi.rb', line 1623

attach_function :get_array_length, :LLVMGetArrayLength, [:pointer], :uint

.get_as_string(c, out) ⇒ String

Get the given constant data sequential as a string.

Parameters:

• c (FFI::Pointer(ValueRef))
• out (FFI::Pointer(*SizeT))

Returns:

• (String)

See Also:

• ConstantDataSequential::getAsString()

# File 'lib/llvm/core_ffi.rb', line 2719

attach_function :get_as_string, :LLVMGetAsString, [:pointer, :pointer], :string

.get_basic_block_parent(bb) ⇒ FFI::Pointer(ValueRef)

Obtain the function to which a basic block belongs.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::getParent()

# File 'lib/llvm/core_ffi.rb', line 3673

attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [:pointer], :pointer

.get_basic_block_terminator(bb) ⇒ FFI::Pointer(ValueRef)

Obtain the terminator instruction for a basic block.

If the basic block does not have a terminator (it is not well-formed if it doesn’t), then NULL is returned.

The returned LLVMValueRef corresponds to a llvm::TerminatorInst.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::getTerminator()

# File 'lib/llvm/core_ffi.rb', line 3688

attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [:pointer], :pointer

.get_basic_blocks(fn, basic_blocks) ⇒ nil

Obtain all of the basic blocks in a function.

This operates on a function value. The BasicBlocks parameter is a pointer to a pre-allocated array of LLVMBasicBlockRef of at least LLVMCountBasicBlocks() in length. This array is populated with LLVMBasicBlockRef instances.

Parameters:

• fn (FFI::Pointer(ValueRef))
• basic_blocks (FFI::Pointer(*BasicBlockRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3712

attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [:pointer, :pointer], :void

.get_bitcode_module(mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_m (FFI::Pointer(*ModuleRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 77

attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int

.get_bitcode_module2(mem_buf, out_m) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_m (FFI::Pointer(*ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 86

attach_function :get_bitcode_module2, :LLVMGetBitcodeModule2, [:pointer, :pointer], :int

.get_bitcode_module_in_context(context_ref, mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_m (FFI::Pointer(*ModuleRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 57

attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_bitcode_module_in_context2(context_ref, mem_buf, out_m) ⇒ Integer

(Not documented)

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_m (FFI::Pointer(*ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 67

attach_function :get_bitcode_module_in_context2, :LLVMGetBitcodeModuleInContext2, [:pointer, :pointer, :pointer], :int

.get_buffer_size(mem_buf) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5331

attach_function :get_buffer_size, :LLVMGetBufferSize, [:pointer], :ulong

.get_buffer_start(mem_buf) ⇒ String

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

• (String)

# File 'lib/llvm/core_ffi.rb', line 5323

attach_function :get_buffer_start, :LLVMGetBufferStart, [:pointer], :string

.get_condition(branch) ⇒ FFI::Pointer(ValueRef)

Return the condition of a branch instruction.

This only works on llvm::BranchInst instructions.

Parameters:

• branch (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::BranchInstllvm::BranchInst::getCondition

# File 'lib/llvm/core_ffi.rb', line 4124

attach_function :get_condition, :LLVMGetCondition, [:pointer], :pointer

.get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

Functions in this group correspond to APIs on llvm::ConstantExpr.

@{

Parameters:

• constant_val (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_opcode_)

See Also:

• llvm::ConstantExpr.

# File 'lib/llvm/core_ffi.rb', line 2807

attach_function :get_const_opcode, :LLVMGetConstOpcode, [:pointer], :opcode

.get_current_debug_location(builder) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4294

attach_function :get_current_debug_location, :LLVMGetCurrentDebugLocation, [:pointer], :pointer

.get_data_layout(m) ⇒ String

Obtain the data layout for a module.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (String)

See Also:

• Module::getDataLayout()

# File 'lib/llvm/core_ffi.rb', line 964

attach_function :get_data_layout, :LLVMGetDataLayout, [:pointer], :string

.get_default_target_triple ⇒ String

Get a triple for the host machine as a string. The result needs to be

disposed with LLVMDisposeMessage.

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 591

attach_function :get_default_target_triple, :LLVMGetDefaultTargetTriple, [], :string

.get_diag_info_description(di) ⇒ String

Return a string representation of the DiagnosticInfo. Use LLVMDisposeMessage to free the string.

Parameters:

• di (FFI::Pointer(DiagnosticInfoRef))

Returns:

• (String)

See Also:

• DiagnosticInfo::print()

# File 'lib/llvm/core_ffi.rb', line 880

attach_function :get_diag_info_description, :LLVMGetDiagInfoDescription, [:pointer], :string

.get_diag_info_severity(di) ⇒ Symbol from _enum_diagnostic_severity_

Return an enum LLVMDiagnosticSeverity.

Parameters:

• di (FFI::Pointer(DiagnosticInfoRef))

Returns:

• (Symbol from _enum_diagnostic_severity_)

See Also:

• DiagnosticInfo::getSeverity()

# File 'lib/llvm/core_ffi.rb', line 890

attach_function :get_diag_info_severity, :LLVMGetDiagInfoSeverity, [:pointer], :diagnostic_severity

.get_dll_storage_class(global) ⇒ Symbol from _enum_dll_storage_class_

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_dll_storage_class_)

# File 'lib/llvm/core_ffi.rb', line 3140

attach_function :get_dll_storage_class, :LLVMGetDLLStorageClass, [:pointer], :dll_storage_class

.get_element_as_constant(c, idx) ⇒ FFI::Pointer(ValueRef)

Get an element at specified index as a constant.

Parameters:

• c (FFI::Pointer(ValueRef))
• idx (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• ConstantDataSequential::getElementAsConstant()

# File 'lib/llvm/core_ffi.rb', line 2782

attach_function :get_element_as_constant, :LLVMGetElementAsConstant, [:pointer, :uint], :pointer

.get_element_type(ty) ⇒ FFI::Pointer(TypeRef)

Obtain the type of elements within a sequential type.

This works on array, vector, and pointer types.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::SequentialTypellvm::SequentialType::getElementType()

# File 'lib/llvm/core_ffi.rb', line 1597

attach_function :get_element_type, :LLVMGetElementType, [:pointer], :pointer

.get_entry_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the basic block that corresponds to the entry point of a function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::Functionllvm::Function::getEntryBlock()

# File 'lib/llvm/core_ffi.rb', line 3762

attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [:pointer], :pointer

.get_execution_engine_target_data(ee) ⇒ FFI::Pointer(TargetDataRef)

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (FFI::Pointer(TargetDataRef))

# File 'lib/llvm/execution_engine_ffi.rb', line 297

attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [OpaqueExecutionEngine], :pointer

.get_execution_engine_target_machine(ee) ⇒ FFI::Pointer(TargetMachineRef)

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (FFI::Pointer(TargetMachineRef))

# File 'lib/llvm/execution_engine_ffi.rb', line 305

attach_function :get_execution_engine_target_machine, :LLVMGetExecutionEngineTargetMachine, [OpaqueExecutionEngine], :pointer

.get_f_cmp_predicate(inst) ⇒ Symbol from _enum_real_predicate_

Obtain the float predicate of an instruction.

This is only valid for instructions that correspond to llvm::FCmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_real_predicate_)

See Also:

• llvmllvm::FCmpInstllvm::FCmpInst::getPredicate()

# File 'lib/llvm/core_ffi.rb', line 3991

attach_function :get_f_cmp_predicate, :LLVMGetFCmpPredicate, [:pointer], :real_predicate

.get_first_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the first basic block in a function.

The returned basic block can be used as an iterator. You will likely eventually call into LLVMGetNextBasicBlock() with it.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::Functionllvm::Function::begin()

# File 'lib/llvm/core_ffi.rb', line 3725

attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [:pointer], :pointer

.get_first_function(m) ⇒ FFI::Pointer(ValueRef)

Obtain an iterator to the first Function in a Module.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Modulellvm::Module::begin()

# File 'lib/llvm/core_ffi.rb', line 1137

attach_function :get_first_function, :LLVMGetFirstFunction, [:pointer], :pointer

.get_first_global(m) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3235

attach_function :get_first_global, :LLVMGetFirstGlobal, [:pointer], :pointer

.get_first_instruction(bb) ⇒ FFI::Pointer(ValueRef)

Obtain the first instruction in a basic block.

The returned LLVMValueRef corresponds to a llvm::Instruction instance.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3871

attach_function :get_first_instruction, :LLVMGetFirstInstruction, [:pointer], :pointer

.get_first_param(fn) ⇒ FFI::Pointer(ValueRef)

Obtain the first parameter to a function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

# File 'lib/llvm/core_ffi.rb', line 3508

attach_function :get_first_param, :LLVMGetFirstParam, [:pointer], :pointer

.get_first_target ⇒ Target

Returns the first llvm::Target in the registered targets list.

Returns:

• (Target)

# File 'lib/llvm/target_ffi.rb', line 410

attach_function :get_first_target, :LLVMGetFirstTarget, [], Target

.get_first_use(val) ⇒ FFI::Pointer(UseRef)

Obtain the first use of a value.

Uses are obtained in an iterator fashion. First, call this function to obtain a reference to the first use. Then, call LLVMGetNextUse() on that instance and all subsequently obtained instances until LLVMGetNextUse() returns NULL.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(UseRef))

See Also:

• llvmllvm::Valuellvm::Value::use_begin()

# File 'lib/llvm/core_ffi.rb', line 2440

attach_function :get_first_use, :LLVMGetFirstUse, [:pointer], :pointer

.get_function_address(ee, name) ⇒ Integer

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• name (String)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 342

attach_function :get_function_address, :LLVMGetFunctionAddress, [OpaqueExecutionEngine, :string], :ulong

.get_function_call_conv(fn) ⇒ Integer

Obtain the calling function of a function.

The returned value corresponds to the LLVMCallConv enumeration.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::getCallingConv()

# File 'lib/llvm/core_ffi.rb', line 3397

attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [:pointer], :uint

.get_gc(fn) ⇒ String

Obtain the name of the garbage collector to use during code generation.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (String)

See Also:

• llvmllvm::Functionllvm::Function::getGC()

# File 'lib/llvm/core_ffi.rb', line 3422

attach_function :get_gc, :LLVMGetGC, [:pointer], :string

.get_global_context ⇒ FFI::Pointer(ContextRef)

Obtain the global context instance.

Returns:

• (FFI::Pointer(ContextRef))

# File 'lib/llvm/core_ffi.rb', line 836

attach_function :get_global_context, :LLVMGetGlobalContext, [], :pointer

.get_global_parent(global) ⇒ FFI::Pointer(ModuleRef)

This group contains functions that operate on global values. Functions in this group relate to functions in the llvm::GlobalValue class tree.

@{

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ModuleRef))

See Also:

• llvmllvm::GlobalValue

# File 'lib/llvm/core_ffi.rb', line 3073

attach_function :get_global_parent, :LLVMGetGlobalParent, [:pointer], :pointer

.get_global_value_address(ee, name) ⇒ Integer

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• name (String)

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 333

attach_function :get_global_value_address, :LLVMGetGlobalValueAddress, [OpaqueExecutionEngine, :string], :ulong

.get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

Obtain the predicate of an instruction.

This is only valid for instructions that correspond to llvm::ICmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_int_predicate_)

See Also:

• llvmllvm::ICmpInstllvm::ICmpInst::getPredicate()

# File 'lib/llvm/core_ffi.rb', line 3978

attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [:pointer], :int_predicate

.get_incoming_block(phi_node, index) ⇒ FFI::Pointer(BasicBlockRef)

Obtain an incoming value to a PHI node as an LLVMBasicBlockRef.

Parameters:

• phi_node (FFI::Pointer(ValueRef))
• index (Integer)

Returns:

• (FFI::Pointer(BasicBlockRef))

# File 'lib/llvm/core_ffi.rb', line 4186

attach_function :get_incoming_block, :LLVMGetIncomingBlock, [:pointer, :uint], :pointer

.get_incoming_value(phi_node, index) ⇒ FFI::Pointer(ValueRef)

Obtain an incoming value to a PHI node as an LLVMValueRef.

Parameters:

• phi_node (FFI::Pointer(ValueRef))
• index (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 4177

attach_function :get_incoming_value, :LLVMGetIncomingValue, [:pointer, :uint], :pointer

.get_initializer(global_var) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3275

attach_function :get_initializer, :LLVMGetInitializer, [:pointer], :pointer

.get_insert_block(builder) ⇒ FFI::Pointer(BasicBlockRef)

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

# File 'lib/llvm/core_ffi.rb', line 4242

attach_function :get_insert_block, :LLVMGetInsertBlock, [:pointer], :pointer

.get_instruction_call_conv(instr) ⇒ Integer

Obtain the calling convention for a call instruction.

This is the opposite of LLVMSetInstructionCallConv(). Reads its usage.

Parameters:

• instr (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• LLVMSetInstructionCallConv()

# File 'lib/llvm/core_ffi.rb', line 4032

attach_function :get_instruction_call_conv, :LLVMGetInstructionCallConv, [:pointer], :uint

.get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

Obtain the code opcode for an individual instruction.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_opcode_)

See Also:

• llvmllvm::Instructionllvm::Instruction::getOpCode()

# File 'lib/llvm/core_ffi.rb', line 3965

attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [:pointer], :opcode

.get_instruction_parent(inst) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the basic block to which an instruction belongs.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::Instructionllvm::Instruction::getParent()

# File 'lib/llvm/core_ffi.rb', line 3918

attach_function :get_instruction_parent, :LLVMGetInstructionParent, [:pointer], :pointer

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

• integer_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 1338

attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [:pointer], :uint

.get_intrinsic_id(fn) ⇒ Integer

Obtain the ID number from a function instance.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::getIntrinsicID()

# File 'lib/llvm/core_ffi.rb', line 3385

attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [:pointer], :uint

.get_last_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the last basic block in a function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::Functionllvm::Function::end()

# File 'lib/llvm/core_ffi.rb', line 3735

attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [:pointer], :pointer

.get_last_function(m) ⇒ FFI::Pointer(ValueRef)

Obtain an iterator to the last Function in a Module.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Modulellvm::Module::end()

# File 'lib/llvm/core_ffi.rb', line 1147

attach_function :get_last_function, :LLVMGetLastFunction, [:pointer], :pointer

.get_last_global(m) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3243

attach_function :get_last_global, :LLVMGetLastGlobal, [:pointer], :pointer

.get_last_instruction(bb) ⇒ FFI::Pointer(ValueRef)

Obtain the last instruction in a basic block.

The returned LLVMValueRef corresponds to an LLVM:Instruction.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3881

attach_function :get_last_instruction, :LLVMGetLastInstruction, [:pointer], :pointer

.get_last_param(fn) ⇒ FFI::Pointer(ValueRef)

Obtain the last parameter to a function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Functionllvm::Function::arg_end()

# File 'lib/llvm/core_ffi.rb', line 3518

attach_function :get_last_param, :LLVMGetLastParam, [:pointer], :pointer

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_linkage_)

# File 'lib/llvm/core_ffi.rb', line 3089

attach_function :get_linkage, :LLVMGetLinkage, [:pointer], :linkage

.get_md_kind_id(name, s_len) ⇒ Integer

(Not documented)

Parameters:

• name (String)
• s_len (Integer)

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 909

attach_function :get_md_kind_id, :LLVMGetMDKindID, [:string, :uint], :uint

.get_md_kind_id_in_context(c, name, s_len) ⇒ Integer

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))
• name (String)
• s_len (Integer)

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 900

attach_function :get_md_kind_id_in_context, :LLVMGetMDKindIDInContext, [:pointer, :string, :uint], :uint

.get_md_node_num_operands(v) ⇒ Object

Obtain the number of operands from an MDNode value.

Parameters:

• V —

  MDNode to get number of operands from.

• v (FFI::Pointer(ValueRef))

Returns:

• Number of operands of the MDNode.

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3622

attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [:pointer], :uint

.get_md_node_operands(v, dest) ⇒ nil

Obtain the given MDNode’s operands.

The passed LLVMValueRef pointer should point to enough memory to hold all of the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the MDNode’s operands.

Parameters:

• V —

  MDNode to get the operands from.

• Dest —

  Destination array for operands.

• v (FFI::Pointer(ValueRef))
• dest (FFI::Pointer(*ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3639

attach_function :get_md_node_operands, :LLVMGetMDNodeOperands, [:pointer, :pointer], :void

.get_md_string(v, len) ⇒ Object

Obtain the underlying string from a MDString value.

Parameters:

• V —

  Instance to obtain string from.

• Len —

  Memory address which will hold length of returned string.

• v (FFI::Pointer(ValueRef))
• len (FFI::Pointer(*UInt))

Returns:

• String data in MDString.

• (String)

# File 'lib/llvm/core_ffi.rb', line 3611

attach_function :get_md_string, :LLVMGetMDString, [:pointer, :pointer], :string

.get_metadata(val, kind_id) ⇒ FFI::Pointer(ValueRef)

Return metadata associated with an instruction value.

Parameters:

• val (FFI::Pointer(ValueRef))
• kind_id (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3898

attach_function :get_metadata, :LLVMGetMetadata, [:pointer, :uint], :pointer

.get_module_context(m) ⇒ FFI::Pointer(ContextRef)

Obtain the context to which this module is associated.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(ContextRef))

See Also:

• Module::getContext()

# File 'lib/llvm/core_ffi.rb', line 1051

attach_function :get_module_context, :LLVMGetModuleContext, [:pointer], :pointer

.get_module_data_layout(m) ⇒ OpaqueTargetData

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (OpaqueTargetData)

# File 'lib/llvm/target_ffi.rb', line 112

attach_function :get_module_data_layout, :LLVMGetModuleDataLayout, [:pointer], OpaqueTargetData

.get_named_function(m, name) ⇒ FFI::Pointer(ValueRef)

Obtain a Function value from a Module by its name.

The returned value corresponds to a llvm::Function value.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Modulellvm::Module::getFunction()

# File 'lib/llvm/core_ffi.rb', line 1127

attach_function :get_named_function, :LLVMGetNamedFunction, [:pointer, :string], :pointer

.get_named_global(m, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3227

attach_function :get_named_global, :LLVMGetNamedGlobal, [:pointer, :string], :pointer

.get_named_metadata_num_operands(m, name) ⇒ Integer

Obtain the number of operands for named metadata in a module.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)

Returns:

• (Integer)

See Also:

• llvmllvm::Modulellvm::Module::getNamedMetadata()

# File 'lib/llvm/core_ffi.rb', line 1071

attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [:pointer, :string], :uint

.get_named_metadata_operands(m, name, dest) ⇒ nil

Obtain the named metadata operands for a module.

The passed LLVMValueRef pointer should refer to an array of LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This array will be populated with the LLVMValueRef instances. Each instance corresponds to a llvm::MDNode.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)
• dest (FFI::Pointer(*ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Modulellvm::Module::getNamedMetadata()
• llvmllvm::MDNodellvm::MDNode::getOperand()

# File 'lib/llvm/core_ffi.rb', line 1089

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [:pointer, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

Advance a basic block iterator.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

# File 'lib/llvm/core_ffi.rb', line 3743

attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [:pointer], :pointer

.get_next_function(fn) ⇒ FFI::Pointer(ValueRef)

Advance a Function iterator to the next Function.

Returns NULL if the iterator was already at the end and there are no more functions.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1158

attach_function :get_next_function, :LLVMGetNextFunction, [:pointer], :pointer

.get_next_global(global_var) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3251

attach_function :get_next_global, :LLVMGetNextGlobal, [:pointer], :pointer

.get_next_instruction(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the instruction that occurs after the one specified.

The next instruction will be from the same basic block.

If this is the last instruction in a basic block, NULL will be returned.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3931

attach_function :get_next_instruction, :LLVMGetNextInstruction, [:pointer], :pointer

.get_next_param(arg) ⇒ FFI::Pointer(ValueRef)

Obtain the next parameter to a function.

This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is actually a wrapped iterator) and obtains the next parameter from the underlying iterator.

Parameters:

• arg (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3530

attach_function :get_next_param, :LLVMGetNextParam, [:pointer], :pointer

.get_next_target(t) ⇒ Target

Returns the next llvm::Target given a previous one (or null if there’s none)

Parameters:

• t (Target)

Returns:

• (Target)

# File 'lib/llvm/target_ffi.rb', line 418

attach_function :get_next_target, :LLVMGetNextTarget, [Target], Target

.get_next_use(u) ⇒ FFI::Pointer(UseRef)

Obtain the next use of a value.

This effectively advances the iterator. It returns NULL if you are on the final use and no more are available.

Parameters:

• u (FFI::Pointer(UseRef))

Returns:

• (FFI::Pointer(UseRef))

# File 'lib/llvm/core_ffi.rb', line 2451

attach_function :get_next_use, :LLVMGetNextUse, [:pointer], :pointer

.get_num_operands(val) ⇒ Integer

Obtain the number of operands in a llvm::User value.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Userllvm::User::getNumOperands()

# File 'lib/llvm/core_ffi.rb', line 2517

attach_function :get_num_operands, :LLVMGetNumOperands, [:pointer], :int

.get_num_successors(term) ⇒ Integer

Return the number of successors that this terminator has.

Parameters:

• term (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::TerminatorInstllvm::TerminatorInst::getNumSuccessors

# File 'lib/llvm/core_ffi.rb', line 4077

attach_function :get_num_successors, :LLVMGetNumSuccessors, [:pointer], :uint

.get_operand(val, index) ⇒ FFI::Pointer(ValueRef)

Obtain an operand at a specific index in a llvm::User value.

Parameters:

• val (FFI::Pointer(ValueRef))
• index (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Userllvm::User::getOperand()

# File 'lib/llvm/core_ffi.rb', line 2484

attach_function :get_operand, :LLVMGetOperand, [:pointer, :uint], :pointer

.get_operand_use(val, index) ⇒ FFI::Pointer(UseRef)

Obtain the use of an operand at a specific index in a llvm::User value.

Parameters:

• val (FFI::Pointer(ValueRef))
• index (Integer)

Returns:

• (FFI::Pointer(UseRef))

See Also:

• llvmllvm::Userllvm::User::getOperandUse()

# File 'lib/llvm/core_ffi.rb', line 2495

attach_function :get_operand_use, :LLVMGetOperandUse, [:pointer, :uint], :pointer

.get_ordering(memory_access_inst) ⇒ Symbol from _enum_atomic_ordering_

(Not documented)

Parameters:

• memory_access_inst (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_atomic_ordering_)

# File 'lib/llvm/core_ffi.rb', line 4880

attach_function :get_ordering, :LLVMGetOrdering, [:pointer], :atomic_ordering

.get_param(fn, index) ⇒ FFI::Pointer(ValueRef)

Obtain the parameter at the specified index.

Parameters are indexed from 0.

Parameters:

• fn (FFI::Pointer(ValueRef))
• index (Integer)

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

# File 'lib/llvm/core_ffi.rb', line 3484

attach_function :get_param, :LLVMGetParam, [:pointer, :uint], :pointer

.get_param_parent(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the function to which this argument belongs.

Unlike other functions in this group, this one takes an LLVMValueRef that corresponds to a llvm::Attribute.

The returned LLVMValueRef is the llvm::Function to which this argument belongs.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3498

attach_function :get_param_parent, :LLVMGetParamParent, [:pointer], :pointer

.get_param_types(function_ty, dest) ⇒ nil

Obtain the types of a function’s parameters.

The Dest parameter should point to a pre-allocated array of LLVMTypeRef at least LLVMCountParamTypes() large. On return, the first LLVMCountParamTypes() entries in the array will be populated with LLVMTypeRef instances.

Parameters:

• FunctionTy —

  The function type to operate on.

• Dest —

  Memory address of an array to be filled with result.

• function_ty (FFI::Pointer(TypeRef))
• dest (FFI::Pointer(*TypeRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 1486

attach_function :get_param_types, :LLVMGetParamTypes, [:pointer, :pointer], :void

.get_params(fn, params) ⇒ nil

Obtain the parameters in a function.

The takes a pointer to a pre-allocated array of LLVMValueRef that is at least LLVMCountParams() long. This array will be filled with LLVMValueRef instances which correspond to the parameters the function receives. Each LLVMValueRef corresponds to a llvm::Argument instance.

Parameters:

• fn (FFI::Pointer(ValueRef))
• params (FFI::Pointer(*ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

# File 'lib/llvm/core_ffi.rb', line 3471

attach_function :get_params, :LLVMGetParams, [:pointer, :pointer], :void

.get_personality_fn(fn) ⇒ FFI::Pointer(ValueRef)

Obtain the personality function attached to the function.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Functionllvm::Function::getPersonalityFn()

# File 'lib/llvm/core_ffi.rb', line 3364

attach_function :get_personality_fn, :LLVMGetPersonalityFn, [:pointer], :pointer

.get_pointer_address_space(pointer_ty) ⇒ Integer

Obtain the address space of a pointer type.

This only works on types that represent pointers.

Parameters:

• pointer_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

See Also:

• llvmllvm::PointerTypellvm::PointerType::getAddressSpace()

# File 'lib/llvm/core_ffi.rb', line 1649

attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [:pointer], :uint

.get_pointer_to_global(ee, global) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• global (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(*Void))

# File 'lib/llvm/execution_engine_ffi.rb', line 324

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, :pointer], :pointer

.get_previous_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

Go backwards in a basic block iterator.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

# File 'lib/llvm/core_ffi.rb', line 3751

attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [:pointer], :pointer

.get_previous_function(fn) ⇒ FFI::Pointer(ValueRef)

Decrement a Function iterator to the previous Function.

Returns NULL if the iterator was already at the beginning and there are no previous functions.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1169

attach_function :get_previous_function, :LLVMGetPreviousFunction, [:pointer], :pointer

.get_previous_global(global_var) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3259

attach_function :get_previous_global, :LLVMGetPreviousGlobal, [:pointer], :pointer

.get_previous_instruction(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the instruction that occurred before this one.

If the instruction is the first instruction in a basic block, NULL will be returned.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3942

attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [:pointer], :pointer

.get_previous_param(arg) ⇒ FFI::Pointer(ValueRef)

Obtain the previous parameter to a function.

This is the opposite of LLVMGetNextParam().

Parameters:

• arg (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3540

attach_function :get_previous_param, :LLVMGetPreviousParam, [:pointer], :pointer

.get_return_type(function_ty) ⇒ FFI::Pointer(TypeRef)

Obtain the Type this function Type returns.

Parameters:

• function_ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1461

attach_function :get_return_type, :LLVMGetReturnType, [:pointer], :pointer

.get_section(global) ⇒ String

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (String)

# File 'lib/llvm/core_ffi.rb', line 3106

attach_function :get_section, :LLVMGetSection, [:pointer], :string

.get_struct_element_types(struct_ty, dest) ⇒ nil

Get the elements within a structure.

The function is passed the address of a pre-allocated array of LLVMTypeRef at least LLVMCountStructElementTypes() long. After invocation, this array will be populated with the structure’s elements. The objects in the destination array will have a lifetime of the structure type itself, which is the lifetime of the context it is contained in.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))
• dest (FFI::Pointer(*TypeRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 1574

attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [:pointer, :pointer], :void

.get_struct_name(ty) ⇒ String

Obtain the name of a structure.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (String)

See Also:

• llvmllvm::StructTypellvm::StructType::getName()

# File 'lib/llvm/core_ffi.rb', line 1535

attach_function :get_struct_name, :LLVMGetStructName, [:pointer], :string

.get_successor(term, i) ⇒ FFI::Pointer(BasicBlockRef)

Return the specified successor.

Parameters:

• term (FFI::Pointer(ValueRef))
• i (Integer)

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::TerminatorInstllvm::TerminatorInst::getSuccessor

# File 'lib/llvm/core_ffi.rb', line 4088

attach_function :get_successor, :LLVMGetSuccessor, [:pointer, :uint], :pointer

.get_switch_default_dest(switch_instr) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the default destination basic block of a switch instruction.

This only works on llvm::SwitchInst instructions.

Parameters:

• switch_instr (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::SwitchInstllvm::SwitchInst::getDefaultDest()

# File 'lib/llvm/core_ffi.rb', line 4149

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [:pointer], :pointer

.get_target(m) ⇒ String

Obtain the target triple for a module.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (String)

See Also:

• Module::getTargetTriple()

# File 'lib/llvm/core_ffi.rb', line 985

attach_function :get_target, :LLVMGetTarget, [:pointer], :string

.get_target_description(t) ⇒ String

Returns the description of a target. See llvm::Target::getDescription

Parameters:

• t (Target)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 455

attach_function :get_target_description, :LLVMGetTargetDescription, [Target], :string

.get_target_from_name(name) ⇒ Target

Finds the target corresponding to the given name and stores it in p T.

Returns 0 on success.

Parameters:

• name (String)

Returns:

• (Target)

# File 'lib/llvm/target_ffi.rb', line 427

attach_function :get_target_from_name, :LLVMGetTargetFromName, [:string], Target

.get_target_from_triple(triple, t, error_message) ⇒ Integer

Finds the target corresponding to the given triple and stores it in p T.

Returns 0 on success. Optionally returns any error in ErrorMessage.
Use LLVMDisposeMessage to dispose the message.

Parameters:

• triple (String)
• t (FFI::Pointer(*TargetRef))
• error_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 439

attach_function :get_target_from_triple, :LLVMGetTargetFromTriple, [:string, :pointer, :pointer], :int

.get_target_machine_cpu(t) ⇒ String

Returns the cpu used creating this target machine. See

llvm::TargetMachine::getCPU. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 530

attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string

.get_target_machine_feature_string(t) ⇒ String

Returns the feature string used creating this target machine. See

llvm::TargetMachine::getFeatureString. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 540

attach_function :get_target_machine_feature_string, :LLVMGetTargetMachineFeatureString, [OpaqueTargetMachine], :string

.get_target_machine_target(t) ⇒ Target

Returns the Target used in a TargetMachine

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (Target)

# File 'lib/llvm/target_ffi.rb', line 510

attach_function :get_target_machine_target, :LLVMGetTargetMachineTarget, [OpaqueTargetMachine], Target

.get_target_machine_triple(t) ⇒ String

Returns the triple used creating this target machine. See

llvm::TargetMachine::getTriple. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 520

attach_function :get_target_machine_triple, :LLVMGetTargetMachineTriple, [OpaqueTargetMachine], :string

.get_target_name(t) ⇒ String

Returns the name of a target. See llvm::Target::getName

Parameters:

• t (Target)

Returns:

• (String)

# File 'lib/llvm/target_ffi.rb', line 447

attach_function :get_target_name, :LLVMGetTargetName, [Target], :string

.get_thread_local_mode(global_var) ⇒ Symbol from _enum_thread_local_mode_

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_thread_local_mode_)

# File 'lib/llvm/core_ffi.rb', line 3310

attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [:pointer], :thread_local_mode

.get_type_by_name(m, name) ⇒ FFI::Pointer(TypeRef)

Obtain a Type from a module by its registered name.

Parameters:

• m (FFI::Pointer(ModuleRef))
• name (String)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1060

attach_function :get_type_by_name, :LLVMGetTypeByName, [:pointer, :string], :pointer

.get_type_context(ty) ⇒ FFI::Pointer(ContextRef)

Obtain the context to which this type instance is associated.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ContextRef))

See Also:

• llvmllvm::Typellvm::Type::getContext()

# File 'lib/llvm/core_ffi.rb', line 1201

attach_function :get_type_context, :LLVMGetTypeContext, [:pointer], :pointer

.get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

Obtain the enumerated type of a Type instance.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (Symbol from _enum_type_kind_)

See Also:

• llvm::Type:getTypeID()

# File 'lib/llvm/core_ffi.rb', line 1179

attach_function :get_type_kind, :LLVMGetTypeKind, [:pointer], :type_kind

.get_undef(ty) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value referring to an undefined value of a type.

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::UndefValuellvm::UndefValue::get()

# File 'lib/llvm/core_ffi.rb', line 2550

attach_function :get_undef, :LLVMGetUndef, [:pointer], :pointer

.get_used_value(u) ⇒ FFI::Pointer(ValueRef)

Obtain the value this use corresponds to.

Parameters:

• u (FFI::Pointer(UseRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvm::Use::get().

# File 'lib/llvm/core_ffi.rb', line 2473

attach_function :get_used_value, :LLVMGetUsedValue, [:pointer], :pointer

.get_user(u) ⇒ FFI::Pointer(ValueRef)

Obtain the user value for a user.

The returned value corresponds to a llvm::User type.

Parameters:

• u (FFI::Pointer(UseRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Usellvm::Use::getUser()

# File 'lib/llvm/core_ffi.rb', line 2463

attach_function :get_user, :LLVMGetUser, [:pointer], :pointer

.get_value_name(val) ⇒ String

Obtain the string name of a value.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (String)

See Also:

• llvmllvm::Valuellvm::Value::getName()

# File 'lib/llvm/core_ffi.rb', line 1742

attach_function :get_value_name, :LLVMGetValueName, [:pointer], :string

.get_vector_size(vector_ty) ⇒ Integer

Obtain the number of elements in a vector type.

This only works on types that represent vectors.

Parameters:

• vector_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

See Also:

• llvmllvm::VectorTypellvm::VectorType::getNumElements()

# File 'lib/llvm/core_ffi.rb', line 1676

attach_function :get_vector_size, :LLVMGetVectorSize, [:pointer], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (Symbol from _enum_visibility_)

# File 'lib/llvm/core_ffi.rb', line 3123

attach_function :get_visibility, :LLVMGetVisibility, [:pointer], :visibility

.get_volatile(memory_access_inst) ⇒ Integer

(Not documented)

Parameters:

• memory_access_inst (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 4863

attach_function :get_volatile, :LLVMGetVolatile, [:pointer], :int

.half_type ⇒ FFI::Pointer(TypeRef)

Obtain a floating point type from the global context.

These map to the functions in this group of the same name.

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1396

attach_function :half_type, :LLVMHalfType, [], :pointer

.half_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 16-bit floating point type from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1346

attach_function :half_type_in_context, :LLVMHalfTypeInContext, [:pointer], :pointer

.has_metadata(val) ⇒ Integer

Determine whether an instruction has any metadata attached.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3889

attach_function :has_metadata, :LLVMHasMetadata, [:pointer], :int

.has_unnamed_addr(global) ⇒ Integer

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3157

attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [:pointer], :int

.initialize_all_asm_parsers ⇒ nil

(Not documented)

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 64

.initialize_all_asm_printers ⇒ nil

(Not documented)

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 57

.initialize_all_disassemblers ⇒ nil

(Not documented)

attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 71

.initialize_all_target_infos ⇒ nil

(Not documented)

attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 36

.initialize_all_target_m_cs ⇒ nil

(Not documented)

attach_function :initialize_all_target_m_cs, :LLVMInitializeAllTargetMCs, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 50

.initialize_all_targets ⇒ nil

(Not documented)

attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 43

.initialize_function_pass_manager(fpm) ⇒ Integer

Initializes all of the function passes scheduled in the function pass

manager. Returns 1 if any of the passes modified the module, 0 otherwise.
@see llvm::FunctionPassManager::doInitialization

Parameters:

• fpm (FFI::Pointer(PassManagerRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5389

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [:pointer], :int

.initialize_mcjit_compiler_options(options, size_of_options) ⇒ nil

(Not documented)

Parameters:

• options (MCJITCompilerOptions)
• size_of_options (Integer)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 168

attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void

.initialize_native_asm_parser ⇒ Integer

(Not documented)

attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 85

.initialize_native_asm_printer ⇒ Integer

(Not documented)

attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 92

.initialize_native_disassembler ⇒ Integer

(Not documented)

attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 99

.initialize_native_target ⇒ Integer

(Not documented)

attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 78

.insert_basic_block(insert_before_bb, name) ⇒ FFI::Pointer(BasicBlockRef)

Insert a basic block in a function using the global context.

Parameters:

• insert_before_bb (FFI::Pointer(BasicBlockRef))
• name (String)

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::Create()

# File 'lib/llvm/core_ffi.rb', line 3812

attach_function :insert_basic_block, :LLVMInsertBasicBlock, [:pointer, :string], :pointer

.insert_basic_block_in_context(c, bb, name) ⇒ FFI::Pointer(BasicBlockRef)

Insert a basic block in a function before another basic block.

The function to add to is determined by the function of the passed basic block.

Parameters:

• c (FFI::Pointer(ContextRef))
• bb (FFI::Pointer(BasicBlockRef))
• name (String)

Returns:

• (FFI::Pointer(BasicBlockRef))

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::Create()

# File 'lib/llvm/core_ffi.rb', line 3801

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [:pointer, :pointer, :string], :pointer

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• instr (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4259

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [:pointer, :pointer], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• instr (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4269

attach_function :insert_into_builder_with_name, :LLVMInsertIntoBuilderWithName, [:pointer, :pointer, :string], :void

.instruction_clone(inst) ⇒ FFI::Pointer(ValueRef)

Create a copy of ‘this’ instruction that is identical in all ways except the following:

* The instruction has no parent
* The instruction has no name

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

See Also:

• llvmllvm::Instructionllvm::Instruction::clone()

# File 'lib/llvm/core_ffi.rb', line 4004

attach_function :instruction_clone, :LLVMInstructionClone, [:pointer], :pointer

.instruction_erase_from_parent(inst) ⇒ nil

Remove and delete an instruction.

The instruction specified is removed from its containing building block and then deleted.

Parameters:

• inst (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Instructionllvm::Instruction::eraseFromParent()

# File 'lib/llvm/core_ffi.rb', line 3955

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [:pointer], :void

.int128_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1322

attach_function :int128_type, :LLVMInt128Type, [], :pointer

.int128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1270

attach_function :int128_type_in_context, :LLVMInt128TypeInContext, [:pointer], :pointer

.int16_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1301

attach_function :int16_type, :LLVMInt16Type, [], :pointer

.int16_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1246

attach_function :int16_type_in_context, :LLVMInt16TypeInContext, [:pointer], :pointer

.int1_type ⇒ FFI::Pointer(TypeRef)

Obtain an integer type from the global context with a specified bit width.

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1287

attach_function :int1_type, :LLVMInt1Type, [], :pointer

.int1_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain an integer type from a context with specified bit width.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1230

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [:pointer], :pointer

.int32_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1308

attach_function :int32_type, :LLVMInt32Type, [], :pointer

.int32_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1254

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [:pointer], :pointer

.int64_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1315

attach_function :int64_type, :LLVMInt64Type, [], :pointer

.int64_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1262

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [:pointer], :pointer

.int8_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1294

attach_function :int8_type, :LLVMInt8Type, [], :pointer

.int8_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1238

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [:pointer], :pointer

.int_ptr_type(td) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• td (OpaqueTargetData)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/target_ffi.rb', line 187

attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], :pointer

.int_ptr_type_for_as(td, as) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• td (OpaqueTargetData)
• as (Integer)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/target_ffi.rb', line 196

attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], :pointer

.int_ptr_type_for_as_in_context(c, td, as) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))
• td (OpaqueTargetData)
• as (Integer)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/target_ffi.rb', line 215

attach_function :int_ptr_type_for_as_in_context, :LLVMIntPtrTypeForASInContext, [:pointer, OpaqueTargetData, :uint], :pointer

.int_ptr_type_in_context(c, td) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))
• td (OpaqueTargetData)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/target_ffi.rb', line 205

attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [:pointer, OpaqueTargetData], :pointer

.int_type(num_bits) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• num_bits (Integer)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1330

attach_function :int_type, :LLVMIntType, [:uint], :pointer

.int_type_in_context(c, num_bits) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

• c (FFI::Pointer(ContextRef))
• num_bits (Integer)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1279

attach_function :int_type_in_context, :LLVMIntTypeInContext, [:pointer, :uint], :pointer

.is_a_addr_space_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2289

attach_function :is_a_addr_space_cast_inst, :LLVMIsAAddrSpaceCastInst, [:pointer], :pointer

.is_a_alloca_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2273

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [:pointer], :pointer

.is_a_argument(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1793

attach_function :is_a_argument, :LLVMIsAArgument, [:pointer], :pointer

.is_a_basic_block(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1801

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [:pointer], :pointer

.is_a_binary_operator(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1993

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [:pointer], :pointer

.is_a_bit_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2297

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [:pointer], :pointer

.is_a_block_address(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1833

attach_function :is_a_block_address, :LLVMIsABlockAddress, [:pointer], :pointer

.is_a_branch_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2169

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [:pointer], :pointer

.is_a_call_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2001

attach_function :is_a_call_inst, :LLVMIsACallInst, [:pointer], :pointer

.is_a_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2281

attach_function :is_a_cast_inst, :LLVMIsACastInst, [:pointer], :pointer

.is_a_catch_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2249

attach_function :is_a_catch_pad_inst, :LLVMIsACatchPadInst, [:pointer], :pointer

.is_a_catch_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2233

attach_function :is_a_catch_return_inst, :LLVMIsACatchReturnInst, [:pointer], :pointer

.is_a_cleanup_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2257

attach_function :is_a_cleanup_pad_inst, :LLVMIsACleanupPadInst, [:pointer], :pointer

.is_a_cleanup_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2225

attach_function :is_a_cleanup_return_inst, :LLVMIsACleanupReturnInst, [:pointer], :pointer

.is_a_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2065

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [:pointer], :pointer

.is_a_constant(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1825

attach_function :is_a_constant, :LLVMIsAConstant, [:pointer], :pointer

.is_a_constant_aggregate_zero(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1841

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [:pointer], :pointer

.is_a_constant_array(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1849

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [:pointer], :pointer

.is_a_constant_data_array(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1865

attach_function :is_a_constant_data_array, :LLVMIsAConstantDataArray, [:pointer], :pointer

.is_a_constant_data_sequential(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1857

attach_function :is_a_constant_data_sequential, :LLVMIsAConstantDataSequential, [:pointer], :pointer

.is_a_constant_data_vector(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1873

attach_function :is_a_constant_data_vector, :LLVMIsAConstantDataVector, [:pointer], :pointer

.is_a_constant_expr(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1881

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [:pointer], :pointer

.is_a_constant_fp(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1889

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [:pointer], :pointer

.is_a_constant_int(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1897

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [:pointer], :pointer

.is_a_constant_pointer_null(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1905

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [:pointer], :pointer

.is_a_constant_struct(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1913

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [:pointer], :pointer

.is_a_constant_token_none(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1921

attach_function :is_a_constant_token_none, :LLVMIsAConstantTokenNone, [:pointer], :pointer

.is_a_constant_vector(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1929

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [:pointer], :pointer

.is_a_dbg_declare_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2025

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [:pointer], :pointer

.is_a_dbg_info_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2017

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [:pointer], :pointer

.is_a_extract_element_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2089

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [:pointer], :pointer

.is_a_extract_value_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2393

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [:pointer], :pointer

.is_a_funclet_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2241

attach_function :is_a_funclet_pad_inst, :LLVMIsAFuncletPadInst, [:pointer], :pointer

.is_a_function(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1961

attach_function :is_a_function, :LLVMIsAFunction, [:pointer], :pointer

.is_a_get_element_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2097

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [:pointer], :pointer

.is_a_global_alias(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1945

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [:pointer], :pointer

.is_a_global_object(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1953

attach_function :is_a_global_object, :LLVMIsAGlobalObject, [:pointer], :pointer

.is_a_global_value(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1937

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [:pointer], :pointer

.is_a_global_variable(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1969

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [:pointer], :pointer

.is_a_indirect_br_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2177

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [:pointer], :pointer

.is_a_inline_asm(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1809

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [:pointer], :pointer

.is_a_insert_element_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2105

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [:pointer], :pointer

.is_a_insert_value_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2113

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [:pointer], :pointer

.is_a_instruction(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1985

attach_function :is_a_instruction, :LLVMIsAInstruction, [:pointer], :pointer

.is_a_int_to_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2337

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [:pointer], :pointer

.is_a_intrinsic_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2009

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [:pointer], :pointer

.is_a_invoke_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2185

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [:pointer], :pointer

.is_a_landing_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2121

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [:pointer], :pointer

.is_a_load_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2401

attach_function :is_a_load_inst, :LLVMIsALoadInst, [:pointer], :pointer

.is_a_mem_cpy_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2041

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [:pointer], :pointer

.is_a_mem_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2033

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [:pointer], :pointer

.is_a_mem_move_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2049

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [:pointer], :pointer

.is_a_mem_set_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2057

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [:pointer], :pointer

.is_a_ptr_to_int_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2345

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [:pointer], :pointer

.is_a_resume_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2217

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [:pointer], :pointer

.is_a_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2193

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [:pointer], :pointer

.is_a_select_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2137

attach_function :is_a_select_inst, :LLVMIsASelectInst, [:pointer], :pointer

.is_a_shuffle_vector_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2145

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [:pointer], :pointer

.is_a_store_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2153

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [:pointer], :pointer

.is_a_switch_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2201

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [:pointer], :pointer

.is_a_terminator_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2161

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [:pointer], :pointer

.is_a_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2369

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [:pointer], :pointer

.is_a_unary_instruction(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2265

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [:pointer], :pointer

.is_a_undef_value(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1977

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [:pointer], :pointer

.is_a_unreachable_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2209

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [:pointer], :pointer

.is_a_user(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 1817

attach_function :is_a_user, :LLVMIsAUser, [:pointer], :pointer

.is_af_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2073

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [:pointer], :pointer

.is_afp_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2305

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [:pointer], :pointer

.is_afp_to_si_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2313

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [:pointer], :pointer

.is_afp_to_ui_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2321

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [:pointer], :pointer

.is_afp_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2329

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [:pointer], :pointer

.is_ai_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2081

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [:pointer], :pointer

.is_amd_node(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2417

attach_function :is_amd_node, :LLVMIsAMDNode, [:pointer], :pointer

.is_amd_string(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2425

attach_function :is_amd_string, :LLVMIsAMDString, [:pointer], :pointer

.is_aphi_node(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2129

attach_function :is_aphi_node, :LLVMIsAPHINode, [:pointer], :pointer

.is_as_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2353

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [:pointer], :pointer

.is_asi_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2361

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [:pointer], :pointer

.is_aui_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2377

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [:pointer], :pointer

.is_ava_arg_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2409

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [:pointer], :pointer

.is_az_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2385

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [:pointer], :pointer

.is_conditional(branch) ⇒ Integer

Return if a branch is conditional.

This only works on llvm::BranchInst instructions.

Parameters:

• branch (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::BranchInstllvm::BranchInst::isConditional

# File 'lib/llvm/core_ffi.rb', line 4112

attach_function :is_conditional, :LLVMIsConditional, [:pointer], :int

.is_constant(val) ⇒ Integer

Determine whether the specified constant instance is constant.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi_v2.rb', line 295

attach_function :is_constant, :LLVMIsConstant, [:pointer], :bool

.is_constant_string(c) ⇒ Integer

Returns true if the specified constant is an array of i8.

Parameters:

• c (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• ConstantDataSequential::getAsString()

# File 'lib/llvm/core_ffi.rb', line 2708

attach_function :is_constant_string, :LLVMIsConstantString, [:pointer], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3081

attach_function :is_declaration, :LLVMIsDeclaration, [:pointer], :int

.is_externally_initialized(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3327

attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [:pointer], :int

.is_function_var_arg(function_ty) ⇒ Integer

Returns whether a function type is variadic.

Parameters:

• function_ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 1453

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [:pointer], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi_v2.rb', line 331

attach_function :is_global_constant, :LLVMIsGlobalConstant, [:pointer], :bool

.is_literal_struct(struct_ty) ⇒ Bool

Determine whether a structure is literal.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))

Returns:

• (Bool)

See Also:

• llvmllvm::StructTypellvm::StructType::isLiteral()

# File 'lib/llvm/core_ffi_v2.rb', line 148

attach_function :is_literal_struct, :LLVMIsLiteralStruct, [:pointer], :bool

.is_multithreaded ⇒ Integer

Check whether LLVM is executing in thread-safe mode or not.

@see llvm::llvm_is_multithreaded

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5446

attach_function :is_multithreaded, :LLVMIsMultithreaded, [], :int

.is_null(val) ⇒ Integer

Determine whether a value instance is null.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Constantllvm::Constant::isNullValue()

# File 'lib/llvm/core_ffi_v2.rb', line 313

attach_function :is_null, :LLVMIsNull, [:pointer], :bool

.is_opaque_struct(struct_ty) ⇒ Bool

Determine whether a structure is opaque.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))

Returns:

• (Bool)

See Also:

• llvmllvm::StructTypellvm::StructType::isOpaque()

# File 'lib/llvm/core_ffi_v2.rb', line 138

attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [:pointer], :bool

.is_packed_struct(struct_ty) ⇒ Bool

Determine whether a structure is packed.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))

Returns:

• (Bool)

See Also:

• llvmllvm::StructTypellvm::StructType::isPacked()

# File 'lib/llvm/core_ffi_v2.rb', line 128

attach_function :is_packed_struct, :LLVMIsPackedStruct, [:pointer], :bool

.is_tail_call(call_inst) ⇒ Integer

Obtain whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

Parameters:

• call_inst (FFI::Pointer(ValueRef))

Returns:

• (Integer)

See Also:

• llvmllvm::CallInstllvm::CallInst::isTailCall()

# File 'lib/llvm/core_ffi.rb', line 4054

attach_function :is_tail_call, :LLVMIsTailCall, [:pointer], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi_v2.rb', line 323

attach_function :is_thread_local, :LLVMIsThreadLocal, [:pointer], :bool

.is_undef(val) ⇒ Integer

Determine whether a value instance is undefined.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi_v2.rb', line 303

attach_function :is_undef, :LLVMIsUndef, [:pointer], :bool

.label_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1715

attach_function :label_type, :LLVMLabelType, [], :pointer

.label_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a label type in a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1692

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [:pointer], :pointer

.link_in_interpreter ⇒ nil

(Not documented)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 23

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

.link_in_mcjit ⇒ nil

@{

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 16

attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void

.link_modules2(dest, src) ⇒ Integer

Links the source module into the destination module. The source module is destroyed. The return value is true if an error occurred, false otherwise. Use the diagnostic handler to get any diagnostic message.

Parameters:

• dest (FFI::Pointer(ModuleRef))
• src (FFI::Pointer(ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/linker_ffi.rb', line 36

attach_function :link_modules2, :LLVMLinkModules2, [:pointer, :pointer], :int

.load_library_permanently(filename) ⇒ Integer

(Not documented)

Parameters:

• filename (String)

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 15

attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int

.md_node(vals, count) ⇒ FFI::Pointer(ValueRef)

Obtain a MDNode value from the global context.

Parameters:

• vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3598

attach_function :md_node, :LLVMMDNode, [:pointer, :uint], :pointer

.md_node_in_context(c, vals, count) ⇒ FFI::Pointer(ValueRef)

Obtain a MDNode value from a context.

The returned value corresponds to the llvm::MDNode class.

Parameters:

• c (FFI::Pointer(ContextRef))
• vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3589

attach_function :md_node_in_context, :LLVMMDNodeInContext, [:pointer, :pointer, :uint], :pointer

.md_string(str, s_len) ⇒ FFI::Pointer(ValueRef)

Obtain a MDString value from the global context.

Parameters:

• str (String)
• s_len (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3577

attach_function :md_string, :LLVMMDString, [:string, :uint], :pointer

.md_string_in_context(c, str, s_len) ⇒ FFI::Pointer(ValueRef)

Obtain a MDString value from a context.

The returned instance corresponds to the llvm::MDString class.

The instance is specified by string data of a specified length. The string content is copied, so the backing memory can be freed after this function returns.

Parameters:

• c (FFI::Pointer(ContextRef))
• str (String)
• s_len (Integer)

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 3568

attach_function :md_string_in_context, :LLVMMDStringInContext, [:pointer, :string, :uint], :pointer

.module_create_with_name(module_id) ⇒ FFI::Pointer(ModuleRef)

Create a new, empty module in the global context.

This is equivalent to calling LLVMModuleCreateWithNameInContext with LLVMGetGlobalContext() as the context parameter.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

• module_id (String)

Returns:

• (FFI::Pointer(ModuleRef))

# File 'lib/llvm/core_ffi.rb', line 923

attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], :pointer

.module_create_with_name_in_context(module_id, c) ⇒ FFI::Pointer(ModuleRef)

Create a new, empty module in a specific context.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

• module_id (String)
• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(ModuleRef))

# File 'lib/llvm/core_ffi.rb', line 935

attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, :pointer], :pointer

.move_basic_block_after(bb, move_pos) ⇒ nil

Move a basic block to after another one.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))
• move_pos (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::moveAfter()

# File 'lib/llvm/core_ffi.rb', line 3860

attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [:pointer, :pointer], :void

.move_basic_block_before(bb, move_pos) ⇒ nil

Move a basic block to before another one.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))
• move_pos (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::moveBefore()

# File 'lib/llvm/core_ffi.rb', line 3849

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [:pointer, :pointer], :void

.offset_of_element(td, struct_ty, element) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• struct_ty (FFI::Pointer(TypeRef))
• element (Integer)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 298

attach_function :offset_of_element, :LLVMOffsetOfElement, [OpaqueTargetData, :pointer, :uint], :ulong_long

.parse_bitcode(mem_buf, out_module, out_message) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_module (FFI::Pointer(*ModuleRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 16

attach_function :parse_bitcode, :LLVMParseBitcode, [:pointer, :pointer, :pointer], :int

.parse_bitcode2(mem_buf, out_module) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_module (FFI::Pointer(*ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 25

attach_function :parse_bitcode2, :LLVMParseBitcode2, [:pointer, :pointer], :int

.parse_bitcode_in_context(context_ref, mem_buf, out_module, out_message) ⇒ Integer

(Not documented)

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_module (FFI::Pointer(*ModuleRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 36

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [:pointer, :pointer, :pointer, :pointer], :int

.parse_bitcode_in_context2(context_ref, mem_buf, out_module) ⇒ Integer

(Not documented)

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_module (FFI::Pointer(*ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 46

attach_function :parse_bitcode_in_context2, :LLVMParseBitcodeInContext2, [:pointer, :pointer, :pointer], :int

.parse_command_line_options(argc, argv, overview) ⇒ nil

This function parses the given arguments using the LLVM command line parser. Note that the only stable thing about this function is its signature; you cannot rely on any particular set of command line arguments being interpreted the same way across LLVM versions.

Parameters:

• argc (Integer)
• argv (FFI::Pointer(**CharS))
• overview (String)

Returns:

• (nil)

See Also:

• llvmllvm::clllvm::cl::ParseCommandLineOptions()

# File 'lib/llvm/core_ffi.rb', line 30

attach_function :parse_command_line_options, :LLVMParseCommandLineOptions, [:int, :pointer, :string], :void

.pointer_size(td) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 170

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_size_for_as(td, as) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• as (Integer)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 179

attach_function :pointer_size_for_as, :LLVMPointerSizeForAS, [OpaqueTargetData, :uint], :uint

.pointer_type(element_type, address_space) ⇒ FFI::Pointer(TypeRef)

Create a pointer type that points to a defined type.

The created type will exist in the context that its pointee type exists in.

Parameters:

• element_type (FFI::Pointer(TypeRef))
• address_space (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::PointerTypellvm::PointerType::get()

# File 'lib/llvm/core_ffi.rb', line 1637

attach_function :pointer_type, :LLVMPointerType, [:pointer, :uint], :pointer

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• block (FFI::Pointer(BasicBlockRef))
• instr (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4216

attach_function :position_builder, :LLVMPositionBuilder, [:pointer, :pointer, :pointer], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• block (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4234

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [:pointer, :pointer], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• instr (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4225

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [:pointer, :pointer], :void

.ppcfp128_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1431

attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], :pointer

.ppcfp128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 128-bit floating point type (two 64-bits) from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1387

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [:pointer], :pointer

.preferred_alignment_of_global(td, global_var) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• global_var (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 278

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, :pointer], :uint

.preferred_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 269

attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, :pointer], :uint

.print_module_to_file(m, filename, error_message) ⇒ Integer

Print a representation of a module to a file. The ErrorMessage needs to be disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.

Parameters:

• m (FFI::Pointer(ModuleRef))
• filename (String)
• error_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

See Also:

• Module::print()

# File 'lib/llvm/core_ffi.rb', line 1019

attach_function :print_module_to_file, :LLVMPrintModuleToFile, [:pointer, :string, :pointer], :int

.print_module_to_string(m) ⇒ String

Return a string representation of the module. Use LLVMDisposeMessage to free the string.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (String)

See Also:

• Module::print()

# File 'lib/llvm/core_ffi.rb', line 1030

attach_function :print_module_to_string, :LLVMPrintModuleToString, [:pointer], :string

.print_type_to_string(val) ⇒ String

Return a string representation of the type. Use LLVMDisposeMessage to free the string.

Parameters:

• val (FFI::Pointer(TypeRef))

Returns:

• (String)

See Also:

• llvmllvm::Typellvm::Type::print()

# File 'lib/llvm/core_ffi.rb', line 1222

attach_function :print_type_to_string, :LLVMPrintTypeToString, [:pointer], :string

.print_value_to_string(val) ⇒ String

Return a string representation of the value. Use LLVMDisposeMessage to free the string.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (String)

See Also:

• llvmllvm::Valuellvm::Value::print()

# File 'lib/llvm/core_ffi.rb', line 1774

attach_function :print_value_to_string, :LLVMPrintValueToString, [:pointer], :string

.recompile_and_relink_function(ee, fn) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• fn (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(*Void))

# File 'lib/llvm/execution_engine_ffi.rb', line 289

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, :pointer], :pointer

.remove_basic_block_from_parent(bb) ⇒ nil

Remove a basic block from a function.

This deletes the basic block from its containing function but keep the basic block alive.

Parameters:

• bb (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::removeFromParent()

# File 'lib/llvm/core_ffi.rb', line 3838

attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [:pointer], :void

.remove_module(ee, m, out_mod, out_error) ⇒ Integer

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• m (FFI::Pointer(ModuleRef))
• out_mod (FFI::Pointer(*ModuleRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 270

attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int

.replace_all_uses_with(old_val, new_val) ⇒ nil

Replace all uses of a value with another one.

Parameters:

• old_val (FFI::Pointer(ValueRef))
• new_val (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::replaceAllUsesWith()

# File 'lib/llvm/core_ffi.rb', line 1785

attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [:pointer, :pointer], :void

.run_function(ee, f, num_args, args) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• f (FFI::Pointer(ValueRef))
• num_args (Integer)
• args (FFI::Pointer(*GenericValueRef))

Returns:

• (OpaqueGenericValue)

# File 'lib/llvm/execution_engine_ffi.rb', line 241

attach_function :run_function, :LLVMRunFunction, [OpaqueExecutionEngine, :pointer, :uint, :pointer], OpaqueGenericValue

.run_function_as_main(ee, f, arg_c, arg_v, env_p) ⇒ Integer

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)
• f (FFI::Pointer(ValueRef))
• arg_c (Integer)
• arg_v (FFI::Pointer(**CharS))
• env_p (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/execution_engine_ffi.rb', line 230

attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [OpaqueExecutionEngine, :pointer, :uint, :pointer, :pointer], :int

.run_function_pass_manager(fpm, f) ⇒ Integer

Executes all of the function passes scheduled in the function pass manager

on the provided function. Returns 1 if any of the passes modified the
function, false otherwise.
@see llvm::FunctionPassManager::run(Function&)

Parameters:

• fpm (FFI::Pointer(PassManagerRef))
• f (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5401

attach_function :run_function_pass_manager, :LLVMRunFunctionPassManager, [:pointer, :pointer], :int

.run_pass_manager(pm, m) ⇒ Integer

Initializes, executes on the provided module, and finalizes all of the

passes scheduled in the pass manager. Returns 1 if any of the passes
modified the module, 0 otherwise.
@see llvm::PassManager::run(Module&)

Parameters:

• pm (FFI::Pointer(PassManagerRef))
• m (FFI::Pointer(ModuleRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5379

attach_function :run_pass_manager, :LLVMRunPassManager, [:pointer, :pointer], :int

.run_passes(pmb, opt_level) ⇒ nil

/**

* Construct and run a set of passes over a module
*
* This function takes a string with the passes that should be used. The format
* of this string is the same as opt's -passes argument for the new pass
* manager. Individual passes may be specified, separated by commas. Full
* pipelines may also be invoked using `default<O3>` and friends. See opt for
* full reference of the Passes format.
*/

LLVMErrorRef LLVMRunPasses(LLVMModuleRef M, const char *Passes,

LLVMTargetMachineRef TM,
LLVMPassBuilderOptionsRef Options);

Parameters:

• pmb (OpaquePassManagerBuilder)
• opt_level (Integer)

Returns:

• (nil)

# File 'lib/llvm/pass_builder.rb', line 794

attach_function :run_passes, :LLVMRunPasses, [:pointer, :string, :pointer, :pointer], :pointer

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 210

attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void

.run_static_destructors(ee) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (nil)

# File 'lib/llvm/execution_engine_ffi.rb', line 218

attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void

.search_for_address_of_symbol(symbol_name) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

• symbol_name (String)

Returns:

• (FFI::Pointer(*Void))

# File 'lib/llvm/core_ffi.rb', line 38

attach_function :search_for_address_of_symbol, :LLVMSearchForAddressOfSymbol, [:string], :pointer

.set_alignment(v, bytes) ⇒ nil

Set the preferred alignment of the value.

Parameters:

• v (FFI::Pointer(ValueRef))
• bytes (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::AllocaInstllvm::AllocaInst::setAlignment()
• llvmllvm::LoadInstllvm::LoadInst::setAlignment()
• llvmllvm::StoreInstllvm::StoreInst::setAlignment()
• llvmllvm::GlobalValuellvm::GlobalValue::setAlignment()

# File 'lib/llvm/core_ffi.rb', line 3191

attach_function :set_alignment, :LLVMSetAlignment, [:pointer, :uint], :void

.set_cleanup(landing_pad, val) ⇒ nil

Set the ‘cleanup’ flag in the landingpad instruction

Parameters:

• landing_pad (FFI::Pointer(ValueRef))
• val (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4437

attach_function :set_cleanup, :LLVMSetCleanup, [:pointer, :int], :void

.set_condition(branch, cond) ⇒ nil

Set the condition of a branch instruction.

This only works on llvm::BranchInst instructions.

Parameters:

• branch (FFI::Pointer(ValueRef))
• cond (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::BranchInstllvm::BranchInst::setCondition

# File 'lib/llvm/core_ffi.rb', line 4137

attach_function :set_condition, :LLVMSetCondition, [:pointer, :pointer], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

• builder (FFI::Pointer(BuilderRef))
• l (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4286

attach_function :set_current_debug_location, :LLVMSetCurrentDebugLocation, [:pointer, :pointer], :void

.set_data_layout(m, triple) ⇒ nil

Set the data layout for a module.

Parameters:

• m (FFI::Pointer(ModuleRef))
• triple (String)

Returns:

• (nil)

See Also:

• Module::setDataLayout()

# File 'lib/llvm/core_ffi.rb', line 975

attach_function :set_data_layout, :LLVMSetDataLayout, [:pointer, :string], :void

.set_dll_storage_class(global, class_) ⇒ nil

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))
• class_ (Symbol from _enum_dll_storage_class_)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3149

attach_function :set_dll_storage_class, :LLVMSetDLLStorageClass, [:pointer, :dll_storage_class], :void

.set_externally_initialized(global_var, is_ext_init) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))
• is_ext_init (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3336

attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [:pointer, :int], :void

.set_function_call_conv(fn, cc) ⇒ nil

Set the calling convention of a function.

Parameters:

• Fn —

  Function to operate on

• CC —

  LLVMCallConv to set calling convention to

• fn (FFI::Pointer(ValueRef))
• cc (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::setCallingConv()

# File 'lib/llvm/core_ffi.rb', line 3411

attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [:pointer, :uint], :void

.set_gc(fn, name) ⇒ nil

Define the garbage collector to use during code generation.

Parameters:

• fn (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::setGC()

# File 'lib/llvm/core_ffi.rb', line 3433

attach_function :set_gc, :LLVMSetGC, [:pointer, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))
• is_constant (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3302

attach_function :set_global_constant, :LLVMSetGlobalConstant, [:pointer, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))
• constant_val (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3284

attach_function :set_initializer, :LLVMSetInitializer, [:pointer, :pointer], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

• builder (FFI::Pointer(BuilderRef))
• inst (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4303

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [:pointer, :pointer], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

• instr (FFI::Pointer(ValueRef))
• index (Integer)
• align (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4042

attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [:pointer, :uint, :uint], :void

.set_instruction_call_conv(instr, cc) ⇒ nil

Set the calling convention for a call instruction.

This expects an LLVMValueRef that corresponds to a llvm::CallInst or llvm::InvokeInst.

Parameters:

• instr (FFI::Pointer(ValueRef))
• cc (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::CallInstllvm::CallInst::setCallingConv()
• llvmllvm::InvokeInstllvm::InvokeInst::setCallingConv()

# File 'lib/llvm/core_ffi.rb', line 4019

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [:pointer, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))
• linkage (Symbol from _enum_linkage_)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3098

attach_function :set_linkage, :LLVMSetLinkage, [:pointer, :linkage], :void

.set_metadata(val, kind_id, node) ⇒ nil

Set metadata associated with an instruction value.

Parameters:

• val (FFI::Pointer(ValueRef))
• kind_id (Integer)
• node (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3908

attach_function :set_metadata, :LLVMSetMetadata, [:pointer, :uint, :pointer], :void

.set_module_data_layout(m, dl) ⇒ nil

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))
• dl (OpaqueTargetData)

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 121

attach_function :set_module_data_layout, :LLVMSetModuleDataLayout, [:pointer, OpaqueTargetData], :void

.set_module_inline_asm(m, asm) ⇒ nil

Set inline assembly for a module.

Parameters:

• m (FFI::Pointer(ModuleRef))
• asm (String)

Returns:

• (nil)

See Also:

• Module::setModuleInlineAsm()

# File 'lib/llvm/core_ffi.rb', line 1041

attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [:pointer, :string], :void

.set_operand(user, index, val) ⇒ nil

Set an operand at a specific index in a llvm::User value.

Parameters:

• user (FFI::Pointer(ValueRef))
• index (Integer)
• val (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Userllvm::User::setOperand()

# File 'lib/llvm/core_ffi.rb', line 2507

attach_function :set_operand, :LLVMSetOperand, [:pointer, :uint, :pointer], :void

.set_ordering(memory_access_inst, ordering) ⇒ nil

(Not documented)

Parameters:

• memory_access_inst (FFI::Pointer(ValueRef))
• ordering (Symbol from _enum_atomic_ordering_)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4889

attach_function :set_ordering, :LLVMSetOrdering, [:pointer, :atomic_ordering], :void

.set_param_alignment(arg, align) ⇒ nil

Set the alignment for a function parameter.

Parameters:

• arg (FFI::Pointer(ValueRef))
• align (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::Argumentllvm::Argument::addAttr()
• llvmllvm::AttrBuilderllvm::AttrBuilder::addAlignmentAttr()

# File 'lib/llvm/core_ffi.rb', line 3552

attach_function :set_param_alignment, :LLVMSetParamAlignment, [:pointer, :uint], :void

.set_personality_fn(fn, personality_fn) ⇒ nil

Set the personality function attached to the function.

Parameters:

• fn (FFI::Pointer(ValueRef))
• personality_fn (FFI::Pointer(ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::setPersonalityFn()

# File 'lib/llvm/core_ffi.rb', line 3375

attach_function :set_personality_fn, :LLVMSetPersonalityFn, [:pointer, :pointer], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))
• section (String)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3115

attach_function :set_section, :LLVMSetSection, [:pointer, :string], :void

.set_successor(term, i, block) ⇒ nil

Update the specified successor to point at the provided block.

Parameters:

• term (FFI::Pointer(ValueRef))
• i (Integer)
• block (FFI::Pointer(BasicBlockRef))

Returns:

• (nil)

See Also:

• llvmllvm::TerminatorInstllvm::TerminatorInst::setSuccessor

# File 'lib/llvm/core_ffi.rb', line 4100

attach_function :set_successor, :LLVMSetSuccessor, [:pointer, :uint, :pointer], :void

.set_tail_call(call_inst, is_tail_call) ⇒ nil

Set whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

Parameters:

• call_inst (FFI::Pointer(ValueRef))
• is_tail_call (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::CallInstllvm::CallInst::setTailCall()

# File 'lib/llvm/core_ffi.rb', line 4067

attach_function :set_tail_call, :LLVMSetTailCall, [:pointer, :int], :void

.set_target(m, triple) ⇒ nil

Set the target triple for a module.

Parameters:

• m (FFI::Pointer(ModuleRef))
• triple (String)

Returns:

• (nil)

See Also:

• Module::setTargetTriple()

# File 'lib/llvm/core_ffi.rb', line 996

attach_function :set_target, :LLVMSetTarget, [:pointer, :string], :void

.set_target_machine_asm_verbosity(t, verbose_asm) ⇒ nil

Set the target machine’s ASM verbosity.

Parameters:

• t (OpaqueTargetMachine)
• verbose_asm (Integer)

Returns:

• (nil)

# File 'lib/llvm/target_ffi.rb', line 557

attach_function :set_target_machine_asm_verbosity, :LLVMSetTargetMachineAsmVerbosity, [OpaqueTargetMachine, :int], :void

.set_thread_local(global_var, is_thread_local) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))
• is_thread_local (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3293

attach_function :set_thread_local, :LLVMSetThreadLocal, [:pointer, :int], :void

.set_thread_local_mode(global_var, mode) ⇒ nil

(Not documented)

Parameters:

• global_var (FFI::Pointer(ValueRef))
• mode (Symbol from _enum_thread_local_mode_)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3319

attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [:pointer, :thread_local_mode], :void

.set_unnamed_addr(global, has_unnamed_addr) ⇒ nil

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))
• has_unnamed_addr (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3166

attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [:pointer, :int], :void

.set_value_name(val, name) ⇒ nil

Set the string name of a value.

Parameters:

• val (FFI::Pointer(ValueRef))
• name (String)

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::setName()

# File 'lib/llvm/core_ffi.rb', line 1753

attach_function :set_value_name, :LLVMSetValueName, [:pointer, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

• global (FFI::Pointer(ValueRef))
• viz (Symbol from _enum_visibility_)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 3132

attach_function :set_visibility, :LLVMSetVisibility, [:pointer, :visibility], :void

.set_volatile(memory_access_inst, is_volatile) ⇒ nil

(Not documented)

Parameters:

• memory_access_inst (FFI::Pointer(ValueRef))
• is_volatile (Integer)

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 4872

attach_function :set_volatile, :LLVMSetVolatile, [:pointer, :int], :void

.shutdown ⇒ nil

@}

Deallocate and destroy all ManagedStatic variables.

@see llvm::llvm_shutdown
@see ManagedStatic

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 773

attach_function :shutdown, :LLVMShutdown, [], :void

.size_of(ty) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (FFI::Pointer(ValueRef))

# File 'lib/llvm/core_ffi.rb', line 2823

attach_function :size_of, :LLVMSizeOf, [:pointer], :pointer

.size_of_type_in_bits(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 224

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, :pointer], :ulong_long

.start_multithreaded ⇒ Integer

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.  This function always returns
LLVMIsMultithreaded().

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 5430

attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int

.stop_multithreaded ⇒ nil

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.

Returns:

• (nil)

# File 'lib/llvm/core_ffi.rb', line 5438

attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void

.store_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

• td (OpaqueTargetData)
• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 233

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, :pointer], :ulong_long

.struct_create_named(c, name) ⇒ FFI::Pointer(TypeRef)

Create an empty structure in a context having a specified name.

Parameters:

• c (FFI::Pointer(ContextRef))
• name (String)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::StructTypellvm::StructType::create()

# File 'lib/llvm/core_ffi.rb', line 1525

attach_function :struct_create_named, :LLVMStructCreateNamed, [:pointer, :string], :pointer

.struct_get_type_at_index(struct_ty, i) ⇒ FFI::Pointer(TypeRef)

Get the type of the element at a given index in the structure.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))
• i (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::StructTypellvm::StructType::getTypeAtIndex()

# File 'lib/llvm/core_ffi.rb', line 1585

attach_function :struct_get_type_at_index, :LLVMStructGetTypeAtIndex, [:pointer, :uint], :pointer

.struct_set_body(struct_ty, element_types, element_count, packed) ⇒ nil

Set the contents of a structure type.

Parameters:

• struct_ty (FFI::Pointer(TypeRef))
• element_types (FFI::Pointer(*TypeRef))
• element_count (Integer)
• packed (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::StructTypellvm::StructType::setBody()

# File 'lib/llvm/core_ffi.rb', line 1548

attach_function :struct_set_body, :LLVMStructSetBody, [:pointer, :pointer, :uint, :int], :void

.struct_type(element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

Create a new structure type in the global context.

Parameters:

• element_types (FFI::Pointer(*TypeRef))
• element_count (Integer)
• packed (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::StructTypellvm::StructType::create()

# File 'lib/llvm/core_ffi.rb', line 1514

attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], :pointer

.struct_type_in_context(c, element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

Create a new structure type in a context.

A structure is specified by a list of inner elements/types and whether these can be packed together.

Parameters:

• c (FFI::Pointer(ContextRef))
• element_types (FFI::Pointer(*TypeRef))
• element_count (Integer)
• packed (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::StructTypellvm::StructType::create()

# File 'lib/llvm/core_ffi.rb', line 1502

attach_function :struct_type_in_context, :LLVMStructTypeInContext, [:pointer, :pointer, :uint, :int], :pointer

.target_has_asm_backend(t) ⇒ Integer

Returns if the target as an ASM backend (required for emitting output)

Parameters:

• t (Target)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 479

attach_function :target_has_asm_backend, :LLVMTargetHasAsmBackend, [Target], :int

.target_has_jit(t) ⇒ Integer

Returns if the target has a JIT

Parameters:

• t (Target)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 463

attach_function :target_has_jit, :LLVMTargetHasJIT, [Target], :int

.target_has_target_machine(t) ⇒ Integer

Returns if the target has a TargetMachine associated

Parameters:

• t (Target)

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 471

attach_function :target_has_target_machine, :LLVMTargetHasTargetMachine, [Target], :int

.target_machine_emit_to_file(t, m, filename, codegen, error_message) ⇒ Integer

Emits an asm or object file for the given module to the filename. This

wraps several c++ only classes (among them a file stream). Returns any
error in ErrorMessage. Use LLVMDisposeMessage to dispose the message.

Parameters:

• t (OpaqueTargetMachine)
• m (FFI::Pointer(ModuleRef))
• filename (String)
• codegen (Symbol from _enum_code_gen_file_type_)
• error_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 571

attach_function :target_machine_emit_to_file, :LLVMTargetMachineEmitToFile, [OpaqueTargetMachine, :pointer, :string, :code_gen_file_type, :pointer], :int

.target_machine_emit_to_memory_buffer(t, m, codegen, error_message, out_mem_buf) ⇒ Integer

Compile the LLVM IR stored in p M and store the result in p OutMemBuf.

Parameters:

• t (OpaqueTargetMachine)
• m (FFI::Pointer(ModuleRef))
• codegen (Symbol from _enum_code_gen_file_type_)
• error_message (FFI::Pointer(**CharS))
• out_mem_buf (FFI::Pointer(*MemoryBufferRef))

Returns:

• (Integer)

# File 'lib/llvm/target_ffi.rb', line 583

attach_function :target_machine_emit_to_memory_buffer, :LLVMTargetMachineEmitToMemoryBuffer, [OpaqueTargetMachine, :pointer, :code_gen_file_type, :pointer, :pointer], :int

.type_is_sized(ty) ⇒ Integer

Whether the type has a known size.

Things that don’t have a size are abstract types, labels, and void.a

Parameters:

• ty (FFI::Pointer(TypeRef))

Returns:

• (Integer)

See Also:

• llvmllvm::Typellvm::Type::isSized()

# File 'lib/llvm/core_ffi.rb', line 1191

attach_function :type_is_sized, :LLVMTypeIsSized, [:pointer], :int

.type_of(val) ⇒ FFI::Pointer(TypeRef)

Obtain the type of a value.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::Valuellvm::Value::getType()

# File 'lib/llvm/core_ffi.rb', line 1732

attach_function :type_of, :LLVMTypeOf, [:pointer], :pointer

.value_as_basic_block(val) ⇒ FFI::Pointer(BasicBlockRef)

Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (FFI::Pointer(BasicBlockRef))

# File 'lib/llvm/core_ffi.rb', line 3663

attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [:pointer], :pointer

.value_is_basic_block(val) ⇒ Integer

Determine whether an LLVMValueRef is itself a basic block.

Parameters:

• val (FFI::Pointer(ValueRef))

Returns:

• (Integer)

# File 'lib/llvm/core_ffi.rb', line 3655

attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [:pointer], :int

.vector_type(element_type, element_count) ⇒ FFI::Pointer(TypeRef)

Create a vector type that contains a defined type and has a specific number of elements.

The created type will exist in the context thats its element type exists in.

Parameters:

• element_type (FFI::Pointer(TypeRef))
• element_count (Integer)

Returns:

• (FFI::Pointer(TypeRef))

See Also:

• llvmllvm::VectorTypellvm::VectorType::get()

# File 'lib/llvm/core_ffi.rb', line 1664

attach_function :vector_type, :LLVMVectorType, [:pointer, :uint], :pointer

.verify_function(fn, action) ⇒ Integer

Verifies that a single function is valid, taking the specified action. Useful

for debugging.

Parameters:

• fn (FFI::Pointer(ValueRef))
• action (Symbol from _enum_verifier_failure_action_)

Returns:

• (Integer)

# File 'lib/llvm/analysis_ffi.rb', line 52

attach_function :verify_function, :LLVMVerifyFunction, [:pointer, :verifier_failure_action], :int

.verify_module(m, action, out_message) ⇒ Integer

Verifies that a module is valid, taking the specified action if not.

Optionally returns a human-readable description of any invalid constructs.
OutMessage must be disposed with LLVMDisposeMessage.

Parameters:

• m (FFI::Pointer(ModuleRef))
• action (Symbol from _enum_verifier_failure_action_)
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/analysis_ffi.rb', line 42

attach_function :verify_module, :LLVMVerifyModule, [:pointer, :verifier_failure_action, :pointer], :int

.view_function_cfg(fn) ⇒ nil

Open up a ghostview window that displays the CFG of the current function.

Useful for debugging.

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/analysis_ffi.rb', line 61

attach_function :view_function_cfg, :LLVMViewFunctionCFG, [:pointer], :void

.view_function_cfg_only(fn) ⇒ nil

(Not documented)

Parameters:

• fn (FFI::Pointer(ValueRef))

Returns:

• (nil)

# File 'lib/llvm/analysis_ffi.rb', line 69

attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [:pointer], :void

.void_type ⇒ FFI::Pointer(TypeRef)

These are similar to the above functions except they operate on the global context.

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1708

attach_function :void_type, :LLVMVoidType, [], :pointer

.void_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a void type in a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1684

attach_function :void_type_in_context, :LLVMVoidTypeInContext, [:pointer], :pointer

.write_bitcode_to_fd(m, fd, should_close, unbuffered) ⇒ Integer

Writes a module to an open file descriptor. Returns 0 on success.

Parameters:

• m (FFI::Pointer(ModuleRef))
• fd (Integer)
• should_close (Integer)
• unbuffered (Integer)

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 106

attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [:pointer, :int, :int, :int], :int

.write_bitcode_to_file(m, path) ⇒ Integer

Writes a module to the specified path. Returns 0 on success.

Parameters:

• m (FFI::Pointer(ModuleRef))
• path (String)

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 95

attach_function :write_bitcode_to_file, :LLVMWriteBitcodeToFile, [:pointer, :string], :int

.write_bitcode_to_file_handle(m, handle) ⇒ Integer

Deprecated for LLVMWriteBitcodeToFD. Writes a module to an open file

descriptor. Returns 0 on success. Closes the Handle.

Parameters:

• m (FFI::Pointer(ModuleRef))
• handle (Integer)

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 116

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [:pointer, :int], :int

.write_bitcode_to_memory_buffer(m) ⇒ FFI::Pointer(MemoryBufferRef)

Writes a module to a new memory buffer and returns it.

Parameters:

• m (FFI::Pointer(ModuleRef))

Returns:

• (FFI::Pointer(MemoryBufferRef))

# File 'lib/llvm/core/bitcode_ffi.rb', line 124

attach_function :write_bitcode_to_memory_buffer, :LLVMWriteBitcodeToMemoryBuffer, [:pointer], :pointer

.x86amx_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi_v2.rb', line 107

attach_function :x86amx_type, :LLVMX86AMXType, [], :pointer

.x86fp80_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1417

attach_function :x86fp80_type, :LLVMX86FP80Type, [], :pointer

.x86fp80_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 80-bit floating point type (X87) from a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1370

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [:pointer], :pointer

.x86mmx_type ⇒ FFI::Pointer(TypeRef)

(Not documented)

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1722

attach_function :x86mmx_type, :LLVMX86MMXType, [], :pointer

.x86mmx_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a X86 MMX type in a context.

Parameters:

• c (FFI::Pointer(ContextRef))

Returns:

• (FFI::Pointer(TypeRef))

# File 'lib/llvm/core_ffi.rb', line 1700

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [:pointer], :pointer