Module: LLVM::C

Extended by:

FFI::Library

Defined in:

lib/llvm.rb,
lib/llvm/core.rb,
lib/llvm/target.rb,
lib/llvm/core_ffi.rb,
lib/llvm/linker_ffi.rb,
lib/llvm/target_ffi.rb,
lib/llvm/analysis_ffi.rb,
lib/llvm/core/bitcode_ffi.rb,
lib/llvm/transforms/ipo_ffi.rb,
lib/llvm/execution_engine_ffi.rb,
lib/llvm/transforms/scalar_ffi.rb,
lib/llvm/transforms/builder_ffi.rb,
lib/llvm/transforms/vectorize_ffi.rb

Defined Under Namespace

Modules: TargetWrappers Classes: MCJITCompilerOptions, OpaqueBasicBlock, OpaqueBuilder, OpaqueContext, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMemoryBuffer, OpaqueModule, OpaqueModuleProvider, OpaquePassManager, OpaquePassManagerBuilder, OpaquePassRegistry, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, OpaqueType, OpaqueUse, OpaqueValue, StructLayout, Target

Class Method Summary

• ._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_int_predicate_ ⇒ Symbol

  (Not documented).

• ._enum_landing_pad_clause_ty_ ⇒ Symbol

  (Not documented).

• ._enum_linkage_ ⇒ Symbol

  (Not documented).

• ._enum_linker_mode_ ⇒ Symbol

  (Not documented).

• ._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

  (Not documented).

• ._enum_visibility_ ⇒ Symbol

  (Not documented).

• .abi_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

  Computes the ABI alignment of a type in bytes for a target.

• .abi_size_of_type(opaque_target_data, type_ref) ⇒ Integer

  Computes the ABI size of a type in bytes for a target.

• .add_aggressive_dce_pass(pm) ⇒ nil

  (Not documented).

• .add_alias(m, ty, aliasee, name) ⇒ OpaqueValue

  This group contains function that operate on global alias values.

• .add_always_inliner_pass(pm) ⇒ nil

  See llvm::createAlwaysInlinerPass function.

• .add_argument_promotion_pass(pm) ⇒ nil

  (Not documented).

• .add_attribute(arg, pa) ⇒ nil

  Add an attribute to a function argument.

• .add_basic_alias_analysis_pass(pm) ⇒ nil

  See llvm::createBasicAliasAnalysisPass function.

• .add_bb_vectorize_pass(pm) ⇒ nil

  (Not documented).

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

  Add a case to the switch instruction.

• .add_cfg_simplification_pass(pm) ⇒ nil

  See llvm::createCFGSimplificationPass function.

• .add_clause(landing_pad, clause_val) ⇒ nil

  Add a catch or filter clause to the landingpad instruction.

• .add_constant_merge_pass(pm) ⇒ nil

  See llvm::createConstantMergePass function.

• .add_constant_propagation_pass(pm) ⇒ nil

  See llvm::createConstantPropagationPass function.

• .add_correlated_value_propagation_pass(pm) ⇒ nil

  See llvm::createCorrelatedValuePropagationPass function.

• .add_dead_arg_elimination_pass(pm) ⇒ nil

  See llvm::createDeadArgEliminationPass function.

• .add_dead_store_elimination_pass(pm) ⇒ nil

  See llvm::createDeadStoreEliminationPass function.

• .add_demote_memory_to_register_pass(pm) ⇒ nil

  See llvm::demotePromoteMemoryToRegisterPass function.

• .add_destination(indirect_br, dest) ⇒ nil

  Add a destination to the indirectbr instruction.

• .add_early_cse_pass(pm) ⇒ nil

  See llvm::createEarlyCSEPass function.

• .add_function(m, name, function_ty) ⇒ OpaqueValue

  Add a function to a module under a specified name.

• .add_function_attr(fn, pa) ⇒ nil

  Add an attribute to a function.

• .add_function_attrs_pass(pm) ⇒ nil

  See llvm::createFunctionAttrsPass function.

• .add_function_inlining_pass(pm) ⇒ nil

  See llvm::createFunctionInliningPass function.

• .add_global(m, ty, name) ⇒ OpaqueValue

  This group contains functions that operate on global variable values.

• .add_global_dce_pass(pm) ⇒ nil

  See llvm::createGlobalDCEPass function.

• .add_global_in_address_space(m, ty, name, address_space) ⇒ OpaqueValue

  (Not documented).

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

  (Not documented).

• .add_global_optimizer_pass(pm) ⇒ nil

  See llvm::createGlobalOptimizerPass function.

• .add_gvn_pass(pm) ⇒ nil

  See llvm::createGVNPass function.

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

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

• .add_ind_var_simplify_pass(pm) ⇒ nil

  See llvm::createIndVarSimplifyPass function.

• .add_instr_attribute(instr, index, attribute) ⇒ nil

  (Not documented).

• .add_instruction_combining_pass(pm) ⇒ nil

  See llvm::createInstructionCombiningPass function.

• .add_internalize_pass(pass_manager_ref, all_but_main) ⇒ nil

  See llvm::createInternalizePass function.

• .add_ip_constant_propagation_pass(pm) ⇒ nil

  See llvm::createIPConstantPropagationPass function.

• .add_ipsccp_pass(pm) ⇒ nil

  See llvm::createIPSCCPPass function.

• .add_jump_threading_pass(pm) ⇒ nil

  See llvm::createJumpThreadingPass function.

• .add_licm_pass(pm) ⇒ nil

  See llvm::createLICMPass function.

• .add_loop_deletion_pass(pm) ⇒ nil

  See llvm::createLoopDeletionPass function.

• .add_loop_idiom_pass(pm) ⇒ nil

  See llvm::createLoopIdiomPass function.

• .add_loop_rotate_pass(pm) ⇒ nil

  See llvm::createLoopRotatePass function.

• .add_loop_unroll_pass(pm) ⇒ nil

  See llvm::createLoopUnrollPass function.

• .add_loop_unswitch_pass(pm) ⇒ nil

  See llvm::createLoopUnswitchPass function.

• .add_loop_vectorize_pass(pm) ⇒ nil

  See llvm::createLoopVectorizePass function.

• .add_lower_expect_intrinsic_pass(pm) ⇒ nil

  See llvm::createLowerExpectIntrinsicPass function.

• .add_mem_cpy_opt_pass(pm) ⇒ nil

  See llvm::createMemCpyOptPass function.

• .add_module(ee, m) ⇒ nil

  (Not documented).

• .add_module_provider(ee, mp) ⇒ nil

  Deprecated: Use LLVMAddModule instead.

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

  Add an operand to named metadata.

• .add_promote_memory_to_register_pass(pm) ⇒ nil

  See llvm::createPromoteMemoryToRegisterPass function.

• .add_prune_eh_pass(pm) ⇒ nil

  See llvm::createPruneEHPass function.

• .add_reassociate_pass(pm) ⇒ nil

  See llvm::createReassociatePass function.

• .add_scalar_repl_aggregates_pass(pm) ⇒ nil

  See llvm::createScalarReplAggregatesPass function.

• .add_scalar_repl_aggregates_pass_ssa(pm) ⇒ nil

  See llvm::createScalarReplAggregatesPass function.

• .add_scalar_repl_aggregates_pass_with_threshold(pm, threshold) ⇒ nil

  See llvm::createScalarReplAggregatesPass function.

• .add_sccp_pass(pm) ⇒ nil

  See llvm::createSCCPPass function.

• .add_simplify_lib_calls_pass(pm) ⇒ nil

  See llvm::createSimplifyLibCallsPass function.

• .add_slp_vectorize_pass(pm) ⇒ nil

  See llvm::createSLPVectorizerPass function.

• .add_strip_dead_prototypes_pass(pm) ⇒ nil

  See llvm::createStripDeadPrototypesPass function.

• .add_strip_symbols_pass(pm) ⇒ nil

  See llvm::createStripSymbolsPass function.

• .add_tail_call_elimination_pass(pm) ⇒ nil

  See llvm::createTailCallEliminationPass function.

• .add_target_data(opaque_target_data, pass_manager_ref) ⇒ nil

  Adds target data information to a pass manager.

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

  Add a target-dependent attribute to a fuction.

• .add_target_library_info(opaque_target_library_infot_data, pass_manager_ref) ⇒ nil

  Adds target library information to a pass manager.

• .add_type_based_alias_analysis_pass(pm) ⇒ nil

  See llvm::createTypeBasedAliasAnalysisPass function.

• .add_verifier_pass(pm) ⇒ nil

  See llvm::createVerifierPass function.

• .align_of(ty) ⇒ OpaqueValue

  (Not documented).

• .append_basic_block(fn, name) ⇒ OpaqueBasicBlock

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

• .append_basic_block_in_context(c, fn, name) ⇒ OpaqueBasicBlock

  Append a basic block to the end of a function.

• .array_type(element_type, element_count) ⇒ OpaqueType

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

• .attach_function(name, *_) ⇒ Object
• .basic_block_as_value(bb) ⇒ OpaqueValue

  Convert a basic block instance to a value type.

• .block_address(f, bb) ⇒ OpaqueValue

  (Not documented).

• .build_a_shr(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  Arithmetic.

• .build_aggregate_ret(opaque_builder, ret_vals, n) ⇒ OpaqueValue

  (Not documented).

• .build_alloca(opaque_builder, ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_and(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_array_alloca(opaque_builder, ty, val, name) ⇒ OpaqueValue

  (Not documented).

• .build_array_malloc(opaque_builder, ty, val, name) ⇒ OpaqueValue

  (Not documented).

• .build_atomic_rmw(b, op, ptr, val, ordering, single_thread) ⇒ OpaqueValue

  (Not documented).

• .build_bin_op(b, op, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_br(opaque_builder, dest) ⇒ OpaqueValue

  (Not documented).

• .build_call(opaque_builder, fn, args, num_args, name) ⇒ OpaqueValue

  (Not documented).

• .build_cast(b, op, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_cond_br(opaque_builder, if_, then_, else_) ⇒ OpaqueValue

  (Not documented).

• .build_exact_s_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_extract_element(opaque_builder, vec_val, index, name) ⇒ OpaqueValue

  (Not documented).

• .build_extract_value(opaque_builder, agg_val, index, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_cmp(opaque_builder, op, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_neg(opaque_builder, v, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_f_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_fp_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_fp_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_fp_to_si(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_fp_to_ui(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_fp_trunc(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_free(opaque_builder, pointer_val) ⇒ OpaqueValue

  (Not documented).

• .build_gep(b, pointer, indices, num_indices, name) ⇒ OpaqueValue

  (Not documented).

• .build_global_string(b, str, name) ⇒ OpaqueValue

  (Not documented).

• .build_global_string_ptr(b, str, name) ⇒ OpaqueValue

  (Not documented).

• .build_i_cmp(opaque_builder, op, lhs, rhs, name) ⇒ OpaqueValue

  Comparisons.

• .build_in_bounds_gep(b, pointer, indices, num_indices, name) ⇒ OpaqueValue

  (Not documented).

• .build_indirect_br(b, addr, num_dests) ⇒ OpaqueValue

  (Not documented).

• .build_insert_element(opaque_builder, vec_val, elt_val, index, name) ⇒ OpaqueValue

  (Not documented).

• .build_insert_value(opaque_builder, agg_val, elt_val, index, name) ⇒ OpaqueValue

  (Not documented).

• .build_int_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_int_to_ptr(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_invoke(opaque_builder, fn, args, num_args, then_, catch, name) ⇒ OpaqueValue

  (Not documented).

• .build_is_not_null(opaque_builder, val, name) ⇒ OpaqueValue

  (Not documented).

• .build_is_null(opaque_builder, val, name) ⇒ OpaqueValue

  (Not documented).

• .build_l_shr(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_landing_pad(b, ty, pers_fn, num_clauses, name) ⇒ OpaqueValue

  (Not documented).

• .build_load(opaque_builder, pointer_val, name) ⇒ OpaqueValue

  (Not documented).

• .build_malloc(opaque_builder, ty, name) ⇒ OpaqueValue

  Memory.

• .build_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_neg(opaque_builder, v, name) ⇒ OpaqueValue

  (Not documented).

• .build_not(opaque_builder, v, name) ⇒ OpaqueValue

  (Not documented).

• .build_nsw_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_nsw_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_nsw_neg(b, v, name) ⇒ OpaqueValue

  (Not documented).

• .build_nsw_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_nuw_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_nuw_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_nuw_neg(b, v, name) ⇒ OpaqueValue

  (Not documented).

• .build_nuw_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_or(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_phi(opaque_builder, ty, name) ⇒ OpaqueValue

  Miscellaneous instructions.

• .build_pointer_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_ptr_diff(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_ptr_to_int(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_resume(b, exn) ⇒ OpaqueValue

  (Not documented).

• .build_ret(opaque_builder, v) ⇒ OpaqueValue

  (Not documented).

• .build_ret_void(opaque_builder) ⇒ OpaqueValue

  Terminators.

• .build_s_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_s_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_s_ext_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_s_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_select(opaque_builder, if_, then_, else_, name) ⇒ OpaqueValue

  (Not documented).

• .build_shl(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_shuffle_vector(opaque_builder, v1, v2, mask, name) ⇒ OpaqueValue

  (Not documented).

• .build_si_to_fp(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_store(opaque_builder, val, ptr) ⇒ OpaqueValue

  (Not documented).

• .build_struct_gep(b, pointer, idx, name) ⇒ OpaqueValue

  (Not documented).

• .build_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_switch(opaque_builder, v, else_, num_cases) ⇒ OpaqueValue

  (Not documented).

• .build_trunc(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  Casts.

• .build_trunc_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_u_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_u_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_ui_to_fp(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_unreachable(opaque_builder) ⇒ OpaqueValue

  (Not documented).

• .build_va_arg(opaque_builder, list, ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_xor(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

  (Not documented).

• .build_z_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .build_z_ext_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

  (Not documented).

• .byte_order(opaque_target_data) ⇒ Symbol from _enum_byte_ordering_

  Returns the byte order of a target, either LLVMBigEndian or LLVMLittleEndian.

• .call_frame_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

  Computes the call frame alignment of a type in bytes for a target.

• .clear_insertion_position(builder) ⇒ nil

  (Not documented).

• .const_a_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_all_ones(ty) ⇒ OpaqueValue

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

• .const_and(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_array(element_ty, constant_vals, length) ⇒ OpaqueValue

  Create a ConstantArray from values.

• .const_bit_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_exact_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_extract_element(vector_constant, index_constant) ⇒ OpaqueValue

  (Not documented).

• .const_extract_value(agg_constant, idx_list, num_idx) ⇒ OpaqueValue

  (Not documented).

• .const_f_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_f_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_f_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_f_neg(constant_val) ⇒ OpaqueValue

  (Not documented).

• .const_f_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_f_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_fp_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_fp_ext(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_fp_to_si(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_fp_to_ui(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_fp_trunc(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

  (Not documented).

• .const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_in_bounds_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

  (Not documented).

• .const_inline_asm(ty, asm_string, constraints, has_side_effects, is_align_stack) ⇒ OpaqueValue

  (Not documented).

• .const_insert_element(vector_constant, element_value_constant, index_constant) ⇒ OpaqueValue

  (Not documented).

• .const_insert_value(agg_constant, element_value_constant, idx_list, num_idx) ⇒ OpaqueValue

  (Not documented).

• .const_int(int_ty, n, sign_extend) ⇒ OpaqueValue

  Obtain a constant value for an integer type.

• .const_int_cast(constant_val, to_type, is_signed) ⇒ OpaqueValue

  (Not documented).

• .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) ⇒ OpaqueValue

  Obtain a constant value for an integer of arbitrary precision.

• .const_int_of_string(int_ty, text, radix) ⇒ OpaqueValue

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

• .const_int_of_string_and_size(int_ty, text, s_len, radix) ⇒ OpaqueValue

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

• .const_int_to_ptr(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_l_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_named_struct(struct_ty, constant_vals, count) ⇒ OpaqueValue

  Create a non-anonymous ConstantStruct from values.

• .const_neg(constant_val) ⇒ OpaqueValue

  (Not documented).

• .const_not(constant_val) ⇒ OpaqueValue

  (Not documented).

• .const_nsw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_nsw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_nsw_neg(constant_val) ⇒ OpaqueValue

  (Not documented).

• .const_nsw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_null(ty) ⇒ OpaqueValue

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

• .const_nuw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_nuw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_nuw_neg(constant_val) ⇒ OpaqueValue

  (Not documented).

• .const_nuw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_or(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_pointer_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_pointer_null(ty) ⇒ OpaqueValue

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

• .const_ptr_to_int(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_real(real_ty, n) ⇒ OpaqueValue

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

• .const_real_of_string(real_ty, text) ⇒ OpaqueValue

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

• .const_real_of_string_and_size(real_ty, text, s_len) ⇒ OpaqueValue

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

• .const_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_s_ext(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_s_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_s_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_select(constant_condition, constant_if_true, constant_if_false) ⇒ OpaqueValue

  (Not documented).

• .const_shl(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ OpaqueValue

  (Not documented).

• .const_si_to_fp(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_string(str, length, dont_null_terminate) ⇒ OpaqueValue

  Create a ConstantDataSequential with string content in the global context.

• .const_string_in_context(c, str, length, dont_null_terminate) ⇒ OpaqueValue

  Create a ConstantDataSequential and initialize it with a string.

• .const_struct(constant_vals, count, packed) ⇒ OpaqueValue

  Create a ConstantStruct in the global Context.

• .const_struct_in_context(c, constant_vals, count, packed) ⇒ OpaqueValue

  Create an anonymous ConstantStruct with the specified values.

• .const_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_trunc(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_trunc_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_u_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_u_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_ui_to_fp(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_vector(scalar_constant_vals, size) ⇒ OpaqueValue

  Create a ConstantVector from values.

• .const_xor(lhs_constant, rhs_constant) ⇒ OpaqueValue

  (Not documented).

• .const_z_ext(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .const_z_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

  (Not documented).

• .context_create ⇒ OpaqueContext

  Create a new context.

• .context_dispose(c) ⇒ nil

  Destroy a context instance.

• .copy_string_rep_of_target_data(opaque_target_data) ⇒ String

  Converts target data to a target layout string.

• .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 ⇒ OpaqueBuilder

  (Not documented).

• .create_builder_in_context(c) ⇒ OpaqueBuilder

  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(out_ee, mp, out_error) ⇒ Integer

  Deprecated: Use LLVMCreateExecutionEngineForModule instead.

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

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

• .create_function_pass_manager(mp) ⇒ OpaquePassManager

  Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

• .create_function_pass_manager_for_module(m) ⇒ OpaquePassManager

  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(out_interp, mp, out_error) ⇒ Integer

  Deprecated: Use LLVMCreateInterpreterForModule instead.

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

  (Not documented).

• .create_jit_compiler(out_jit, mp, opt_level, out_error) ⇒ Integer

  Deprecated: Use LLVMCreateJITCompilerForModule instead.

• .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) ⇒ OpaqueMemoryBuffer

  (Not documented).

• .create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name) ⇒ OpaqueMemoryBuffer

  (Not documented).

• .create_memory_buffer_with_stdin(out_mem_buf, out_message) ⇒ Integer

  (Not documented).

• .create_module_provider_for_existing_module(m) ⇒ OpaqueModuleProvider

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

• .create_pass_manager ⇒ OpaquePassManager

  Constructs a new whole-module pass pipeline.

• .create_target_data(string_rep) ⇒ OpaqueTargetData

  Creates target data from a target layout string.

• .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

  Remove a function from its containing module and deletes it.

• .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_memory_buffer(mem_buf) ⇒ nil

  (Not documented).

• .dispose_message(message) ⇒ nil

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

• .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(opaque_target_data) ⇒ nil

  Deallocates a TargetData.

• .dispose_target_machine(t) ⇒ nil

  Dispose the LLVMTargetMachineRef instance generated by LLVMCreateTargetMachine.

• .double_type ⇒ OpaqueType

  (Not documented).

• .double_type_in_context(c) ⇒ OpaqueType

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

• .dump_module(m) ⇒ nil

  Dump a representation of a module to stderr.

• .dump_value(val) ⇒ nil

  Dump a representation of a value to stderr.

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

  Computes the structure element that contains the byte offset for a target.

• .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 ⇒ OpaqueType

  (Not documented).

• .float_type_in_context(c) ⇒ OpaqueType

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

• .fp128_type ⇒ OpaqueType

  (Not documented).

• .fp128_type_in_context(c) ⇒ OpaqueType

  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) ⇒ OpaqueType

  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(global) ⇒ Integer

  (Not documented).

• .get_array_length(array_ty) ⇒ Integer

  Obtain the length of an array type.

• .get_attribute(arg) ⇒ Symbol from _enum_attribute_

  Get an attribute from a function argument.

• .get_basic_block_parent(bb) ⇒ OpaqueValue

  Obtain the function to which a basic block belongs.

• .get_basic_block_terminator(bb) ⇒ OpaqueValue

  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_module_in_context(context_ref, mem_buf, out_m, out_message) ⇒ Integer

  Reads a module from the specified path, returning via the OutMP parameter a module provider which performs lazy deserialization.

• .get_bitcode_module_provider(mem_buf, out_mp, out_message) ⇒ Integer

  Deprecated: Use LLVMGetBitcodeModule instead.

• .get_bitcode_module_provider_in_context(context_ref, mem_buf, out_mp, out_message) ⇒ Integer

  Deprecated: Use LLVMGetBitcodeModuleInContext instead.

• .get_buffer_size(mem_buf) ⇒ Integer

  (Not documented).

• .get_buffer_start(mem_buf) ⇒ String

  (Not documented).

• .get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

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

• .get_current_debug_location(builder) ⇒ OpaqueValue

  (Not documented).

• .get_data_layout(m) ⇒ String

  Obtain the data layout for a module.

• .get_element_type(ty) ⇒ OpaqueType

  Obtain the type of elements within a sequential type.

• .get_entry_basic_block(fn) ⇒ OpaqueBasicBlock

  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_first_basic_block(fn) ⇒ OpaqueBasicBlock

  Obtain the first basic block in a function.

• .get_first_function(m) ⇒ OpaqueValue

  Obtain an iterator to the first Function in a Module.

• .get_first_global(m) ⇒ OpaqueValue

  (Not documented).

• .get_first_instruction(bb) ⇒ OpaqueValue

  Obtain the first instruction in a basic block.

• .get_first_param(fn) ⇒ OpaqueValue

  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) ⇒ OpaqueUse

  Obtain the first use of a value.

• .get_function_attr(fn) ⇒ Symbol from _enum_attribute_

  Obtain an attribute from a function.

• .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 ⇒ OpaqueContext

  Obtain the global context instance.

• .get_global_parent(global) ⇒ OpaqueModule

  This group contains functions that operate on global values.

• .get_global_pass_registry ⇒ OpaquePassRegistry

  Return the global pass registry, for use with initialization functions.

• .get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

  Obtain the predicate of an instruction.

• .get_incoming_block(phi_node, index) ⇒ OpaqueBasicBlock

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

• .get_incoming_value(phi_node, index) ⇒ OpaqueValue

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

• .get_initializer(global_var) ⇒ OpaqueValue

  (Not documented).

• .get_insert_block(builder) ⇒ OpaqueBasicBlock

  (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) ⇒ OpaqueBasicBlock

  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) ⇒ OpaqueBasicBlock

  Obtain the last basic block in a function.

• .get_last_function(m) ⇒ OpaqueValue

  Obtain an iterator to the last Function in a Module.

• .get_last_global(m) ⇒ OpaqueValue

  (Not documented).

• .get_last_instruction(bb) ⇒ OpaqueValue

  Obtain the last instruction in a basic block.

• .get_last_param(fn) ⇒ OpaqueValue

  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) ⇒ OpaqueValue

  Return metadata associated with an instruction value.

• .get_module_context(m) ⇒ OpaqueContext

  Obtain the context to which this module is associated.

• .get_named_function(m, name) ⇒ OpaqueValue

  Obtain a Function value from a Module by its name.

• .get_named_global(m, name) ⇒ OpaqueValue

  (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) ⇒ OpaqueBasicBlock

  Advance a basic block iterator.

• .get_next_function(fn) ⇒ OpaqueValue

  Advance a Function iterator to the next Function.

• .get_next_global(global_var) ⇒ OpaqueValue

  (Not documented).

• .get_next_instruction(inst) ⇒ OpaqueValue

  Obtain the instruction that occurs after the one specified.

• .get_next_param(arg) ⇒ OpaqueValue

  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) ⇒ OpaqueUse

  Obtain the next use of a value.

• .get_num_operands(val) ⇒ Integer

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

• .get_operand(val, index) ⇒ OpaqueValue

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

• .get_param(fn, index) ⇒ OpaqueValue

  Obtain the parameter at the specified index.

• .get_param_parent(inst) ⇒ OpaqueValue

  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_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) ⇒ OpaqueBasicBlock

  Go backwards in a basic block iterator.

• .get_previous_function(fn) ⇒ OpaqueValue

  Decrement a Function iterator to the previous Function.

• .get_previous_global(global_var) ⇒ OpaqueValue

  (Not documented).

• .get_previous_instruction(inst) ⇒ OpaqueValue

  Obtain the instruction that occurred before this one.

• .get_previous_param(arg) ⇒ OpaqueValue

  Obtain the previous parameter to a function.

• .get_return_type(function_ty) ⇒ OpaqueType

  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_switch_default_dest(switch_instr) ⇒ OpaqueBasicBlock

  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_machine_cpu(t) ⇒ String

  Returns the cpu used creating this target machine.

• .get_target_machine_data(t) ⇒ OpaqueTargetData

  Returns the llvm::DataLayout used for this llvm:TargetMachine.

• .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) ⇒ OpaqueType

  Obtain a Type from a module by its registered name.

• .get_type_context(ty) ⇒ OpaqueContext

  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) ⇒ OpaqueValue

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

• .get_used_value(u) ⇒ OpaqueValue

  Obtain the value this use corresponds to.

• .get_user(u) ⇒ OpaqueValue

  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 ⇒ OpaqueType

  Obtain a floating point type from the global context.

• .half_type_in_context(c) ⇒ OpaqueType

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

• .has_metadata(val) ⇒ Integer

  Determine whether an instruction has any metadata attached.

• .initialize_all_asm_parsers ⇒ nil

  LLVMInitializeAllAsmParsers - The main program should call this function if it wants all asm parsers that LLVM is configured to support, to make them available via the TargetRegistry.

• .initialize_all_asm_printers ⇒ nil

  LLVMInitializeAllAsmPrinters - The main program should call this function if it wants all asm printers that LLVM is configured to support, to make them available via the TargetRegistry.

• .initialize_all_disassemblers ⇒ nil

  LLVMInitializeAllDisassemblers - The main program should call this function if it wants all disassemblers that LLVM is configured to support, to make them available via the TargetRegistry.

• .initialize_all_target_infos ⇒ nil

  (Not documented).

• .initialize_all_target_m_cs ⇒ nil

  LLVMInitializeAllTargetMCs - The main program should call this function if it wants access to all available target MC that LLVM is configured to support.

• .initialize_all_targets ⇒ nil

  LLVMInitializeAllTargets - The main program should call this function if it wants to link in all available targets that LLVM is configured to support.

• .initialize_core(r) ⇒ nil

  @}.

• .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_target ⇒ Integer

  LLVMInitializeNativeTarget - The main program should call this function to initialize the native target corresponding to the host.

• .insert_basic_block(insert_before_bb, name) ⇒ OpaqueBasicBlock

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

• .insert_basic_block_in_context(c, bb, name) ⇒ OpaqueBasicBlock

  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_erase_from_parent(inst) ⇒ nil

  Remove and delete an instruction.

• .int16_type ⇒ OpaqueType

  (Not documented).

• .int16_type_in_context(c) ⇒ OpaqueType

  (Not documented).

• .int1_type ⇒ OpaqueType

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

• .int1_type_in_context(c) ⇒ OpaqueType

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

• .int32_type ⇒ OpaqueType

  (Not documented).

• .int32_type_in_context(c) ⇒ OpaqueType

  (Not documented).

• .int64_type ⇒ OpaqueType

  (Not documented).

• .int64_type_in_context(c) ⇒ OpaqueType

  (Not documented).

• .int8_type ⇒ OpaqueType

  (Not documented).

• .int8_type_in_context(c) ⇒ OpaqueType

  (Not documented).

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

  Returns the integer type that is the same size as a pointer on a target.

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

  Returns the integer type that is the same size as a pointer on a target.

• .int_type(num_bits) ⇒ OpaqueType

  (Not documented).

• .int_type_in_context(c, num_bits) ⇒ OpaqueType

  (Not documented).

• .is_a_alloca_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_argument(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_basic_block(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_binary_operator(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_bit_cast_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_block_address(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_branch_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_call_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_cast_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_cmp_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_aggregate_zero(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_array(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_expr(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_fp(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_int(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_pointer_null(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_struct(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_constant_vector(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_dbg_declare_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_dbg_info_intrinsic(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_extract_element_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_extract_value_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_function(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_get_element_ptr_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_global_alias(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_global_value(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_global_variable(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_indirect_br_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_inline_asm(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_insert_element_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_insert_value_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_instruction(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_int_to_ptr_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_intrinsic_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_invoke_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_landing_pad_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_load_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_mem_cpy_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_mem_intrinsic(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_mem_move_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_mem_set_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_ptr_to_int_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_resume_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_return_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_select_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_shuffle_vector_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_store_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_switch_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_terminator_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_trunc_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_unary_instruction(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_undef_value(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_unreachable_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_a_user(val) ⇒ OpaqueValue

  (Not documented).

• .is_af_cmp_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_afp_ext_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_afp_to_si_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_afp_to_ui_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_afp_trunc_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_ai_cmp_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_amd_node(val) ⇒ OpaqueValue

  (Not documented).

• .is_amd_string(val) ⇒ OpaqueValue

  (Not documented).

• .is_aphi_node(val) ⇒ OpaqueValue

  (Not documented).

• .is_as_ext_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_asi_to_fp_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_aui_to_fp_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_ava_arg_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_az_ext_inst(val) ⇒ OpaqueValue

  (Not documented).

• .is_constant(val) ⇒ Integer

  Determine whether the specified constant instance is constant.

• .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_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) ⇒ Integer

  Determine whether a structure is opaque.

• .is_packed_struct(struct_ty) ⇒ Integer

  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 ⇒ OpaqueType

  (Not documented).

• .label_type_in_context(c) ⇒ OpaqueType

  Create a label type in a context.

• .link_in_interpreter ⇒ nil

  (Not documented).

• .link_in_jit ⇒ nil

  (Not documented).

• .link_in_mcjit ⇒ nil

  (Not documented).

• .link_modules(dest, src, mode, out_message) ⇒ Integer

  Links the source module into the destination module, taking ownership of the source module away from the caller.

• .md_node(vals, count) ⇒ OpaqueValue

  Obtain a MDNode value from the global context.

• .md_node_in_context(c, vals, count) ⇒ OpaqueValue

  Obtain a MDNode value from a context.

• .md_string(str, s_len) ⇒ OpaqueValue

  Obtain a MDString value from the global context.

• .md_string_in_context(c, str, s_len) ⇒ OpaqueValue

  Obtain a MDString value from a context.

• .module_create_with_name(module_id) ⇒ OpaqueModule

  Create a new, empty module in the global context.

• .module_create_with_name_in_context(module_id, c) ⇒ OpaqueModule

  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(opaque_target_data, struct_ty, element) ⇒ Integer

  Computes the byte offset of the indexed struct element for a target.

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

  (Not documented).

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

  (Not documented).

• .pass_manager_builder_create ⇒ OpaquePassManagerBuilder

  See llvm::PassManagerBuilder.

• .pass_manager_builder_dispose(pmb) ⇒ nil

  (Not documented).

• .pass_manager_builder_populate_function_pass_manager(pmb, pm) ⇒ nil

  See llvm::PassManagerBuilder::populateFunctionPassManager.

• .pass_manager_builder_populate_lto_pass_manager(pmb, pm, internalize, run_inliner) ⇒ nil

  See llvm::PassManagerBuilder::populateLTOPassManager.

• .pass_manager_builder_populate_module_pass_manager(pmb, pm) ⇒ nil

  See llvm::PassManagerBuilder::populateModulePassManager.

• .pass_manager_builder_set_disable_simplify_lib_calls(pmb, value) ⇒ nil

  See llvm::PassManagerBuilder::DisableSimplifyLibCalls.

• .pass_manager_builder_set_disable_unit_at_a_time(pmb, value) ⇒ nil

  See llvm::PassManagerBuilder::DisableUnitAtATime.

• .pass_manager_builder_set_disable_unroll_loops(pmb, value) ⇒ nil

  See llvm::PassManagerBuilder::DisableUnrollLoops.

• .pass_manager_builder_set_opt_level(pmb, opt_level) ⇒ nil

  See llvm::PassManagerBuilder::OptLevel.

• .pass_manager_builder_set_size_level(pmb, size_level) ⇒ nil

  See llvm::PassManagerBuilder::SizeLevel.

• .pass_manager_builder_use_inliner_with_threshold(pmb, threshold) ⇒ nil

  See llvm::PassManagerBuilder::Inliner.

• .pointer_size(opaque_target_data) ⇒ Integer

  Returns the pointer size in bytes for a target.

• .pointer_size_for_as(opaque_target_data, as) ⇒ Integer

  Returns the pointer size in bytes for a target for a specified address space.

• .pointer_type(element_type, address_space) ⇒ OpaqueType

  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 ⇒ OpaqueType

  (Not documented).

• .ppcfp128_type_in_context(c) ⇒ OpaqueType

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

• .preferred_alignment_of_global(opaque_target_data, global_var) ⇒ Integer

  Computes the preferred alignment of a global variable in bytes for a target.

• .preferred_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

  Computes the preferred alignment of a type in bytes for a target.

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

  Print a representation of a module to a file.

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

  (Not documented).

• .remove_attribute(arg, pa) ⇒ nil

  Remove an attribute from a function argument.

• .remove_basic_block_from_parent(bb) ⇒ nil

  Remove a basic block from a function.

• .remove_function_attr(fn, pa) ⇒ nil

  Remove an attribute from a function.

• .remove_instr_attribute(instr, index, attribute) ⇒ nil

  (Not documented).

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

  (Not documented).

• .remove_module_provider(ee, mp, out_mod, out_error) ⇒ Integer

  Deprecated: Use LLVMRemoveModule instead.

• .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_static_constructors(ee) ⇒ nil

  (Not documented).

• .run_static_destructors(ee) ⇒ nil

  (Not documented).

• .set_alignment(global, bytes) ⇒ nil

  (Not documented).

• .set_cleanup(landing_pad, val) ⇒ nil

  Set the ‘cleanup’ flag in the landingpad instruction.

• .set_current_debug_location(builder, l) ⇒ nil

  Metadata.

• .set_data_layout(m, triple) ⇒ nil

  Set the data layout for a module.

• .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_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_param_alignment(arg, align) ⇒ nil

  Set the alignment for a function parameter.

• .set_section(global, section) ⇒ nil

  (Not documented).

• .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_thread_local(global_var, is_thread_local) ⇒ nil

  (Not documented).

• .set_thread_local_mode(global_var, mode) ⇒ 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

  Deallocate and destroy all ManagedStatic variables.

• .size_of(ty) ⇒ OpaqueValue

  (Not documented).

• .size_of_type_in_bits(opaque_target_data, type_ref) ⇒ Integer

  Computes the size of a type in bytes for a target.

• .start_multithreaded ⇒ Integer

  Allocate and initialize structures needed to make LLVM safe for multithreading.

• .stop_multithreaded ⇒ nil

  Deallocate structures necessary to make LLVM safe for multithreading.

• .store_size_of_type(opaque_target_data, type_ref) ⇒ Integer

  Computes the storage size of a type in bytes for a target.

• .struct_create_named(c, name) ⇒ OpaqueType

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

• .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) ⇒ OpaqueType

  Create a new structure type in the global context.

• .struct_type_in_context(c, element_types, element_count, packed) ⇒ OpaqueType

  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) ⇒ OpaqueType

  Obtain the type of a value.

• .value_as_basic_block(val) ⇒ OpaqueBasicBlock

  Convert a LLVMValueRef to a LLVMBasicBlockRef instance.

• .value_is_basic_block(val) ⇒ Integer

  Determine whether a LLVMValueRef is itself a basic block.

• .vector_type(element_type, element_count) ⇒ OpaqueType

  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 ⇒ OpaqueType

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

• .void_type_in_context(c) ⇒ OpaqueType

  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

  (Not documented).

• .write_bitcode_to_file_handle(m, handle) ⇒ Integer

  Deprecated for LLVMWriteBitcodeToFD.

• .x86fp80_type ⇒ OpaqueType

  (Not documented).

• .x86fp80_type_in_context(c) ⇒ OpaqueType

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

• .x86mmx_type ⇒ OpaqueType

  (Not documented).

• .x86mmx_type_in_context(c) ⇒ OpaqueType

  Create a X86 MMX type in a context.

Class Method Details

._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.

Returns:

• (Symbol)

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

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

._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.rb', line 755

enum :atomic_rmw_bin_op, [
  :xchg, 0,
  :add, 1,
  :sub, 2,
  :and_, 3,
  :nand, 4,
  :or_, 5,
  :xor, 6,
  :max, 7,
  :min, 8,
  :u_max, 9,
  :u_min, 10
]

._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

Returns:

• (Symbol)

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

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
]

._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 28

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

:x86_stdcall

:x86_fastcall

Returns:

• (Symbol)

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

enum :call_conv, [
  :c, 0,
  :fast, 8,
  :cold, 9,
  :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 417

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 343

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 395

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

._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 563

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 649

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

< Like LinkOnceODR, but possibly hidden.

: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

< Function to be imported from DLL

:external_weak

< Function to be accessible from DLL

: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 466

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

(Not documented)

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

Options:

:linker_destroy_source

Returns:

• (Symbol)

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

enum :linker_mode, [
  :linker_destroy_source, 0
]

._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

: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

Returns:

• (Symbol)

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

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,
  :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
]

._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 617

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 367

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 673

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

Returns:

• (Symbol)

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

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
]

._enum_verifier_failure_action_ ⇒ Symbol

(Not documented)

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 30

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 501

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

.abi_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

Computes the ABI alignment of a type in bytes for a target.

See the method llvm::DataLayout::getTypeABISize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

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

.abi_size_of_type(opaque_target_data, type_ref) ⇒ Integer

Computes the ABI size of a type in bytes for a target.

See the method llvm::DataLayout::getTypeAllocSize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

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

.add_aggressive_dce_pass(pm) ⇒ nil

(Not documented)

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 21

attach_function :add_aggressive_dce_pass, :LLVMAddAggressiveDCEPass, [:pointer], :void

.add_alias(m, ty, aliasee, name) ⇒ OpaqueValue

This group contains function that operate on global alias values.

@{

Parameters:

• m (OpaqueModule)
• ty (OpaqueType)
• aliasee (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::GlobalAlias

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

attach_function :add_alias, :LLVMAddAlias, [OpaqueModule, OpaqueType, OpaqueValue, :string], OpaqueValue

.add_always_inliner_pass(pm) ⇒ nil

See llvm::createAlwaysInlinerPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 61

attach_function :add_always_inliner_pass, :LLVMAddAlwaysInlinerPass, [:pointer], :void

.add_argument_promotion_pass(pm) ⇒ nil

(Not documented)

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 21

attach_function :add_argument_promotion_pass, :LLVMAddArgumentPromotionPass, [:pointer], :void

.add_attribute(arg, pa) ⇒ nil

Add an attribute to a function argument.

Parameters:

• arg (OpaqueValue)
• pa (Symbol from _enum_attribute_)

Returns:

• (nil)

See Also:

• llvmllvm::Argumentllvm::Argument::addAttr()

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

attach_function :add_attribute, :LLVMAddAttribute, [OpaqueValue, :attribute], :void

.add_basic_alias_analysis_pass(pm) ⇒ nil

See llvm::createBasicAliasAnalysisPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 254

attach_function :add_basic_alias_analysis_pass, :LLVMAddBasicAliasAnalysisPass, [:pointer], :void

.add_bb_vectorize_pass(pm) ⇒ nil

(Not documented)

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/vectorize_ffi.rb', line 21

attach_function :add_bb_vectorize_pass, :LLVMAddBBVectorizePass, [:pointer], :void

.add_case(switch, on_val, dest) ⇒ nil

Add a case to the switch instruction

Parameters:

• switch (OpaqueValue)
• on_val (OpaqueValue)
• dest (OpaqueBasicBlock)

Returns:

• (nil)

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

attach_function :add_case, :LLVMAddCase, [OpaqueValue, OpaqueValue, OpaqueBasicBlock], :void

.add_cfg_simplification_pass(pm) ⇒ nil

See llvm::createCFGSimplificationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 29

attach_function :add_cfg_simplification_pass, :LLVMAddCFGSimplificationPass, [:pointer], :void

.add_clause(landing_pad, clause_val) ⇒ nil

Add a catch or filter clause to the landingpad instruction

Parameters:

• landing_pad (OpaqueValue)
• clause_val (OpaqueValue)

Returns:

• (nil)

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

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

.add_constant_merge_pass(pm) ⇒ nil

See llvm::createConstantMergePass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 29

attach_function :add_constant_merge_pass, :LLVMAddConstantMergePass, [:pointer], :void

.add_constant_propagation_pass(pm) ⇒ nil

See llvm::createConstantPropagationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 198

attach_function :add_constant_propagation_pass, :LLVMAddConstantPropagationPass, [:pointer], :void

.add_correlated_value_propagation_pass(pm) ⇒ nil

See llvm::createCorrelatedValuePropagationPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 222

attach_function :add_correlated_value_propagation_pass, :LLVMAddCorrelatedValuePropagationPass, [:pointer], :void

.add_dead_arg_elimination_pass(pm) ⇒ nil

See llvm::createDeadArgEliminationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 37

attach_function :add_dead_arg_elimination_pass, :LLVMAddDeadArgEliminationPass, [:pointer], :void

.add_dead_store_elimination_pass(pm) ⇒ nil

See llvm::createDeadStoreEliminationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 37

attach_function :add_dead_store_elimination_pass, :LLVMAddDeadStoreEliminationPass, [:pointer], :void

.add_demote_memory_to_register_pass(pm) ⇒ nil

See llvm::demotePromoteMemoryToRegisterPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 206

attach_function :add_demote_memory_to_register_pass, :LLVMAddDemoteMemoryToRegisterPass, [:pointer], :void

.add_destination(indirect_br, dest) ⇒ nil

Add a destination to the indirectbr instruction

Parameters:

• indirect_br (OpaqueValue)
• dest (OpaqueBasicBlock)

Returns:

• (nil)

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

attach_function :add_destination, :LLVMAddDestination, [OpaqueValue, OpaqueBasicBlock], :void

.add_early_cse_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 230

attach_function :add_early_cse_pass, :LLVMAddEarlyCSEPass, [:pointer], :void

.add_function(m, name, function_ty) ⇒ OpaqueValue

Add a function to a module under a specified name.

Parameters:

• m (OpaqueModule)
• name (String)
• function_ty (OpaqueType)

Returns:

• (OpaqueValue)

See Also:

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

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

attach_function :add_function, :LLVMAddFunction, [OpaqueModule, :string, OpaqueType], OpaqueValue

.add_function_attr(fn, pa) ⇒ nil

Add an attribute to a function.

Parameters:

• fn (OpaqueValue)
• pa (Symbol from _enum_attribute_)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::addAttribute()

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

attach_function :add_function_attr, :LLVMAddFunctionAttr, [OpaqueValue, :attribute], :void

.add_function_attrs_pass(pm) ⇒ nil

See llvm::createFunctionAttrsPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 45

attach_function :add_function_attrs_pass, :LLVMAddFunctionAttrsPass, [:pointer], :void

.add_function_inlining_pass(pm) ⇒ nil

See llvm::createFunctionInliningPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 53

attach_function :add_function_inlining_pass, :LLVMAddFunctionInliningPass, [:pointer], :void

.add_global(m, ty, name) ⇒ OpaqueValue

This group contains functions that operate on global variable values.

@{

Parameters:

• m (OpaqueModule)
• ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::GlobalVariable

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

attach_function :add_global, :LLVMAddGlobal, [OpaqueModule, OpaqueType, :string], OpaqueValue

.add_global_dce_pass(pm) ⇒ nil

See llvm::createGlobalDCEPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 69

attach_function :add_global_dce_pass, :LLVMAddGlobalDCEPass, [:pointer], :void

.add_global_in_address_space(m, ty, name, address_space) ⇒ OpaqueValue

(Not documented)

Parameters:

• m (OpaqueModule)
• ty (OpaqueType)
• name (String)
• address_space (Integer)

Returns:

• (OpaqueValue)

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

attach_function :add_global_in_address_space, :LLVMAddGlobalInAddressSpace, [OpaqueModule, OpaqueType, :string, :uint], OpaqueValue

.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 361

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

.add_global_optimizer_pass(pm) ⇒ nil

See llvm::createGlobalOptimizerPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 77

attach_function :add_global_optimizer_pass, :LLVMAddGlobalOptimizerPass, [:pointer], :void

.add_gvn_pass(pm) ⇒ nil

See llvm::createGVNPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 45

attach_function :add_gvn_pass, :LLVMAddGVNPass, [: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 (OpaqueValue)
• incoming_values (FFI::Pointer(*ValueRef))
• incoming_blocks (FFI::Pointer(*BasicBlockRef))
• count (Integer)

Returns:

• (nil)

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

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

.add_ind_var_simplify_pass(pm) ⇒ nil

See llvm::createIndVarSimplifyPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 53

attach_function :add_ind_var_simplify_pass, :LLVMAddIndVarSimplifyPass, [:pointer], :void

.add_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

• instr (OpaqueValue)
• index (Integer)
• attribute (Symbol from _enum_attribute_)

Returns:

• (nil)

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

attach_function :add_instr_attribute, :LLVMAddInstrAttribute, [OpaqueValue, :uint, :attribute], :void

.add_instruction_combining_pass(pm) ⇒ nil

See llvm::createInstructionCombiningPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 61

attach_function :add_instruction_combining_pass, :LLVMAddInstructionCombiningPass, [:pointer], :void

.add_internalize_pass(pass_manager_ref, all_but_main) ⇒ nil

See llvm::createInternalizePass function.

Parameters:

• pass_manager_ref (FFI::Pointer(PassManagerRef))
• all_but_main (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 110

attach_function :add_internalize_pass, :LLVMAddInternalizePass, [:pointer, :uint], :void

.add_ip_constant_propagation_pass(pm) ⇒ nil

See llvm::createIPConstantPropagationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 85

attach_function :add_ip_constant_propagation_pass, :LLVMAddIPConstantPropagationPass, [:pointer], :void

.add_ipsccp_pass(pm) ⇒ nil

See llvm::createIPSCCPPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 101

attach_function :add_ipsccp_pass, :LLVMAddIPSCCPPass, [:pointer], :void

.add_jump_threading_pass(pm) ⇒ nil

See llvm::createJumpThreadingPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 69

attach_function :add_jump_threading_pass, :LLVMAddJumpThreadingPass, [:pointer], :void

.add_licm_pass(pm) ⇒ nil

See llvm::createLICMPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 77

attach_function :add_licm_pass, :LLVMAddLICMPass, [:pointer], :void

.add_loop_deletion_pass(pm) ⇒ nil

See llvm::createLoopDeletionPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 85

attach_function :add_loop_deletion_pass, :LLVMAddLoopDeletionPass, [:pointer], :void

.add_loop_idiom_pass(pm) ⇒ nil

See llvm::createLoopIdiomPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 93

attach_function :add_loop_idiom_pass, :LLVMAddLoopIdiomPass, [:pointer], :void

.add_loop_rotate_pass(pm) ⇒ nil

See llvm::createLoopRotatePass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 101

attach_function :add_loop_rotate_pass, :LLVMAddLoopRotatePass, [:pointer], :void

.add_loop_unroll_pass(pm) ⇒ nil

See llvm::createLoopUnrollPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 109

attach_function :add_loop_unroll_pass, :LLVMAddLoopUnrollPass, [:pointer], :void

.add_loop_unswitch_pass(pm) ⇒ nil

See llvm::createLoopUnswitchPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 117

attach_function :add_loop_unswitch_pass, :LLVMAddLoopUnswitchPass, [:pointer], :void

.add_loop_vectorize_pass(pm) ⇒ nil

See llvm::createLoopVectorizePass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/vectorize_ffi.rb', line 29

attach_function :add_loop_vectorize_pass, :LLVMAddLoopVectorizePass, [:pointer], :void

.add_lower_expect_intrinsic_pass(pm) ⇒ nil

See llvm::createLowerExpectIntrinsicPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 238

attach_function :add_lower_expect_intrinsic_pass, :LLVMAddLowerExpectIntrinsicPass, [:pointer], :void

.add_mem_cpy_opt_pass(pm) ⇒ nil

See llvm::createMemCpyOptPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 125

attach_function :add_mem_cpy_opt_pass, :LLVMAddMemCpyOptPass, [:pointer], :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 293

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

.add_module_provider(ee, mp) ⇒ nil

Deprecated: Use LLVMAddModule instead.

Parameters:

• ee (OpaqueExecutionEngine)
• mp (FFI::Pointer(ModuleProviderRef))

Returns:

• (nil)

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

attach_function :add_module_provider, :LLVMAddModuleProvider, [OpaqueExecutionEngine, :pointer], :void

.add_named_metadata_operand(m, name, val) ⇒ nil

Add an operand to named metadata.

Parameters:

• m (OpaqueModule)
• name (String)
• val (OpaqueValue)

Returns:

• (nil)

See Also:

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

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

attach_function :add_named_metadata_operand, :LLVMAddNamedMetadataOperand, [OpaqueModule, :string, OpaqueValue], :void

.add_promote_memory_to_register_pass(pm) ⇒ nil

See llvm::createPromoteMemoryToRegisterPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 133

attach_function :add_promote_memory_to_register_pass, :LLVMAddPromoteMemoryToRegisterPass, [:pointer], :void

.add_prune_eh_pass(pm) ⇒ nil

See llvm::createPruneEHPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 93

attach_function :add_prune_eh_pass, :LLVMAddPruneEHPass, [:pointer], :void

.add_reassociate_pass(pm) ⇒ nil

See llvm::createReassociatePass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 141

attach_function :add_reassociate_pass, :LLVMAddReassociatePass, [:pointer], :void

.add_scalar_repl_aggregates_pass(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 157

attach_function :add_scalar_repl_aggregates_pass, :LLVMAddScalarReplAggregatesPass, [:pointer], :void

.add_scalar_repl_aggregates_pass_ssa(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 165

attach_function :add_scalar_repl_aggregates_pass_ssa, :LLVMAddScalarReplAggregatesPassSSA, [:pointer], :void

.add_scalar_repl_aggregates_pass_with_threshold(pm, threshold) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))
• threshold (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 174

attach_function :add_scalar_repl_aggregates_pass_with_threshold, :LLVMAddScalarReplAggregatesPassWithThreshold, [:pointer, :int], :void

.add_sccp_pass(pm) ⇒ nil

See llvm::createSCCPPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 149

attach_function :add_sccp_pass, :LLVMAddSCCPPass, [:pointer], :void

.add_simplify_lib_calls_pass(pm) ⇒ nil

See llvm::createSimplifyLibCallsPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 182

attach_function :add_simplify_lib_calls_pass, :LLVMAddSimplifyLibCallsPass, [:pointer], :void

.add_slp_vectorize_pass(pm) ⇒ nil

See llvm::createSLPVectorizerPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/vectorize_ffi.rb', line 37

attach_function :add_slp_vectorize_pass, :LLVMAddSLPVectorizePass, [:pointer], :void

.add_strip_dead_prototypes_pass(pm) ⇒ nil

See llvm::createStripDeadPrototypesPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 118

attach_function :add_strip_dead_prototypes_pass, :LLVMAddStripDeadPrototypesPass, [:pointer], :void

.add_strip_symbols_pass(pm) ⇒ nil

See llvm::createStripSymbolsPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/ipo_ffi.rb', line 126

attach_function :add_strip_symbols_pass, :LLVMAddStripSymbolsPass, [:pointer], :void

.add_tail_call_elimination_pass(pm) ⇒ nil

See llvm::createTailCallEliminationPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 190

attach_function :add_tail_call_elimination_pass, :LLVMAddTailCallEliminationPass, [:pointer], :void

.add_target_data(opaque_target_data, pass_manager_ref) ⇒ nil

Adds target data information to a pass manager. This does not take ownership

of the target data.
See the method llvm::PassManagerBase::add.

Parameters:

• opaque_target_data (OpaqueTargetData)
• pass_manager_ref (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

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

attach_function :add_target_data, :LLVMAddTargetData, [OpaqueTargetData, :pointer], :void

.add_target_dependent_function_attr(fn, a, v) ⇒ nil

Add a target-dependent attribute to a fuction

Parameters:

• fn (OpaqueValue)
• a (String)
• v (String)

Returns:

• (nil)

See Also:

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

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

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

.add_target_library_info(opaque_target_library_infot_data, pass_manager_ref) ⇒ nil

Adds target library information to a pass manager. This does not take

ownership of the target library info.
See the method llvm::PassManagerBase::add.

Parameters:

• opaque_target_library_infot_data (OpaqueTargetLibraryInfotData)
• pass_manager_ref (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

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

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

.add_type_based_alias_analysis_pass(pm) ⇒ nil

See llvm::createTypeBasedAliasAnalysisPass function

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 246

attach_function :add_type_based_alias_analysis_pass, :LLVMAddTypeBasedAliasAnalysisPass, [:pointer], :void

.add_verifier_pass(pm) ⇒ nil

See llvm::createVerifierPass function.

Parameters:

• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/scalar_ffi.rb', line 214

attach_function :add_verifier_pass, :LLVMAddVerifierPass, [:pointer], :void

.align_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :align_of, :LLVMAlignOf, [OpaqueType], OpaqueValue

.append_basic_block(fn, name) ⇒ OpaqueBasicBlock

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

Parameters:

• fn (OpaqueValue)
• name (String)

Returns:

• (OpaqueBasicBlock)

See Also:

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

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

attach_function :append_basic_block, :LLVMAppendBasicBlock, [OpaqueValue, :string], OpaqueBasicBlock

.append_basic_block_in_context(c, fn, name) ⇒ OpaqueBasicBlock

Append a basic block to the end of a function.

Parameters:

• c (OpaqueContext)
• fn (OpaqueValue)
• name (String)

Returns:

• (OpaqueBasicBlock)

See Also:

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

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

attach_function :append_basic_block_in_context, :LLVMAppendBasicBlockInContext, [OpaqueContext, OpaqueValue, :string], OpaqueBasicBlock

.array_type(element_type, element_count) ⇒ OpaqueType

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 (OpaqueType)
• element_count (Integer)

Returns:

• (OpaqueType)

See Also:

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

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

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

.attach_function(name, *_) ⇒ Object

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

def self.attach_function(name, *_)
  begin; super; rescue FFI::NotFoundError => e
    (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
  end
end

.basic_block_as_value(bb) ⇒ OpaqueValue

Convert a basic block instance to a value type.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :basic_block_as_value, :LLVMBasicBlockAsValue, [OpaqueBasicBlock], OpaqueValue

.block_address(f, bb) ⇒ OpaqueValue

(Not documented)

Parameters:

• f (OpaqueValue)
• bb (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :block_address, :LLVMBlockAddress, [OpaqueValue, OpaqueBasicBlock], OpaqueValue

.build_a_shr(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_a_shr, :LLVMBuildAShr, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

Arithmetic

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_add, :LLVMBuildAdd, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_aggregate_ret(opaque_builder, ret_vals, n) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• ret_vals (FFI::Pointer(*ValueRef))
• n (Integer)

Returns:

• (OpaqueValue)

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

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

.build_alloca(opaque_builder, ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_alloca, :LLVMBuildAlloca, [OpaqueBuilder, OpaqueType, :string], OpaqueValue

.build_and(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_and, :LLVMBuildAnd, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_array_alloca(opaque_builder, ty, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• ty (OpaqueType)
• val (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_array_alloca, :LLVMBuildArrayAlloca, [OpaqueBuilder, OpaqueType, OpaqueValue, :string], OpaqueValue

.build_array_malloc(opaque_builder, ty, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• ty (OpaqueType)
• val (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_array_malloc, :LLVMBuildArrayMalloc, [OpaqueBuilder, OpaqueType, OpaqueValue, :string], OpaqueValue

.build_atomic_rmw(b, op, ptr, val, ordering, single_thread) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• op (Symbol from _enum_atomic_rmw_bin_op_)
• ptr (OpaqueValue)
• val (OpaqueValue)
• ordering (Symbol from _enum_atomic_ordering_)
• single_thread (Integer)

Returns:

• (OpaqueValue)

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

attach_function :build_atomic_rmw, :LLVMBuildAtomicRMW, [OpaqueBuilder, :atomic_rmw_bin_op, OpaqueValue, OpaqueValue, :atomic_ordering, :int], OpaqueValue

.build_bin_op(b, op, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• op (Symbol from _enum_opcode_)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_bin_op, :LLVMBuildBinOp, [OpaqueBuilder, :opcode, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_bit_cast, :LLVMBuildBitCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_br(opaque_builder, dest) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• dest (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :build_br, :LLVMBuildBr, [OpaqueBuilder, OpaqueBasicBlock], OpaqueValue

.build_call(opaque_builder, fn, args, num_args, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• fn (OpaqueValue)
• args (FFI::Pointer(*ValueRef))
• num_args (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_call, :LLVMBuildCall, [OpaqueBuilder, OpaqueValue, :pointer, :uint, :string], OpaqueValue

.build_cast(b, op, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• op (Symbol from _enum_opcode_)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_cast, :LLVMBuildCast, [OpaqueBuilder, :opcode, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_cond_br(opaque_builder, if_, then_, else_) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• if_ (OpaqueValue)
• then_ (OpaqueBasicBlock)
• else_ (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :build_cond_br, :LLVMBuildCondBr, [OpaqueBuilder, OpaqueValue, OpaqueBasicBlock, OpaqueBasicBlock], OpaqueValue

.build_exact_s_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_exact_s_div, :LLVMBuildExactSDiv, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_extract_element(opaque_builder, vec_val, index, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• vec_val (OpaqueValue)
• index (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_extract_element, :LLVMBuildExtractElement, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_extract_value(opaque_builder, agg_val, index, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• agg_val (OpaqueValue)
• index (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_extract_value, :LLVMBuildExtractValue, [OpaqueBuilder, OpaqueValue, :uint, :string], OpaqueValue

.build_f_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_add, :LLVMBuildFAdd, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_f_cmp(opaque_builder, op, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• op (Symbol from _enum_real_predicate_)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_cmp, :LLVMBuildFCmp, [OpaqueBuilder, :real_predicate, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_f_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_div, :LLVMBuildFDiv, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_f_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_mul, :LLVMBuildFMul, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_f_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_neg, :LLVMBuildFNeg, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_f_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_rem, :LLVMBuildFRem, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_f_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_f_sub, :LLVMBuildFSub, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_fp_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_fp_cast, :LLVMBuildFPCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_fp_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_fp_ext, :LLVMBuildFPExt, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_fp_to_si(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_fp_to_si, :LLVMBuildFPToSI, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_fp_to_ui(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_fp_to_ui, :LLVMBuildFPToUI, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_fp_trunc(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_fp_trunc, :LLVMBuildFPTrunc, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_free(opaque_builder, pointer_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• pointer_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :build_free, :LLVMBuildFree, [OpaqueBuilder, OpaqueValue], OpaqueValue

.build_gep(b, pointer, indices, num_indices, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• pointer (OpaqueValue)
• indices (FFI::Pointer(*ValueRef))
• num_indices (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_gep, :LLVMBuildGEP, [OpaqueBuilder, OpaqueValue, :pointer, :uint, :string], OpaqueValue

.build_global_string(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• str (String)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_global_string, :LLVMBuildGlobalString, [OpaqueBuilder, :string, :string], OpaqueValue

.build_global_string_ptr(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• str (String)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_global_string_ptr, :LLVMBuildGlobalStringPtr, [OpaqueBuilder, :string, :string], OpaqueValue

.build_i_cmp(opaque_builder, op, lhs, rhs, name) ⇒ OpaqueValue

Comparisons

Parameters:

• opaque_builder (OpaqueBuilder)
• op (Symbol from _enum_int_predicate_)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_i_cmp, :LLVMBuildICmp, [OpaqueBuilder, :int_predicate, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_in_bounds_gep(b, pointer, indices, num_indices, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• pointer (OpaqueValue)
• indices (FFI::Pointer(*ValueRef))
• num_indices (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_in_bounds_gep, :LLVMBuildInBoundsGEP, [OpaqueBuilder, OpaqueValue, :pointer, :uint, :string], OpaqueValue

.build_indirect_br(b, addr, num_dests) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• addr (OpaqueValue)
• num_dests (Integer)

Returns:

• (OpaqueValue)

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

attach_function :build_indirect_br, :LLVMBuildIndirectBr, [OpaqueBuilder, OpaqueValue, :uint], OpaqueValue

.build_insert_element(opaque_builder, vec_val, elt_val, index, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• vec_val (OpaqueValue)
• elt_val (OpaqueValue)
• index (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_insert_element, :LLVMBuildInsertElement, [OpaqueBuilder, OpaqueValue, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_insert_value(opaque_builder, agg_val, elt_val, index, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• agg_val (OpaqueValue)
• elt_val (OpaqueValue)
• index (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_insert_value, :LLVMBuildInsertValue, [OpaqueBuilder, OpaqueValue, OpaqueValue, :uint, :string], OpaqueValue

.build_int_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_int_cast, :LLVMBuildIntCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_int_to_ptr(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_int_to_ptr, :LLVMBuildIntToPtr, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_invoke(opaque_builder, fn, args, num_args, then_, catch, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• fn (OpaqueValue)
• args (FFI::Pointer(*ValueRef))
• num_args (Integer)
• then_ (OpaqueBasicBlock)
• catch (OpaqueBasicBlock)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_invoke, :LLVMBuildInvoke, [OpaqueBuilder, OpaqueValue, :pointer, :uint, OpaqueBasicBlock, OpaqueBasicBlock, :string], OpaqueValue

.build_is_not_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_is_not_null, :LLVMBuildIsNotNull, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_is_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_is_null, :LLVMBuildIsNull, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_l_shr(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_l_shr, :LLVMBuildLShr, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_landing_pad(b, ty, pers_fn, num_clauses, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• ty (OpaqueType)
• pers_fn (OpaqueValue)
• num_clauses (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_landing_pad, :LLVMBuildLandingPad, [OpaqueBuilder, OpaqueType, OpaqueValue, :uint, :string], OpaqueValue

.build_load(opaque_builder, pointer_val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• pointer_val (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_load, :LLVMBuildLoad, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_malloc(opaque_builder, ty, name) ⇒ OpaqueValue

Memory

Parameters:

• opaque_builder (OpaqueBuilder)
• ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_malloc, :LLVMBuildMalloc, [OpaqueBuilder, OpaqueType, :string], OpaqueValue

.build_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_mul, :LLVMBuildMul, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_neg, :LLVMBuildNeg, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_not(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_not, :LLVMBuildNot, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_nsw_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nsw_add, :LLVMBuildNSWAdd, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_nsw_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nsw_mul, :LLVMBuildNSWMul, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_nsw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• v (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nsw_neg, :LLVMBuildNSWNeg, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_nsw_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nsw_sub, :LLVMBuildNSWSub, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_nuw_add(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nuw_add, :LLVMBuildNUWAdd, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_nuw_mul(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nuw_mul, :LLVMBuildNUWMul, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_nuw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• v (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nuw_neg, :LLVMBuildNUWNeg, [OpaqueBuilder, OpaqueValue, :string], OpaqueValue

.build_nuw_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_nuw_sub, :LLVMBuildNUWSub, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_or(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_or, :LLVMBuildOr, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_phi(opaque_builder, ty, name) ⇒ OpaqueValue

Miscellaneous instructions

Parameters:

• opaque_builder (OpaqueBuilder)
• ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_phi, :LLVMBuildPhi, [OpaqueBuilder, OpaqueType, :string], OpaqueValue

.build_pointer_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_pointer_cast, :LLVMBuildPointerCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_ptr_diff(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_ptr_diff, :LLVMBuildPtrDiff, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_ptr_to_int(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_ptr_to_int, :LLVMBuildPtrToInt, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_resume(b, exn) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• exn (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :build_resume, :LLVMBuildResume, [OpaqueBuilder, OpaqueValue], OpaqueValue

.build_ret(opaque_builder, v) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :build_ret, :LLVMBuildRet, [OpaqueBuilder, OpaqueValue], OpaqueValue

.build_ret_void(opaque_builder) ⇒ OpaqueValue

Terminators

Parameters:

• opaque_builder (OpaqueBuilder)

Returns:

• (OpaqueValue)

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

attach_function :build_ret_void, :LLVMBuildRetVoid, [OpaqueBuilder], OpaqueValue

.build_s_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_s_div, :LLVMBuildSDiv, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_s_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_s_ext, :LLVMBuildSExt, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_s_ext_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_s_ext_or_bit_cast, :LLVMBuildSExtOrBitCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_s_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_s_rem, :LLVMBuildSRem, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_select(opaque_builder, if_, then_, else_, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• if_ (OpaqueValue)
• then_ (OpaqueValue)
• else_ (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_select, :LLVMBuildSelect, [OpaqueBuilder, OpaqueValue, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_shl(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_shl, :LLVMBuildShl, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_shuffle_vector(opaque_builder, v1, v2, mask, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v1 (OpaqueValue)
• v2 (OpaqueValue)
• mask (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_shuffle_vector, :LLVMBuildShuffleVector, [OpaqueBuilder, OpaqueValue, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_si_to_fp(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_si_to_fp, :LLVMBuildSIToFP, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_store(opaque_builder, val, ptr) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• ptr (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :build_store, :LLVMBuildStore, [OpaqueBuilder, OpaqueValue, OpaqueValue], OpaqueValue

.build_struct_gep(b, pointer, idx, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• b (OpaqueBuilder)
• pointer (OpaqueValue)
• idx (Integer)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_struct_gep, :LLVMBuildStructGEP, [OpaqueBuilder, OpaqueValue, :uint, :string], OpaqueValue

.build_sub(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_sub, :LLVMBuildSub, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_switch(opaque_builder, v, else_, num_cases) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• v (OpaqueValue)
• else_ (OpaqueBasicBlock)
• num_cases (Integer)

Returns:

• (OpaqueValue)

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

attach_function :build_switch, :LLVMBuildSwitch, [OpaqueBuilder, OpaqueValue, OpaqueBasicBlock, :uint], OpaqueValue

.build_trunc(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

Casts

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_trunc, :LLVMBuildTrunc, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_trunc_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_trunc_or_bit_cast, :LLVMBuildTruncOrBitCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_u_div(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_u_div, :LLVMBuildUDiv, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_u_rem(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_u_rem, :LLVMBuildURem, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_ui_to_fp(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_ui_to_fp, :LLVMBuildUIToFP, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_unreachable(opaque_builder) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)

Returns:

• (OpaqueValue)

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

attach_function :build_unreachable, :LLVMBuildUnreachable, [OpaqueBuilder], OpaqueValue

.build_va_arg(opaque_builder, list, ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• list (OpaqueValue)
• ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_va_arg, :LLVMBuildVAArg, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_xor(opaque_builder, lhs, rhs, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• lhs (OpaqueValue)
• rhs (OpaqueValue)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_xor, :LLVMBuildXor, [OpaqueBuilder, OpaqueValue, OpaqueValue, :string], OpaqueValue

.build_z_ext(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_z_ext, :LLVMBuildZExt, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_z_ext_or_bit_cast(opaque_builder, val, dest_ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• opaque_builder (OpaqueBuilder)
• val (OpaqueValue)
• dest_ty (OpaqueType)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :build_z_ext_or_bit_cast, :LLVMBuildZExtOrBitCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.byte_order(opaque_target_data) ⇒ Symbol from _enum_byte_ordering_

Returns the byte order of a target, either LLVMBigEndian or

LLVMLittleEndian.
See the method llvm::DataLayout::isLittleEndian.

Parameters:

• opaque_target_data (OpaqueTargetData)

Returns:

• (Symbol from _enum_byte_ordering_)

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

attach_function :byte_order, :LLVMByteOrder, [OpaqueTargetData], :byte_ordering

.call_frame_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

Computes the call frame alignment of a type in bytes for a target.

See the method llvm::DataLayout::getTypeABISize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

attach_function :call_frame_alignment_of_type, :LLVMCallFrameAlignmentOfType, [OpaqueTargetData, :pointer], :uint

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)

Returns:

• (nil)

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

attach_function :clear_insertion_position, :LLVMClearInsertionPosition, [OpaqueBuilder], :void

.const_a_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_a_shr, :LLVMConstAShr, [OpaqueValue, OpaqueValue], OpaqueValue

.const_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_add, :LLVMConstAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_all_ones(ty) ⇒ OpaqueValue

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

This is only valid for integer types.

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Constantllvm::Constant::getAllOnesValue()

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

attach_function :const_all_ones, :LLVMConstAllOnes, [OpaqueType], OpaqueValue

.const_and(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_and, :LLVMConstAnd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_array(element_ty, constant_vals, length) ⇒ OpaqueValue

Create a ConstantArray from values.

Parameters:

• element_ty (OpaqueType)
• constant_vals (FFI::Pointer(*ValueRef))
• length (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantArrayllvm::ConstantArray::get()

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

attach_function :const_array, :LLVMConstArray, [OpaqueType, :pointer, :uint], OpaqueValue

.const_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_bit_cast, :LLVMConstBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_exact_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_exact_s_div, :LLVMConstExactSDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_extract_element(vector_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• vector_constant (OpaqueValue)
• index_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_extract_element, :LLVMConstExtractElement, [OpaqueValue, OpaqueValue], OpaqueValue

.const_extract_value(agg_constant, idx_list, num_idx) ⇒ OpaqueValue

(Not documented)

Parameters:

• agg_constant (OpaqueValue)
• idx_list (FFI::Pointer(*UInt))
• num_idx (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_extract_value, :LLVMConstExtractValue, [OpaqueValue, :pointer, :uint], OpaqueValue

.const_f_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_add, :LLVMConstFAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• predicate (Symbol from _enum_real_predicate_)
• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_cmp, :LLVMConstFCmp, [:real_predicate, OpaqueValue, OpaqueValue], OpaqueValue

.const_f_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_div, :LLVMConstFDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_mul, :LLVMConstFMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_neg, :LLVMConstFNeg, [OpaqueValue], OpaqueValue

.const_f_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_rem, :LLVMConstFRem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_f_sub, :LLVMConstFSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_fp_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_fp_cast, :LLVMConstFPCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_fp_ext, :LLVMConstFPExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_to_si(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_fp_to_si, :LLVMConstFPToSI, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_to_ui(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_fp_to_ui, :LLVMConstFPToUI, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_fp_trunc, :LLVMConstFPTrunc, [OpaqueValue, OpaqueType], OpaqueValue

.const_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• constant_indices (FFI::Pointer(*ValueRef))
• num_indices (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_gep, :LLVMConstGEP, [OpaqueValue, :pointer, :uint], OpaqueValue

.const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• predicate (Symbol from _enum_int_predicate_)
• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_i_cmp, :LLVMConstICmp, [:int_predicate, OpaqueValue, OpaqueValue], OpaqueValue

.const_in_bounds_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• constant_indices (FFI::Pointer(*ValueRef))
• num_indices (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_in_bounds_gep, :LLVMConstInBoundsGEP, [OpaqueValue, :pointer, :uint], OpaqueValue

.const_inline_asm(ty, asm_string, constraints, has_side_effects, is_align_stack) ⇒ OpaqueValue

(Not documented)

Parameters:

• ty (OpaqueType)
• asm_string (String)
• constraints (String)
• has_side_effects (Integer)
• is_align_stack (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_inline_asm, :LLVMConstInlineAsm, [OpaqueType, :string, :string, :int, :int], OpaqueValue

.const_insert_element(vector_constant, element_value_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• vector_constant (OpaqueValue)
• element_value_constant (OpaqueValue)
• index_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_insert_element, :LLVMConstInsertElement, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

.const_insert_value(agg_constant, element_value_constant, idx_list, num_idx) ⇒ OpaqueValue

(Not documented)

Parameters:

• agg_constant (OpaqueValue)
• element_value_constant (OpaqueValue)
• idx_list (FFI::Pointer(*UInt))
• num_idx (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_insert_value, :LLVMConstInsertValue, [OpaqueValue, OpaqueValue, :pointer, :uint], OpaqueValue

.const_int(int_ty, n, sign_extend) ⇒ OpaqueValue

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 (OpaqueType)
• n (Integer)
• sign_extend (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

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

attach_function :const_int, :LLVMConstInt, [OpaqueType, :ulong_long, :int], OpaqueValue

.const_int_cast(constant_val, to_type, is_signed) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)
• is_signed (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_int_cast, :LLVMConstIntCast, [OpaqueValue, OpaqueType, :int], OpaqueValue

.const_int_get_s_ext_value(constant_val) ⇒ Integer

Obtain the sign extended value for an integer constant value.

Parameters:

• constant_val (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::getSExtValue()

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

attach_function :const_int_get_s_ext_value, :LLVMConstIntGetSExtValue, [OpaqueValue], :long_long

.const_int_get_z_ext_value(constant_val) ⇒ Integer

Obtain the zero extended value for an integer constant value.

Parameters:

• constant_val (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::getZExtValue()

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

attach_function :const_int_get_z_ext_value, :LLVMConstIntGetZExtValue, [OpaqueValue], :ulong_long

.const_int_of_arbitrary_precision(int_ty, num_words, words) ⇒ OpaqueValue

Obtain a constant value for an integer of arbitrary precision.

Parameters:

• int_ty (OpaqueType)
• num_words (Integer)
• words (FFI::Pointer(*Uint64T))

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

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

attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [OpaqueType, :uint, :pointer], OpaqueValue

.const_int_of_string(int_ty, text, radix) ⇒ OpaqueValue

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 (OpaqueType)
• text (String)
• radix (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

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

attach_function :const_int_of_string, :LLVMConstIntOfString, [OpaqueType, :string, :uchar], OpaqueValue

.const_int_of_string_and_size(int_ty, text, s_len, radix) ⇒ OpaqueValue

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

Parameters:

• int_ty (OpaqueType)
• text (String)
• s_len (Integer)
• radix (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantIntllvm::ConstantInt::get()

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

attach_function :const_int_of_string_and_size, :LLVMConstIntOfStringAndSize, [OpaqueType, :string, :uint, :uchar], OpaqueValue

.const_int_to_ptr(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_int_to_ptr, :LLVMConstIntToPtr, [OpaqueValue, OpaqueType], OpaqueValue

.const_l_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_l_shr, :LLVMConstLShr, [OpaqueValue, OpaqueValue], OpaqueValue

.const_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_mul, :LLVMConstMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_named_struct(struct_ty, constant_vals, count) ⇒ OpaqueValue

Create a non-anonymous ConstantStruct from values.

Parameters:

• struct_ty (OpaqueType)
• constant_vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantStructllvm::ConstantStruct::get()

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

attach_function :const_named_struct, :LLVMConstNamedStruct, [OpaqueType, :pointer, :uint], OpaqueValue

.const_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_neg, :LLVMConstNeg, [OpaqueValue], OpaqueValue

.const_not(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_not, :LLVMConstNot, [OpaqueValue], OpaqueValue

.const_nsw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nsw_add, :LLVMConstNSWAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nsw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nsw_mul, :LLVMConstNSWMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nsw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nsw_neg, :LLVMConstNSWNeg, [OpaqueValue], OpaqueValue

.const_nsw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nsw_sub, :LLVMConstNSWSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_null(ty) ⇒ OpaqueValue

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

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Constantllvm::Constant::getNullValue()

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

attach_function :const_null, :LLVMConstNull, [OpaqueType], OpaqueValue

.const_nuw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nuw_add, :LLVMConstNUWAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nuw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nuw_mul, :LLVMConstNUWMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nuw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nuw_neg, :LLVMConstNUWNeg, [OpaqueValue], OpaqueValue

.const_nuw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_nuw_sub, :LLVMConstNUWSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_or(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_or, :LLVMConstOr, [OpaqueValue, OpaqueValue], OpaqueValue

.const_pointer_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_pointer_cast, :LLVMConstPointerCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_pointer_null(ty) ⇒ OpaqueValue

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

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_pointer_null, :LLVMConstPointerNull, [OpaqueType], OpaqueValue

.const_ptr_to_int(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_ptr_to_int, :LLVMConstPtrToInt, [OpaqueValue, OpaqueType], OpaqueValue

.const_real(real_ty, n) ⇒ OpaqueValue

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

Parameters:

• real_ty (OpaqueType)
• n (Float)

Returns:

• (OpaqueValue)

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

attach_function :const_real, :LLVMConstReal, [OpaqueType, :double], OpaqueValue

.const_real_of_string(real_ty, text) ⇒ OpaqueValue

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 (OpaqueType)
• text (String)

Returns:

• (OpaqueValue)

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

attach_function :const_real_of_string, :LLVMConstRealOfString, [OpaqueType, :string], OpaqueValue

.const_real_of_string_and_size(real_ty, text, s_len) ⇒ OpaqueValue

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

Parameters:

• real_ty (OpaqueType)
• text (String)
• s_len (Integer)

Returns:

• (OpaqueValue)

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

attach_function :const_real_of_string_and_size, :LLVMConstRealOfStringAndSize, [OpaqueType, :string, :uint], OpaqueValue

.const_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_s_div, :LLVMConstSDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_s_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_s_ext, :LLVMConstSExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_s_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_s_ext_or_bit_cast, :LLVMConstSExtOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_s_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_s_rem, :LLVMConstSRem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_select(constant_condition, constant_if_true, constant_if_false) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_condition (OpaqueValue)
• constant_if_true (OpaqueValue)
• constant_if_false (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_select, :LLVMConstSelect, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

.const_shl(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_shl, :LLVMConstShl, [OpaqueValue, OpaqueValue], OpaqueValue

.const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• vector_a_constant (OpaqueValue)
• vector_b_constant (OpaqueValue)
• mask_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_shuffle_vector, :LLVMConstShuffleVector, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

.const_si_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_si_to_fp, :LLVMConstSIToFP, [OpaqueValue, OpaqueType], OpaqueValue

.const_string(str, length, dont_null_terminate) ⇒ OpaqueValue

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:

• (OpaqueValue)

See Also:

• LLVMConstStringInContext()
• llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()

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

attach_function :const_string, :LLVMConstString, [:string, :uint, :int], OpaqueValue

.const_string_in_context(c, str, length, dont_null_terminate) ⇒ OpaqueValue

Create a ConstantDataSequential and initialize it with a string.

Parameters:

• c (OpaqueContext)
• str (String)
• length (Integer)
• dont_null_terminate (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()

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

attach_function :const_string_in_context, :LLVMConstStringInContext, [OpaqueContext, :string, :uint, :int], OpaqueValue

.const_struct(constant_vals, count, packed) ⇒ OpaqueValue

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:

• (OpaqueValue)

See Also:

• LLVMConstStructInContext()

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

attach_function :const_struct, :LLVMConstStruct, [:pointer, :uint, :int], OpaqueValue

.const_struct_in_context(c, constant_vals, count, packed) ⇒ OpaqueValue

Create an anonymous ConstantStruct with the specified values.

Parameters:

• c (OpaqueContext)
• constant_vals (FFI::Pointer(*ValueRef))
• count (Integer)
• packed (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantStructllvm::ConstantStruct::getAnon()

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

attach_function :const_struct_in_context, :LLVMConstStructInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueValue

.const_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_sub, :LLVMConstSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_trunc, :LLVMConstTrunc, [OpaqueValue, OpaqueType], OpaqueValue

.const_trunc_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_trunc_or_bit_cast, :LLVMConstTruncOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_u_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_u_div, :LLVMConstUDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_u_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_u_rem, :LLVMConstURem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_ui_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_ui_to_fp, :LLVMConstUIToFP, [OpaqueValue, OpaqueType], OpaqueValue

.const_vector(scalar_constant_vals, size) ⇒ OpaqueValue

Create a ConstantVector from values.

Parameters:

• scalar_constant_vals (FFI::Pointer(*ValueRef))
• size (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::ConstantVectorllvm::ConstantVector::get()

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

attach_function :const_vector, :LLVMConstVector, [:pointer, :uint], OpaqueValue

.const_xor(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

• lhs_constant (OpaqueValue)
• rhs_constant (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :const_xor, :LLVMConstXor, [OpaqueValue, OpaqueValue], OpaqueValue

.const_z_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_z_ext, :LLVMConstZExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_z_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

• constant_val (OpaqueValue)
• to_type (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :const_z_ext_or_bit_cast, :LLVMConstZExtOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.context_create ⇒ OpaqueContext

Create a new context.

Every call to this function should be paired with a call to LLVMContextDispose() or the context will leak memory.

Returns:

• (OpaqueContext)

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

attach_function :context_create, :LLVMContextCreate, [], OpaqueContext

.context_dispose(c) ⇒ nil

Destroy a context instance.

This should be called for every call to LLVMContextCreate() or memory will be leaked.

Parameters:

• c (OpaqueContext)

Returns:

• (nil)

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

attach_function :context_dispose, :LLVMContextDispose, [OpaqueContext], :void

.copy_string_rep_of_target_data(opaque_target_data) ⇒ String

Converts target data to a target layout string. The string must be disposed

with LLVMDisposeMessage.
See the constructor llvm::DataLayout::DataLayout.

Parameters:

• opaque_target_data (OpaqueTargetData)

Returns:

• (String)

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

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 (OpaqueValue)

Returns:

• (Integer)

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

attach_function :count_basic_blocks, :LLVMCountBasicBlocks, [OpaqueValue], :uint

.count_incoming(phi_node) ⇒ Integer

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

Parameters:

• phi_node (OpaqueValue)

Returns:

• (Integer)

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

attach_function :count_incoming, :LLVMCountIncoming, [OpaqueValue], :uint

.count_param_types(function_ty) ⇒ Integer

Obtain the number of parameters this function accepts.

Parameters:

• function_ty (OpaqueType)

Returns:

• (Integer)

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

attach_function :count_param_types, :LLVMCountParamTypes, [OpaqueType], :uint

.count_params(fn) ⇒ Integer

Obtain the number of parameters in a function.

Parameters:

• fn (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::arg_size()

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

attach_function :count_params, :LLVMCountParams, [OpaqueValue], :uint

.count_struct_element_types(struct_ty) ⇒ Integer

Get the number of elements defined inside the structure.

Parameters:

• struct_ty (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::StructTypellvm::StructType::getNumElements()

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

attach_function :count_struct_element_types, :LLVMCountStructElementTypes, [OpaqueType], :uint

.create_builder ⇒ OpaqueBuilder

(Not documented)

Returns:

• (OpaqueBuilder)

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

attach_function :create_builder, :LLVMCreateBuilder, [], OpaqueBuilder

.create_builder_in_context(c) ⇒ OpaqueBuilder

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

@{

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueBuilder)

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

attach_function :create_builder_in_context, :LLVMCreateBuilderInContext, [OpaqueContext], OpaqueBuilder

.create_execution_engine(out_ee, mp, out_error) ⇒ Integer

Deprecated: Use LLVMCreateExecutionEngineForModule instead.

Parameters:

• out_ee (FFI::Pointer(*ExecutionEngineRef))
• mp (FFI::Pointer(ModuleProviderRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

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

attach_function :create_execution_engine, :LLVMCreateExecutionEngine, [:pointer, :pointer, :pointer], :int

.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 141

attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int

.create_function_pass_manager(mp) ⇒ OpaquePassManager

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

• mp (OpaqueModuleProvider)

Returns:

• (OpaquePassManager)

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

attach_function :create_function_pass_manager, :LLVMCreateFunctionPassManager, [OpaqueModuleProvider], OpaquePassManager

.create_function_pass_manager_for_module(m) ⇒ OpaquePassManager

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 (OpaqueModule)

Returns:

• (OpaquePassManager)

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

attach_function :create_function_pass_manager_for_module, :LLVMCreateFunctionPassManagerForModule, [OpaqueModule], OpaquePassManager

.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 89

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 72

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 80

attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], OpaqueGenericValue

.create_interpreter(out_interp, mp, out_error) ⇒ Integer

Deprecated: Use LLVMCreateInterpreterForModule instead.

Parameters:

• out_interp (FFI::Pointer(*ExecutionEngineRef))
• mp (FFI::Pointer(ModuleProviderRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

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

attach_function :create_interpreter, :LLVMCreateInterpreter, [:pointer, :pointer, :pointer], :int

.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 151

attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int

.create_jit_compiler(out_jit, mp, opt_level, out_error) ⇒ Integer

Deprecated: Use LLVMCreateJITCompilerForModule instead.

Parameters:

• out_jit (FFI::Pointer(*ExecutionEngineRef))
• mp (FFI::Pointer(ModuleProviderRef))
• opt_level (Integer)
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

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

attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, :pointer, :uint, :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 162

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 197

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 5370

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) ⇒ OpaqueMemoryBuffer

(Not documented)

Parameters:

• input_data (String)
• input_data_length (Integer)
• buffer_name (String)
• requires_null_terminator (Integer)

Returns:

• (OpaqueMemoryBuffer)

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

attach_function :create_memory_buffer_with_memory_range, :LLVMCreateMemoryBufferWithMemoryRange, [:string, :ulong, :string, :int], OpaqueMemoryBuffer

.create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name) ⇒ OpaqueMemoryBuffer

(Not documented)

Parameters:

• input_data (String)
• input_data_length (Integer)
• buffer_name (String)

Returns:

• (OpaqueMemoryBuffer)

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

attach_function :create_memory_buffer_with_memory_range_copy, :LLVMCreateMemoryBufferWithMemoryRangeCopy, [:string, :ulong, :string], OpaqueMemoryBuffer

.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 5379

attach_function :create_memory_buffer_with_stdin, :LLVMCreateMemoryBufferWithSTDIN, [:pointer, :pointer], :int

.create_module_provider_for_existing_module(m) ⇒ OpaqueModuleProvider

Changes the type of M so it can be passed to FunctionPassManagers and the JIT. They take ModuleProviders for historical reasons.

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueModuleProvider)

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

attach_function :create_module_provider_for_existing_module, :LLVMCreateModuleProviderForExistingModule, [OpaqueModule], OpaqueModuleProvider

.create_pass_manager ⇒ OpaquePassManager

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:

• (OpaquePassManager)

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

attach_function :create_pass_manager, :LLVMCreatePassManager, [], OpaquePassManager

.create_target_data(string_rep) ⇒ OpaqueTargetData

Creates target data from a target layout string.

See the constructor llvm::DataLayout::DataLayout.

Parameters:

• string_rep (String)

Returns:

• (OpaqueTargetData)

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

attach_function :create_target_data, :LLVMCreateTargetData, [:string], 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 489

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 (OpaqueBasicBlock)

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::eraseFromParent()

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

attach_function :delete_basic_block, :LLVMDeleteBasicBlock, [OpaqueBasicBlock], :void

.delete_function(fn) ⇒ nil

Remove a function from its containing module and deletes it.

Parameters:

• fn (OpaqueValue)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::eraseFromParent()

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

attach_function :delete_function, :LLVMDeleteFunction, [OpaqueValue], :void

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (nil)

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

attach_function :delete_global, :LLVMDeleteGlobal, [OpaqueValue], :void

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)

Returns:

• (nil)

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

attach_function :dispose_builder, :LLVMDisposeBuilder, [OpaqueBuilder], :void

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (nil)

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

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 131

attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [OpaqueGenericValue], :void

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

• mem_buf (OpaqueMemoryBuffer)

Returns:

• (nil)

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

attach_function :dispose_memory_buffer, :LLVMDisposeMemoryBuffer, [OpaqueMemoryBuffer], :void

.dispose_message(message) ⇒ nil

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

Parameters:

• message (String)

Returns:

• (nil)

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

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 (OpaqueModule)

Returns:

• (nil)

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

attach_function :dispose_module, :LLVMDisposeModule, [OpaqueModule], :void

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

• m (OpaqueModuleProvider)

Returns:

• (nil)

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

attach_function :dispose_module_provider, :LLVMDisposeModuleProvider, [OpaqueModuleProvider], :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 (OpaquePassManager)

Returns:

• (nil)

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

attach_function :dispose_pass_manager, :LLVMDisposePassManager, [OpaquePassManager], :void

.dispose_target_data(opaque_target_data) ⇒ nil

Deallocates a TargetData.

See the destructor llvm::DataLayout::~DataLayout.

Parameters:

• opaque_target_data (OpaqueTargetData)

Returns:

• (nil)

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

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 498

attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void

.double_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :double_type, :LLVMDoubleType, [], OpaqueType

.double_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :double_type_in_context, :LLVMDoubleTypeInContext, [OpaqueContext], OpaqueType

.dump_module(m) ⇒ nil

Dump a representation of a module to stderr.

Parameters:

• m (OpaqueModule)

Returns:

• (nil)

See Also:

• Module::dump()

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

attach_function :dump_module, :LLVMDumpModule, [OpaqueModule], :void

.dump_value(val) ⇒ nil

Dump a representation of a value to stderr.

Parameters:

• val (OpaqueValue)

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::dump()

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

attach_function :dump_value, :LLVMDumpValue, [OpaqueValue], :void

.element_at_offset(opaque_target_data, struct_ty, offset) ⇒ Integer

Computes the structure element that contains the byte offset for a target.

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

• opaque_target_data (OpaqueTargetData)
• struct_ty (FFI::Pointer(TypeRef))
• offset (Integer)

Returns:

• (Integer)

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

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 (OpaquePassManager)

Returns:

• (Integer)

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

attach_function :finalize_function_pass_manager, :LLVMFinalizeFunctionPassManager, [OpaquePassManager], :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 334

attach_function :find_function, :LLVMFindFunction, [OpaqueExecutionEngine, :string, :pointer], :int

.float_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :float_type, :LLVMFloatType, [], OpaqueType

.float_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :float_type_in_context, :LLVMFloatTypeInContext, [OpaqueContext], OpaqueType

.fp128_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :fp128_type, :LLVMFP128Type, [], OpaqueType

.fp128_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :fp128_type_in_context, :LLVMFP128TypeInContext, [OpaqueContext], OpaqueType

.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 284

attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, :pointer], :void

.function_type(return_type, param_types, param_count, is_var_arg) ⇒ OpaqueType

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 (OpaqueType)
• param_types (FFI::Pointer(*TypeRef))
• param_count (Integer)
• is_var_arg (Integer)

Returns:

• (OpaqueType)

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

attach_function :function_type, :LLVMFunctionType, [OpaqueType, :pointer, :uint, :int], OpaqueType

.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 97

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 123

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 106

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 114

attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [OpaqueGenericValue], :pointer

.get_alignment(global) ⇒ Integer

(Not documented)

Parameters:

• global (OpaqueValue)

Returns:

• (Integer)

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

attach_function :get_alignment, :LLVMGetAlignment, [OpaqueValue], :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 (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::ArrayTypellvm::ArrayType::getNumElements()

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

attach_function :get_array_length, :LLVMGetArrayLength, [OpaqueType], :uint

.get_attribute(arg) ⇒ Symbol from _enum_attribute_

Get an attribute from a function argument.

Parameters:

• arg (OpaqueValue)

Returns:

• (Symbol from _enum_attribute_)

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

attach_function :get_attribute, :LLVMGetAttribute, [OpaqueValue], :attribute

.get_basic_block_parent(bb) ⇒ OpaqueValue

Obtain the function to which a basic block belongs.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::getParent()

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

attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [OpaqueBasicBlock], OpaqueValue

.get_basic_block_terminator(bb) ⇒ OpaqueValue

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 (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::getTerminator()

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

attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [OpaqueBasicBlock], OpaqueValue

.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 (OpaqueValue)
• basic_blocks (FFI::Pointer(*BasicBlockRef))

Returns:

• (nil)

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

attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [OpaqueValue, :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 57

attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int

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

Reads a module from the specified path, returning via the OutMP parameter

a module provider which performs lazy deserialization. Returns 0 on success.
Optionally returns a human-readable error message via OutMessage.

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 47

attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_bitcode_module_provider(mem_buf, out_mp, out_message) ⇒ Integer

Deprecated: Use LLVMGetBitcodeModule instead.

Parameters:

• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_mp (FFI::Pointer(*ModuleProviderRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 78

attach_function :get_bitcode_module_provider, :LLVMGetBitcodeModuleProvider, [:pointer, :pointer, :pointer], :int

.get_bitcode_module_provider_in_context(context_ref, mem_buf, out_mp, out_message) ⇒ Integer

Deprecated: Use LLVMGetBitcodeModuleInContext instead.

Parameters:

• context_ref (FFI::Pointer(ContextRef))
• mem_buf (FFI::Pointer(MemoryBufferRef))
• out_mp (FFI::Pointer(*ModuleProviderRef))
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 68

attach_function :get_bitcode_module_provider_in_context, :LLVMGetBitcodeModuleProviderInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_buffer_size(mem_buf) ⇒ Integer

(Not documented)

Parameters:

• mem_buf (OpaqueMemoryBuffer)

Returns:

• (Integer)

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

attach_function :get_buffer_size, :LLVMGetBufferSize, [OpaqueMemoryBuffer], :ulong

.get_buffer_start(mem_buf) ⇒ String

(Not documented)

Parameters:

• mem_buf (OpaqueMemoryBuffer)

Returns:

• (String)

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

attach_function :get_buffer_start, :LLVMGetBufferStart, [OpaqueMemoryBuffer], :string

.get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

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

@{

Parameters:

• constant_val (OpaqueValue)

Returns:

• (Symbol from _enum_opcode_)

See Also:

• llvm::ConstantExpr.

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

attach_function :get_const_opcode, :LLVMGetConstOpcode, [OpaqueValue], :opcode

.get_current_debug_location(builder) ⇒ OpaqueValue

(Not documented)

Parameters:

• builder (OpaqueBuilder)

Returns:

• (OpaqueValue)

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

attach_function :get_current_debug_location, :LLVMGetCurrentDebugLocation, [OpaqueBuilder], OpaqueValue

.get_data_layout(m) ⇒ String

Obtain the data layout for a module.

Parameters:

• m (OpaqueModule)

Returns:

• (String)

See Also:

• Module::getDataLayout()

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

attach_function :get_data_layout, :LLVMGetDataLayout, [OpaqueModule], :string

.get_element_type(ty) ⇒ OpaqueType

Obtain the type of elements within a sequential type.

This works on array, vector, and pointer types.

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::SequentialTypellvm::SequentialType::getElementType()

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

attach_function :get_element_type, :LLVMGetElementType, [OpaqueType], OpaqueType

.get_entry_basic_block(fn) ⇒ OpaqueBasicBlock

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

Parameters:

• fn (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

See Also:

• llvmllvm::Functionllvm::Function::getEntryBlock()

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

attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [OpaqueValue], OpaqueBasicBlock

.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 351

attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [OpaqueExecutionEngine], :pointer

.get_first_basic_block(fn) ⇒ OpaqueBasicBlock

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 (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

See Also:

• llvmllvm::Functionllvm::Function::begin()

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

attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_first_function(m) ⇒ OpaqueValue

Obtain an iterator to the first Function in a Module.

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Modulellvm::Module::begin()

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

attach_function :get_first_function, :LLVMGetFirstFunction, [OpaqueModule], OpaqueValue

.get_first_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueValue)

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

attach_function :get_first_global, :LLVMGetFirstGlobal, [OpaqueModule], OpaqueValue

.get_first_instruction(bb) ⇒ OpaqueValue

Obtain the first instruction in a basic block.

The returned LLVMValueRef corresponds to a llvm::Instruction instance.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :get_first_instruction, :LLVMGetFirstInstruction, [OpaqueBasicBlock], OpaqueValue

.get_first_param(fn) ⇒ OpaqueValue

Obtain the first parameter to a function.

Parameters:

• fn (OpaqueValue)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

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

attach_function :get_first_param, :LLVMGetFirstParam, [OpaqueValue], OpaqueValue

.get_first_target ⇒ Target

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

Returns:

• (Target)

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

attach_function :get_first_target, :LLVMGetFirstTarget, [], Target

.get_first_use(val) ⇒ OpaqueUse

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 (OpaqueValue)

Returns:

• (OpaqueUse)

See Also:

• llvmllvm::Valuellvm::Value::use_begin()

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

attach_function :get_first_use, :LLVMGetFirstUse, [OpaqueValue], OpaqueUse

.get_function_attr(fn) ⇒ Symbol from _enum_attribute_

Obtain an attribute from a function.

Parameters:

• fn (OpaqueValue)

Returns:

• (Symbol from _enum_attribute_)

See Also:

• llvmllvm::Functionllvm::Function::getAttributes()

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

attach_function :get_function_attr, :LLVMGetFunctionAttr, [OpaqueValue], :attribute

.get_function_call_conv(fn) ⇒ Integer

Obtain the calling function of a function.

The returned value corresponds to the LLVMCallConv enumeration.

Parameters:

• fn (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::getCallingConv()

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

attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [OpaqueValue], :uint

.get_gc(fn) ⇒ String

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

Parameters:

• fn (OpaqueValue)

Returns:

• (String)

See Also:

• llvmllvm::Functionllvm::Function::getGC()

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

attach_function :get_gc, :LLVMGetGC, [OpaqueValue], :string

.get_global_context ⇒ OpaqueContext

Obtain the global context instance.

Returns:

• (OpaqueContext)

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

attach_function :get_global_context, :LLVMGetGlobalContext, [], OpaqueContext

.get_global_parent(global) ⇒ OpaqueModule

This group contains functions that operate on global values. Functions in this group relate to functions in the llvm::GlobalValue class tree.

@{

Parameters:

• global (OpaqueValue)

Returns:

• (OpaqueModule)

See Also:

• llvmllvm::GlobalValue

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

attach_function :get_global_parent, :LLVMGetGlobalParent, [OpaqueValue], OpaqueModule

.get_global_pass_registry ⇒ OpaquePassRegistry

Return the global pass registry, for use with initialization functions.

@see llvm::PassRegistry::getPassRegistry

Returns:

• (OpaquePassRegistry)

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

attach_function :get_global_pass_registry, :LLVMGetGlobalPassRegistry, [], OpaquePassRegistry

.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 (OpaqueValue)

Returns:

• (Symbol from _enum_int_predicate_)

See Also:

• llvmllvm::ICmpInstllvm::ICmpInst::getPredicate()

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

attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [OpaqueValue], :int_predicate

.get_incoming_block(phi_node, index) ⇒ OpaqueBasicBlock

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

Parameters:

• phi_node (OpaqueValue)
• index (Integer)

Returns:

• (OpaqueBasicBlock)

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

attach_function :get_incoming_block, :LLVMGetIncomingBlock, [OpaqueValue, :uint], OpaqueBasicBlock

.get_incoming_value(phi_node, index) ⇒ OpaqueValue

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

Parameters:

• phi_node (OpaqueValue)
• index (Integer)

Returns:

• (OpaqueValue)

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

attach_function :get_incoming_value, :LLVMGetIncomingValue, [OpaqueValue, :uint], OpaqueValue

.get_initializer(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_initializer, :LLVMGetInitializer, [OpaqueValue], OpaqueValue

.get_insert_block(builder) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

• builder (OpaqueBuilder)

Returns:

• (OpaqueBasicBlock)

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

attach_function :get_insert_block, :LLVMGetInsertBlock, [OpaqueBuilder], OpaqueBasicBlock

.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 (OpaqueValue)

Returns:

• (Integer)

See Also:

• LLVMSetInstructionCallConv()

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

attach_function :get_instruction_call_conv, :LLVMGetInstructionCallConv, [OpaqueValue], :uint

.get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

Obtain the code opcode for an individual instruction.

Parameters:

• inst (OpaqueValue)

Returns:

• (Symbol from _enum_opcode_)

See Also:

• llvmllvm::Instructionllvm::Instruction::getOpCode()

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

attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [OpaqueValue], :opcode

.get_instruction_parent(inst) ⇒ OpaqueBasicBlock

Obtain the basic block to which an instruction belongs.

Parameters:

• inst (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

See Also:

• llvmllvm::Instructionllvm::Instruction::getParent()

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

attach_function :get_instruction_parent, :LLVMGetInstructionParent, [OpaqueValue], OpaqueBasicBlock

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

• integer_ty (OpaqueType)

Returns:

• (Integer)

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

attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [OpaqueType], :uint

.get_intrinsic_id(fn) ⇒ Integer

Obtain the ID number from a function instance.

Parameters:

• fn (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::Functionllvm::Function::getIntrinsicID()

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

attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [OpaqueValue], :uint

.get_last_basic_block(fn) ⇒ OpaqueBasicBlock

Obtain the last basic block in a function.

Parameters:

• fn (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

See Also:

• llvmllvm::Functionllvm::Function::end()

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

attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_last_function(m) ⇒ OpaqueValue

Obtain an iterator to the last Function in a Module.

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Modulellvm::Module::end()

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

attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue

.get_last_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueValue)

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

attach_function :get_last_global, :LLVMGetLastGlobal, [OpaqueModule], OpaqueValue

.get_last_instruction(bb) ⇒ OpaqueValue

Obtain the last instruction in a basic block.

The returned LLVMValueRef corresponds to a LLVM:Instruction.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueValue)

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

attach_function :get_last_instruction, :LLVMGetLastInstruction, [OpaqueBasicBlock], OpaqueValue

.get_last_param(fn) ⇒ OpaqueValue

Obtain the last parameter to a function.

Parameters:

• fn (OpaqueValue)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Functionllvm::Function::arg_end()

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

attach_function :get_last_param, :LLVMGetLastParam, [OpaqueValue], OpaqueValue

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

• global (OpaqueValue)

Returns:

• (Symbol from _enum_linkage_)

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

attach_function :get_linkage, :LLVMGetLinkage, [OpaqueValue], :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 839

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 (OpaqueContext)
• name (String)
• s_len (Integer)

Returns:

• (Integer)

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

attach_function :get_md_kind_id_in_context, :LLVMGetMDKindIDInContext, [OpaqueContext, :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 (OpaqueValue)

Returns:

• Number of operands of the MDNode.

• (Integer)

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

attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [OpaqueValue], :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 (OpaqueValue)
• dest (FFI::Pointer(*ValueRef))

Returns:

• (nil)

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

attach_function :get_md_node_operands, :LLVMGetMDNodeOperands, [OpaqueValue, :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 (OpaqueValue)
• len (FFI::Pointer(*UInt))

Returns:

• String data in MDString.

• (String)

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

attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string

.get_metadata(val, kind_id) ⇒ OpaqueValue

Return metadata associated with an instruction value.

Parameters:

• val (OpaqueValue)
• kind_id (Integer)

Returns:

• (OpaqueValue)

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

attach_function :get_metadata, :LLVMGetMetadata, [OpaqueValue, :uint], OpaqueValue

.get_module_context(m) ⇒ OpaqueContext

Obtain the context to which this module is associated.

Parameters:

• m (OpaqueModule)

Returns:

• (OpaqueContext)

See Also:

• Module::getContext()

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

attach_function :get_module_context, :LLVMGetModuleContext, [OpaqueModule], OpaqueContext

.get_named_function(m, name) ⇒ OpaqueValue

Obtain a Function value from a Module by its name.

The returned value corresponds to a llvm::Function value.

Parameters:

• m (OpaqueModule)
• name (String)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Modulellvm::Module::getFunction()

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

attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue

.get_named_global(m, name) ⇒ OpaqueValue

(Not documented)

Parameters:

• m (OpaqueModule)
• name (String)

Returns:

• (OpaqueValue)

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

attach_function :get_named_global, :LLVMGetNamedGlobal, [OpaqueModule, :string], OpaqueValue

.get_named_metadata_num_operands(m, name) ⇒ Integer

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

Parameters:

• m (OpaqueModule)
• name (String)

Returns:

• (Integer)

See Also:

• llvmllvm::Modulellvm::Module::getNamedMetadata()

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

attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [OpaqueModule, :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 (OpaqueModule)
• 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 1000

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ OpaqueBasicBlock

Advance a basic block iterator.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueBasicBlock)

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

attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_next_function(fn) ⇒ OpaqueValue

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 (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue

.get_next_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_next_global, :LLVMGetNextGlobal, [OpaqueValue], OpaqueValue

.get_next_instruction(inst) ⇒ OpaqueValue

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 (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_next_instruction, :LLVMGetNextInstruction, [OpaqueValue], OpaqueValue

.get_next_param(arg) ⇒ OpaqueValue

Obtain the next parameter to a function.

This takes a LLVMValueRef obtained from LLVMGetFirstParam() (which is actually a wrapped iterator) and obtains the next parameter from the underlying iterator.

Parameters:

• arg (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_next_param, :LLVMGetNextParam, [OpaqueValue], OpaqueValue

.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 435

attach_function :get_next_target, :LLVMGetNextTarget, [Target], Target

.get_next_use(u) ⇒ OpaqueUse

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 (OpaqueUse)

Returns:

• (OpaqueUse)

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

attach_function :get_next_use, :LLVMGetNextUse, [OpaqueUse], OpaqueUse

.get_num_operands(val) ⇒ Integer

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

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::Userllvm::User::getNumOperands()

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

attach_function :get_num_operands, :LLVMGetNumOperands, [OpaqueValue], :int

.get_operand(val, index) ⇒ OpaqueValue

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

Parameters:

• val (OpaqueValue)
• index (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Userllvm::User::getOperand()

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

attach_function :get_operand, :LLVMGetOperand, [OpaqueValue, :uint], OpaqueValue

.get_param(fn, index) ⇒ OpaqueValue

Obtain the parameter at the specified index.

Parameters are indexed from 0.

Parameters:

• fn (OpaqueValue)
• index (Integer)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

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

attach_function :get_param, :LLVMGetParam, [OpaqueValue, :uint], OpaqueValue

.get_param_parent(inst) ⇒ OpaqueValue

Obtain the function to which this argument belongs.

Unlike other functions in this group, this one takes a LLVMValueRef that corresponds to a llvm::Attribute.

The returned LLVMValueRef is the llvm::Function to which this argument belongs.

Parameters:

• inst (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_param_parent, :LLVMGetParamParent, [OpaqueValue], OpaqueValue

.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 (OpaqueType)
• dest (FFI::Pointer(*TypeRef))

Returns:

• (nil)

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

attach_function :get_param_types, :LLVMGetParamTypes, [OpaqueType, :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 (OpaqueValue)
• params (FFI::Pointer(*ValueRef))

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::arg_begin()

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

attach_function :get_params, :LLVMGetParams, [OpaqueValue, :pointer], :void

.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 (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::PointerTypellvm::PointerType::getAddressSpace()

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

attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [OpaqueType], :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 370

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, :pointer], :pointer

.get_previous_basic_block(bb) ⇒ OpaqueBasicBlock

Go backwards in a basic block iterator.

Parameters:

• bb (OpaqueBasicBlock)

Returns:

• (OpaqueBasicBlock)

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

attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_previous_function(fn) ⇒ OpaqueValue

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 (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue

.get_previous_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_previous_global, :LLVMGetPreviousGlobal, [OpaqueValue], OpaqueValue

.get_previous_instruction(inst) ⇒ OpaqueValue

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 (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [OpaqueValue], OpaqueValue

.get_previous_param(arg) ⇒ OpaqueValue

Obtain the previous parameter to a function.

This is the opposite of LLVMGetNextParam().

Parameters:

• arg (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :get_previous_param, :LLVMGetPreviousParam, [OpaqueValue], OpaqueValue

.get_return_type(function_ty) ⇒ OpaqueType

Obtain the Type this function Type returns.

Parameters:

• function_ty (OpaqueType)

Returns:

• (OpaqueType)

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

attach_function :get_return_type, :LLVMGetReturnType, [OpaqueType], OpaqueType

.get_section(global) ⇒ String

(Not documented)

Parameters:

• global (OpaqueValue)

Returns:

• (String)

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

attach_function :get_section, :LLVMGetSection, [OpaqueValue], :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 (OpaqueType)
• dest (FFI::Pointer(*TypeRef))

Returns:

• (nil)

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

attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [OpaqueType, :pointer], :void

.get_struct_name(ty) ⇒ String

Obtain the name of a structure.

Parameters:

• ty (OpaqueType)

Returns:

• (String)

See Also:

• llvmllvm::StructTypellvm::StructType::getName()

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

attach_function :get_struct_name, :LLVMGetStructName, [OpaqueType], :string

.get_switch_default_dest(switch_instr) ⇒ OpaqueBasicBlock

Obtain the default destination basic block of a switch instruction.

This only works on llvm::SwitchInst instructions.

Parameters:

• switch_instr (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

See Also:

• llvmllvm::SwitchInstllvm::SwitchInst::getDefaultDest()

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

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [OpaqueValue], OpaqueBasicBlock

.get_target(m) ⇒ String

Obtain the target triple for a module.

Parameters:

• m (OpaqueModule)

Returns:

• (String)

See Also:

• Module::getTargetTriple()

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

attach_function :get_target, :LLVMGetTarget, [OpaqueModule], :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 451

attach_function :get_target_description, :LLVMGetTargetDescription, [Target], :string

.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 526

attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string

.get_target_machine_data(t) ⇒ OpaqueTargetData

Returns the llvm::DataLayout used for this llvm:TargetMachine.

Parameters:

• t (OpaqueTargetMachine)

Returns:

• (OpaqueTargetData)

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

attach_function :get_target_machine_data, :LLVMGetTargetMachineData, [OpaqueTargetMachine], OpaqueTargetData

.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 536

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 506

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 516

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 443

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 (OpaqueValue)

Returns:

• (Symbol from _enum_thread_local_mode_)

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

attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [OpaqueValue], :thread_local_mode

.get_type_by_name(m, name) ⇒ OpaqueType

Obtain a Type from a module by its registered name.

Parameters:

• m (OpaqueModule)
• name (String)

Returns:

• (OpaqueType)

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

attach_function :get_type_by_name, :LLVMGetTypeByName, [OpaqueModule, :string], OpaqueType

.get_type_context(ty) ⇒ OpaqueContext

Obtain the context to which this type instance is associated.

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueContext)

See Also:

• llvmllvm::Typellvm::Type::getContext()

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

attach_function :get_type_context, :LLVMGetTypeContext, [OpaqueType], OpaqueContext

.get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

Obtain the enumerated type of a Type instance.

Parameters:

• ty (OpaqueType)

Returns:

• (Symbol from _enum_type_kind_)

See Also:

• llvm::Type:getTypeID()

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

attach_function :get_type_kind, :LLVMGetTypeKind, [OpaqueType], :type_kind

.get_undef(ty) ⇒ OpaqueValue

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

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::UndefValuellvm::UndefValue::get()

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

attach_function :get_undef, :LLVMGetUndef, [OpaqueType], OpaqueValue

.get_used_value(u) ⇒ OpaqueValue

Obtain the value this use corresponds to.

Parameters:

• u (OpaqueUse)

Returns:

• (OpaqueValue)

See Also:

• llvm::Use::get().

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

attach_function :get_used_value, :LLVMGetUsedValue, [OpaqueUse], OpaqueValue

.get_user(u) ⇒ OpaqueValue

Obtain the user value for a user.

The returned value corresponds to a llvm::User type.

Parameters:

• u (OpaqueUse)

Returns:

• (OpaqueValue)

See Also:

• llvmllvm::Usellvm::Use::getUser()

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

attach_function :get_user, :LLVMGetUser, [OpaqueUse], OpaqueValue

.get_value_name(val) ⇒ String

Obtain the string name of a value.

Parameters:

• val (OpaqueValue)

Returns:

• (String)

See Also:

• llvmllvm::Valuellvm::Value::getName()

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

attach_function :get_value_name, :LLVMGetValueName, [OpaqueValue], :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 (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::VectorTypellvm::VectorType::getNumElements()

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

attach_function :get_vector_size, :LLVMGetVectorSize, [OpaqueType], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

• global (OpaqueValue)

Returns:

• (Symbol from _enum_visibility_)

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

attach_function :get_visibility, :LLVMGetVisibility, [OpaqueValue], :visibility

.get_volatile(memory_access_inst) ⇒ Integer

(Not documented)

Parameters:

• memory_access_inst (OpaqueValue)

Returns:

• (Integer)

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

attach_function :get_volatile, :LLVMGetVolatile, [OpaqueValue], :int

.half_type ⇒ OpaqueType

Obtain a floating point type from the global context.

These map to the functions in this group of the same name.

Returns:

• (OpaqueType)

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

attach_function :half_type, :LLVMHalfType, [], OpaqueType

.half_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :half_type_in_context, :LLVMHalfTypeInContext, [OpaqueContext], OpaqueType

.has_metadata(val) ⇒ Integer

Determine whether an instruction has any metadata attached.

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

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

attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int

.initialize_all_asm_parsers ⇒ nil

LLVMInitializeAllAsmParsers - The main program should call this function if

it wants all asm parsers that LLVM is configured to support, to make them
available via the TargetRegistry.

Returns:

• (nil)

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

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

.initialize_all_asm_printers ⇒ nil

LLVMInitializeAllAsmPrinters - The main program should call this function if

it wants all asm printers that LLVM is configured to support, to make them
available via the TargetRegistry.

Returns:

• (nil)

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

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

.initialize_all_disassemblers ⇒ nil

LLVMInitializeAllDisassemblers - The main program should call this function

if it wants all disassemblers that LLVM is configured to support, to make
them available via the TargetRegistry.

Returns:

• (nil)

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

attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void

.initialize_all_target_infos ⇒ nil

(Not documented)

Returns:

• (nil)

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

attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void

.initialize_all_target_m_cs ⇒ nil

LLVMInitializeAllTargetMCs - The main program should call this function if

it wants access to all available target MC that LLVM is configured to
support.

Returns:

• (nil)

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

attach_function :initialize_all_target_m_cs, :LLVMInitializeAllTargetMCs, [], :void

.initialize_all_targets ⇒ nil

LLVMInitializeAllTargets - The main program should call this function if it

wants to link in all available targets that LLVM is configured to
support.

Returns:

• (nil)

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

attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void

.initialize_core(r) ⇒ nil

@}

Parameters:

• r (OpaquePassRegistry)

Returns:

• (nil)

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

attach_function :initialize_core, :LLVMInitializeCore, [OpaquePassRegistry], :void

.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 (OpaquePassManager)

Returns:

• (Integer)

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

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [OpaquePassManager], :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 171

attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void

.initialize_native_target ⇒ Integer

LLVMInitializeNativeTarget - The main program should call this function to

initialize the native target corresponding to the host.  This is useful 
for JIT applications to ensure that the target gets linked in correctly.

Returns:

• (Integer)

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

attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int

.insert_basic_block(insert_before_bb, name) ⇒ OpaqueBasicBlock

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

Parameters:

• insert_before_bb (OpaqueBasicBlock)
• name (String)

Returns:

• (OpaqueBasicBlock)

See Also:

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

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

attach_function :insert_basic_block, :LLVMInsertBasicBlock, [OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_basic_block_in_context(c, bb, name) ⇒ OpaqueBasicBlock

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 (OpaqueContext)
• bb (OpaqueBasicBlock)
• name (String)

Returns:

• (OpaqueBasicBlock)

See Also:

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

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

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• instr (OpaqueValue)

Returns:

• (nil)

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

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [OpaqueBuilder, OpaqueValue], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• instr (OpaqueValue)
• name (String)

Returns:

• (nil)

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

attach_function :insert_into_builder_with_name, :LLVMInsertIntoBuilderWithName, [OpaqueBuilder, OpaqueValue, :string], :void

.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 (OpaqueValue)

Returns:

• (nil)

See Also:

• llvmllvm::Instructionllvm::Instruction::eraseFromParent()

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

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [OpaqueValue], :void

.int16_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :int16_type, :LLVMInt16Type, [], OpaqueType

.int16_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :int16_type_in_context, :LLVMInt16TypeInContext, [OpaqueContext], OpaqueType

.int1_type ⇒ OpaqueType

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

Returns:

• (OpaqueType)

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

attach_function :int1_type, :LLVMInt1Type, [], OpaqueType

.int1_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [OpaqueContext], OpaqueType

.int32_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :int32_type, :LLVMInt32Type, [], OpaqueType

.int32_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [OpaqueContext], OpaqueType

.int64_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :int64_type, :LLVMInt64Type, [], OpaqueType

.int64_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [OpaqueContext], OpaqueType

.int8_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :int8_type, :LLVMInt8Type, [], OpaqueType

.int8_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [OpaqueContext], OpaqueType

.int_ptr_type(opaque_target_data) ⇒ FFI::Pointer(TypeRef)

Returns the integer type that is the same size as a pointer on a target.

See the method llvm::DataLayout::getIntPtrType.

Parameters:

• opaque_target_data (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(opaque_target_data, as) ⇒ FFI::Pointer(TypeRef)

Returns the integer type that is the same size as a pointer on a target.

This version allows the address space to be specified.
See the method llvm::DataLayout::getIntPtrType.

Parameters:

• opaque_target_data (OpaqueTargetData)
• as (Integer)

Returns:

• (FFI::Pointer(TypeRef))

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

attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], :pointer

.int_type(num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

• num_bits (Integer)

Returns:

• (OpaqueType)

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

attach_function :int_type, :LLVMIntType, [:uint], OpaqueType

.int_type_in_context(c, num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

• c (OpaqueContext)
• num_bits (Integer)

Returns:

• (OpaqueType)

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

attach_function :int_type_in_context, :LLVMIntTypeInContext, [OpaqueContext, :uint], OpaqueType

.is_a_alloca_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [OpaqueValue], OpaqueValue

.is_a_argument(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_argument, :LLVMIsAArgument, [OpaqueValue], OpaqueValue

.is_a_basic_block(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [OpaqueValue], OpaqueValue

.is_a_binary_operator(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [OpaqueValue], OpaqueValue

.is_a_bit_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [OpaqueValue], OpaqueValue

.is_a_block_address(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_block_address, :LLVMIsABlockAddress, [OpaqueValue], OpaqueValue

.is_a_branch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [OpaqueValue], OpaqueValue

.is_a_call_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_call_inst, :LLVMIsACallInst, [OpaqueValue], OpaqueValue

.is_a_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_cast_inst, :LLVMIsACastInst, [OpaqueValue], OpaqueValue

.is_a_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [OpaqueValue], OpaqueValue

.is_a_constant(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant, :LLVMIsAConstant, [OpaqueValue], OpaqueValue

.is_a_constant_aggregate_zero(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [OpaqueValue], OpaqueValue

.is_a_constant_array(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [OpaqueValue], OpaqueValue

.is_a_constant_expr(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [OpaqueValue], OpaqueValue

.is_a_constant_fp(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [OpaqueValue], OpaqueValue

.is_a_constant_int(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [OpaqueValue], OpaqueValue

.is_a_constant_pointer_null(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [OpaqueValue], OpaqueValue

.is_a_constant_struct(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [OpaqueValue], OpaqueValue

.is_a_constant_vector(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [OpaqueValue], OpaqueValue

.is_a_dbg_declare_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [OpaqueValue], OpaqueValue

.is_a_dbg_info_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [OpaqueValue], OpaqueValue

.is_a_extract_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [OpaqueValue], OpaqueValue

.is_a_extract_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [OpaqueValue], OpaqueValue

.is_a_function(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_function, :LLVMIsAFunction, [OpaqueValue], OpaqueValue

.is_a_get_element_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [OpaqueValue], OpaqueValue

.is_a_global_alias(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [OpaqueValue], OpaqueValue

.is_a_global_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [OpaqueValue], OpaqueValue

.is_a_global_variable(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [OpaqueValue], OpaqueValue

.is_a_indirect_br_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [OpaqueValue], OpaqueValue

.is_a_inline_asm(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [OpaqueValue], OpaqueValue

.is_a_insert_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [OpaqueValue], OpaqueValue

.is_a_insert_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [OpaqueValue], OpaqueValue

.is_a_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_instruction, :LLVMIsAInstruction, [OpaqueValue], OpaqueValue

.is_a_int_to_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [OpaqueValue], OpaqueValue

.is_a_intrinsic_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [OpaqueValue], OpaqueValue

.is_a_invoke_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [OpaqueValue], OpaqueValue

.is_a_landing_pad_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [OpaqueValue], OpaqueValue

.is_a_load_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_load_inst, :LLVMIsALoadInst, [OpaqueValue], OpaqueValue

.is_a_mem_cpy_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [OpaqueValue], OpaqueValue

.is_a_mem_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [OpaqueValue], OpaqueValue

.is_a_mem_move_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [OpaqueValue], OpaqueValue

.is_a_mem_set_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [OpaqueValue], OpaqueValue

.is_a_ptr_to_int_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [OpaqueValue], OpaqueValue

.is_a_resume_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [OpaqueValue], OpaqueValue

.is_a_return_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [OpaqueValue], OpaqueValue

.is_a_select_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_select_inst, :LLVMIsASelectInst, [OpaqueValue], OpaqueValue

.is_a_shuffle_vector_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [OpaqueValue], OpaqueValue

.is_a_store_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [OpaqueValue], OpaqueValue

.is_a_switch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [OpaqueValue], OpaqueValue

.is_a_terminator_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [OpaqueValue], OpaqueValue

.is_a_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [OpaqueValue], OpaqueValue

.is_a_unary_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [OpaqueValue], OpaqueValue

.is_a_undef_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [OpaqueValue], OpaqueValue

.is_a_unreachable_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [OpaqueValue], OpaqueValue

.is_a_user(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_a_user, :LLVMIsAUser, [OpaqueValue], OpaqueValue

.is_af_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [OpaqueValue], OpaqueValue

.is_afp_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [OpaqueValue], OpaqueValue

.is_afp_to_si_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [OpaqueValue], OpaqueValue

.is_afp_to_ui_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [OpaqueValue], OpaqueValue

.is_afp_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [OpaqueValue], OpaqueValue

.is_ai_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [OpaqueValue], OpaqueValue

.is_amd_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_amd_node, :LLVMIsAMDNode, [OpaqueValue], OpaqueValue

.is_amd_string(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_amd_string, :LLVMIsAMDString, [OpaqueValue], OpaqueValue

.is_aphi_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_aphi_node, :LLVMIsAPHINode, [OpaqueValue], OpaqueValue

.is_as_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [OpaqueValue], OpaqueValue

.is_asi_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [OpaqueValue], OpaqueValue

.is_aui_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [OpaqueValue], OpaqueValue

.is_ava_arg_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [OpaqueValue], OpaqueValue

.is_az_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueValue)

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

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [OpaqueValue], OpaqueValue

.is_constant(val) ⇒ Integer

Determine whether the specified constant instance is constant.

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

• global (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_declaration, :LLVMIsDeclaration, [OpaqueValue], :int

.is_externally_initialized(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [OpaqueValue], :int

.is_function_var_arg(function_ty) ⇒ Integer

Returns whether a function type is variadic.

Parameters:

• function_ty (OpaqueType)

Returns:

• (Integer)

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

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [OpaqueType], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_global_constant, :LLVMIsGlobalConstant, [OpaqueValue], :int

.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 5542

attach_function :is_multithreaded, :LLVMIsMultithreaded, [], :int

.is_null(val) ⇒ Integer

Determine whether a value instance is null.

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::Constantllvm::Constant::isNullValue()

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

attach_function :is_null, :LLVMIsNull, [OpaqueValue], :int

.is_opaque_struct(struct_ty) ⇒ Integer

Determine whether a structure is opaque.

Parameters:

• struct_ty (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::StructTypellvm::StructType::isOpaque()

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

attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [OpaqueType], :int

.is_packed_struct(struct_ty) ⇒ Integer

Determine whether a structure is packed.

Parameters:

• struct_ty (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::StructTypellvm::StructType::isPacked()

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

attach_function :is_packed_struct, :LLVMIsPackedStruct, [OpaqueType], :int

.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 (OpaqueValue)

Returns:

• (Integer)

See Also:

• llvmllvm::CallInstllvm::CallInst::isTailCall()

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

attach_function :is_tail_call, :LLVMIsTailCall, [OpaqueValue], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

• global_var (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_thread_local, :LLVMIsThreadLocal, [OpaqueValue], :int

.is_undef(val) ⇒ Integer

Determine whether a value instance is undefined.

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

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

attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int

.label_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :label_type, :LLVMLabelType, [], OpaqueType

.label_type_in_context(c) ⇒ OpaqueType

Create a label type in a context.

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [OpaqueContext], OpaqueType

.link_in_interpreter ⇒ nil

(Not documented)

Returns:

• (nil)

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

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

.link_in_jit ⇒ nil

(Not documented)

Returns:

• (nil)

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

attach_function :link_in_jit, :LLVMLinkInJIT, [], :void

.link_in_mcjit ⇒ nil

(Not documented)

Returns:

• (nil)

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

attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void

.link_modules(dest, src, mode, out_message) ⇒ Integer

Links the source module into the destination module, taking ownership of the source module away from the caller. Optionally returns a human-readable description of any errors that occurred in linking. OutMessage must be disposed with LLVMDisposeMessage. The return value is true if an error occurred, false otherwise.

Parameters:

• dest (FFI::Pointer(ModuleRef))
• src (FFI::Pointer(ModuleRef))
• mode (Symbol from _enum_linker_mode_)
• out_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

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

attach_function :link_modules, :LLVMLinkModules, [:pointer, :pointer, :linker_mode, :pointer], :int

.md_node(vals, count) ⇒ OpaqueValue

Obtain a MDNode value from the global context.

Parameters:

• vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (OpaqueValue)

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

attach_function :md_node, :LLVMMDNode, [:pointer, :uint], OpaqueValue

.md_node_in_context(c, vals, count) ⇒ OpaqueValue

Obtain a MDNode value from a context.

The returned value corresponds to the llvm::MDNode class.

Parameters:

• c (OpaqueContext)
• vals (FFI::Pointer(*ValueRef))
• count (Integer)

Returns:

• (OpaqueValue)

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

attach_function :md_node_in_context, :LLVMMDNodeInContext, [OpaqueContext, :pointer, :uint], OpaqueValue

.md_string(str, s_len) ⇒ OpaqueValue

Obtain a MDString value from the global context.

Parameters:

• str (String)
• s_len (Integer)

Returns:

• (OpaqueValue)

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

attach_function :md_string, :LLVMMDString, [:string, :uint], OpaqueValue

.md_string_in_context(c, str, s_len) ⇒ OpaqueValue

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 (OpaqueContext)
• str (String)
• s_len (Integer)

Returns:

• (OpaqueValue)

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

attach_function :md_string_in_context, :LLVMMDStringInContext, [OpaqueContext, :string, :uint], OpaqueValue

.module_create_with_name(module_id) ⇒ OpaqueModule

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:

• (OpaqueModule)

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

attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], OpaqueModule

.module_create_with_name_in_context(module_id, c) ⇒ OpaqueModule

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 (OpaqueContext)

Returns:

• (OpaqueModule)

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

attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, OpaqueContext], OpaqueModule

.move_basic_block_after(bb, move_pos) ⇒ nil

Move a basic block to after another one.

Parameters:

• bb (OpaqueBasicBlock)
• move_pos (OpaqueBasicBlock)

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::moveAfter()

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

attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.move_basic_block_before(bb, move_pos) ⇒ nil

Move a basic block to before another one.

Parameters:

• bb (OpaqueBasicBlock)
• move_pos (OpaqueBasicBlock)

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::moveBefore()

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

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.offset_of_element(opaque_target_data, struct_ty, element) ⇒ Integer

Computes the byte offset of the indexed struct element for a target.

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

• opaque_target_data (OpaqueTargetData)
• struct_ty (FFI::Pointer(TypeRef))
• element (Integer)

Returns:

• (Integer)

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

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 23

attach_function :parse_bitcode, :LLVMParseBitcode, [:pointer, :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 34

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [:pointer, :pointer, :pointer, :pointer], :int

.pass_manager_builder_create ⇒ OpaquePassManagerBuilder

See llvm::PassManagerBuilder.

Returns:

• (OpaquePassManagerBuilder)

# File 'lib/llvm/transforms/builder_ffi.rb', line 25

attach_function :pass_manager_builder_create, :LLVMPassManagerBuilderCreate, [], OpaquePassManagerBuilder

.pass_manager_builder_dispose(pmb) ⇒ nil

(Not documented)

Parameters:

• pmb (OpaquePassManagerBuilder)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 33

attach_function :pass_manager_builder_dispose, :LLVMPassManagerBuilderDispose, [OpaquePassManagerBuilder], :void

.pass_manager_builder_populate_function_pass_manager(pmb, pm) ⇒ nil

See llvm::PassManagerBuilder::populateFunctionPassManager.

Parameters:

• pmb (OpaquePassManagerBuilder)
• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 96

attach_function :pass_manager_builder_populate_function_pass_manager, :LLVMPassManagerBuilderPopulateFunctionPassManager, [OpaquePassManagerBuilder, :pointer], :void

.pass_manager_builder_populate_lto_pass_manager(pmb, pm, internalize, run_inliner) ⇒ nil

See llvm::PassManagerBuilder::populateLTOPassManager.

Parameters:

• pmb (OpaquePassManagerBuilder)
• pm (FFI::Pointer(PassManagerRef))
• internalize (Integer)
• run_inliner (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 116

attach_function :pass_manager_builder_populate_lto_pass_manager, :LLVMPassManagerBuilderPopulateLTOPassManager, [OpaquePassManagerBuilder, :pointer, :int, :int], :void

.pass_manager_builder_populate_module_pass_manager(pmb, pm) ⇒ nil

See llvm::PassManagerBuilder::populateModulePassManager.

Parameters:

• pmb (OpaquePassManagerBuilder)
• pm (FFI::Pointer(PassManagerRef))

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 105

attach_function :pass_manager_builder_populate_module_pass_manager, :LLVMPassManagerBuilderPopulateModulePassManager, [OpaquePassManagerBuilder, :pointer], :void

.pass_manager_builder_set_disable_simplify_lib_calls(pmb, value) ⇒ nil

See llvm::PassManagerBuilder::DisableSimplifyLibCalls

Parameters:

• pmb (OpaquePassManagerBuilder)
• value (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 78

attach_function :pass_manager_builder_set_disable_simplify_lib_calls, :LLVMPassManagerBuilderSetDisableSimplifyLibCalls, [OpaquePassManagerBuilder, :int], :void

.pass_manager_builder_set_disable_unit_at_a_time(pmb, value) ⇒ nil

See llvm::PassManagerBuilder::DisableUnitAtATime.

Parameters:

• pmb (OpaquePassManagerBuilder)
• value (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 60

attach_function :pass_manager_builder_set_disable_unit_at_a_time, :LLVMPassManagerBuilderSetDisableUnitAtATime, [OpaquePassManagerBuilder, :int], :void

.pass_manager_builder_set_disable_unroll_loops(pmb, value) ⇒ nil

See llvm::PassManagerBuilder::DisableUnrollLoops.

Parameters:

• pmb (OpaquePassManagerBuilder)
• value (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 69

attach_function :pass_manager_builder_set_disable_unroll_loops, :LLVMPassManagerBuilderSetDisableUnrollLoops, [OpaquePassManagerBuilder, :int], :void

.pass_manager_builder_set_opt_level(pmb, opt_level) ⇒ nil

See llvm::PassManagerBuilder::OptLevel.

Parameters:

• pmb (OpaquePassManagerBuilder)
• opt_level (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 42

attach_function :pass_manager_builder_set_opt_level, :LLVMPassManagerBuilderSetOptLevel, [OpaquePassManagerBuilder, :uint], :void

.pass_manager_builder_set_size_level(pmb, size_level) ⇒ nil

See llvm::PassManagerBuilder::SizeLevel.

Parameters:

• pmb (OpaquePassManagerBuilder)
• size_level (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 51

attach_function :pass_manager_builder_set_size_level, :LLVMPassManagerBuilderSetSizeLevel, [OpaquePassManagerBuilder, :uint], :void

.pass_manager_builder_use_inliner_with_threshold(pmb, threshold) ⇒ nil

See llvm::PassManagerBuilder::Inliner.

Parameters:

• pmb (OpaquePassManagerBuilder)
• threshold (Integer)

Returns:

• (nil)

# File 'lib/llvm/transforms/builder_ffi.rb', line 87

attach_function :pass_manager_builder_use_inliner_with_threshold, :LLVMPassManagerBuilderUseInlinerWithThreshold, [OpaquePassManagerBuilder, :uint], :void

.pointer_size(opaque_target_data) ⇒ Integer

Returns the pointer size in bytes for a target.

See the method llvm::DataLayout::getPointerSize.

Parameters:

• opaque_target_data (OpaqueTargetData)

Returns:

• (Integer)

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

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_size_for_as(opaque_target_data, as) ⇒ Integer

Returns the pointer size in bytes for a target for a specified

address space.
See the method llvm::DataLayout::getPointerSize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• as (Integer)

Returns:

• (Integer)

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

attach_function :pointer_size_for_as, :LLVMPointerSizeForAS, [OpaqueTargetData, :uint], :uint

.pointer_type(element_type, address_space) ⇒ OpaqueType

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 (OpaqueType)
• address_space (Integer)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::PointerTypellvm::PointerType::get()

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

attach_function :pointer_type, :LLVMPointerType, [OpaqueType, :uint], OpaqueType

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• block (OpaqueBasicBlock)
• instr (OpaqueValue)

Returns:

• (nil)

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

attach_function :position_builder, :LLVMPositionBuilder, [OpaqueBuilder, OpaqueBasicBlock, OpaqueValue], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• block (OpaqueBasicBlock)

Returns:

• (nil)

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

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [OpaqueBuilder, OpaqueBasicBlock], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• instr (OpaqueValue)

Returns:

• (nil)

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

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [OpaqueBuilder, OpaqueValue], :void

.ppcfp128_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], OpaqueType

.ppcfp128_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [OpaqueContext], OpaqueType

.preferred_alignment_of_global(opaque_target_data, global_var) ⇒ Integer

Computes the preferred alignment of a global variable in bytes for a target.

See the method llvm::DataLayout::getPreferredAlignment.

Parameters:

• opaque_target_data (OpaqueTargetData)
• global_var (FFI::Pointer(ValueRef))

Returns:

• (Integer)

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

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, :pointer], :uint

.preferred_alignment_of_type(opaque_target_data, type_ref) ⇒ Integer

Computes the preferred alignment of a type in bytes for a target.

See the method llvm::DataLayout::getTypeABISize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

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 (OpaqueModule)
• filename (String)
• error_message (FFI::Pointer(**CharS))

Returns:

• (Integer)

See Also:

• Module::print()

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

attach_function :print_module_to_file, :LLVMPrintModuleToFile, [OpaqueModule, :string, :pointer], :int

.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 343

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, :pointer], :pointer

.remove_attribute(arg, pa) ⇒ nil

Remove an attribute from a function argument.

Parameters:

• arg (OpaqueValue)
• pa (Symbol from _enum_attribute_)

Returns:

• (nil)

See Also:

• llvmllvm::Argumentllvm::Argument::removeAttr()

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

attach_function :remove_attribute, :LLVMRemoveAttribute, [OpaqueValue, :attribute], :void

.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 (OpaqueBasicBlock)

Returns:

• (nil)

See Also:

• llvmllvm::BasicBlockllvm::BasicBlock::removeFromParent()

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

attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [OpaqueBasicBlock], :void

.remove_function_attr(fn, pa) ⇒ nil

Remove an attribute from a function.

Parameters:

• fn (OpaqueValue)
• pa (Symbol from _enum_attribute_)

Returns:

• (nil)

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

attach_function :remove_function_attr, :LLVMRemoveFunctionAttr, [OpaqueValue, :attribute], :void

.remove_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

• instr (OpaqueValue)
• index (Integer)
• attribute (Symbol from _enum_attribute_)

Returns:

• (nil)

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

attach_function :remove_instr_attribute, :LLVMRemoveInstrAttribute, [OpaqueValue, :uint, :attribute], :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 313

attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int

.remove_module_provider(ee, mp, out_mod, out_error) ⇒ Integer

Deprecated: Use LLVMRemoveModule instead.

Parameters:

• ee (OpaqueExecutionEngine)
• mp (FFI::Pointer(ModuleProviderRef))
• out_mod (FFI::Pointer(*ModuleRef))
• out_error (FFI::Pointer(**CharS))

Returns:

• (Integer)

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

attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [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 (OpaqueValue)
• new_val (OpaqueValue)

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::replaceAllUsesWith()

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

attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [OpaqueValue, OpaqueValue], :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 275

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 264

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 (OpaquePassManager)
• f (OpaqueValue)

Returns:

• (Integer)

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

attach_function :run_function_pass_manager, :LLVMRunFunctionPassManager, [OpaquePassManager, OpaqueValue], :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 (OpaquePassManager)
• m (OpaqueModule)

Returns:

• (Integer)

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

attach_function :run_pass_manager, :LLVMRunPassManager, [OpaquePassManager, OpaqueModule], :int

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

• ee (OpaqueExecutionEngine)

Returns:

• (nil)

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

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 252

attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void

.set_alignment(global, bytes) ⇒ nil

(Not documented)

Parameters:

• global (OpaqueValue)
• bytes (Integer)

Returns:

• (nil)

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

attach_function :set_alignment, :LLVMSetAlignment, [OpaqueValue, :uint], :void

.set_cleanup(landing_pad, val) ⇒ nil

Set the ‘cleanup’ flag in the landingpad instruction

Parameters:

• landing_pad (OpaqueValue)
• val (Integer)

Returns:

• (nil)

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

attach_function :set_cleanup, :LLVMSetCleanup, [OpaqueValue, :int], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

• builder (OpaqueBuilder)
• l (OpaqueValue)

Returns:

• (nil)

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

attach_function :set_current_debug_location, :LLVMSetCurrentDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_data_layout(m, triple) ⇒ nil

Set the data layout for a module.

Parameters:

• m (OpaqueModule)
• triple (String)

Returns:

• (nil)

See Also:

• Module::setDataLayout()

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

attach_function :set_data_layout, :LLVMSetDataLayout, [OpaqueModule, :string], :void

.set_externally_initialized(global_var, is_ext_init) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)
• is_ext_init (Integer)

Returns:

• (nil)

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

attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [OpaqueValue, :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 (OpaqueValue)
• cc (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::setCallingConv()

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

attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [OpaqueValue, :uint], :void

.set_gc(fn, name) ⇒ nil

Define the garbage collector to use during code generation.

Parameters:

• fn (OpaqueValue)
• name (String)

Returns:

• (nil)

See Also:

• llvmllvm::Functionllvm::Function::setGC()

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

attach_function :set_gc, :LLVMSetGC, [OpaqueValue, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)
• is_constant (Integer)

Returns:

• (nil)

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

attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)
• constant_val (OpaqueValue)

Returns:

• (nil)

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

attach_function :set_initializer, :LLVMSetInitializer, [OpaqueValue, OpaqueValue], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

• builder (OpaqueBuilder)
• inst (OpaqueValue)

Returns:

• (nil)

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

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

• instr (OpaqueValue)
• index (Integer)
• align (Integer)

Returns:

• (nil)

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

attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [OpaqueValue, :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 (OpaqueValue)
• cc (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::CallInstllvm::CallInst::setCallingConv()
• llvmllvm::InvokeInstllvm::InvokeInst::setCallingConv()

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

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [OpaqueValue, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

• global (OpaqueValue)
• linkage (Symbol from _enum_linkage_)

Returns:

• (nil)

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

attach_function :set_linkage, :LLVMSetLinkage, [OpaqueValue, :linkage], :void

.set_metadata(val, kind_id, node) ⇒ nil

Set metadata associated with an instruction value.

Parameters:

• val (OpaqueValue)
• kind_id (Integer)
• node (OpaqueValue)

Returns:

• (nil)

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

attach_function :set_metadata, :LLVMSetMetadata, [OpaqueValue, :uint, OpaqueValue], :void

.set_module_inline_asm(m, asm) ⇒ nil

Set inline assembly for a module.

Parameters:

• m (OpaqueModule)
• asm (String)

Returns:

• (nil)

See Also:

• Module::setModuleInlineAsm()

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

attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [OpaqueModule, :string], :void

.set_operand(user, index, val) ⇒ nil

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

Parameters:

• user (OpaqueValue)
• index (Integer)
• val (OpaqueValue)

Returns:

• (nil)

See Also:

• llvmllvm::Userllvm::User::setOperand()

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

attach_function :set_operand, :LLVMSetOperand, [OpaqueValue, :uint, OpaqueValue], :void

.set_param_alignment(arg, align) ⇒ nil

Set the alignment for a function parameter.

Parameters:

• arg (OpaqueValue)
• align (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::Argumentllvm::Argument::addAttr()
• llvmllvm::AttrBuilderllvm::AttrBuilder::addAlignmentAttr()

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

attach_function :set_param_alignment, :LLVMSetParamAlignment, [OpaqueValue, :uint], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

• global (OpaqueValue)
• section (String)

Returns:

• (nil)

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

attach_function :set_section, :LLVMSetSection, [OpaqueValue, :string], :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 (OpaqueValue)
• is_tail_call (Integer)

Returns:

• (nil)

See Also:

• llvmllvm::CallInstllvm::CallInst::setTailCall()

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

attach_function :set_tail_call, :LLVMSetTailCall, [OpaqueValue, :int], :void

.set_target(m, triple) ⇒ nil

Set the target triple for a module.

Parameters:

• m (OpaqueModule)
• triple (String)

Returns:

• (nil)

See Also:

• Module::setTargetTriple()

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

attach_function :set_target, :LLVMSetTarget, [OpaqueModule, :string], :void

.set_thread_local(global_var, is_thread_local) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)
• is_thread_local (Integer)

Returns:

• (nil)

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

attach_function :set_thread_local, :LLVMSetThreadLocal, [OpaqueValue, :int], :void

.set_thread_local_mode(global_var, mode) ⇒ nil

(Not documented)

Parameters:

• global_var (OpaqueValue)
• mode (Symbol from _enum_thread_local_mode_)

Returns:

• (nil)

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

attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [OpaqueValue, :thread_local_mode], :void

.set_value_name(val, name) ⇒ nil

Set the string name of a value.

Parameters:

• val (OpaqueValue)
• name (String)

Returns:

• (nil)

See Also:

• llvmllvm::Valuellvm::Value::setName()

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

attach_function :set_value_name, :LLVMSetValueName, [OpaqueValue, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

• global (OpaqueValue)
• viz (Symbol from _enum_visibility_)

Returns:

• (nil)

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

attach_function :set_visibility, :LLVMSetVisibility, [OpaqueValue, :visibility], :void

.set_volatile(memory_access_inst, is_volatile) ⇒ nil

(Not documented)

Parameters:

• memory_access_inst (OpaqueValue)
• is_volatile (Integer)

Returns:

• (nil)

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

attach_function :set_volatile, :LLVMSetVolatile, [OpaqueValue, :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 784

attach_function :shutdown, :LLVMShutdown, [], :void

.size_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

• ty (OpaqueType)

Returns:

• (OpaqueValue)

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

attach_function :size_of, :LLVMSizeOf, [OpaqueType], OpaqueValue

.size_of_type_in_bits(opaque_target_data, type_ref) ⇒ Integer

Computes the size of a type in bytes for a target.

See the method llvm::DataLayout::getTypeSizeInBits.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, :pointer], :ulong_long

.start_multithreaded ⇒ Integer

Allocate and initialize structures needed to make LLVM safe for

multithreading. The return value indicates whether multithreaded
initialization succeeded. Must be executed in isolation from all
other LLVM api calls.
@see llvm::llvm_start_multithreaded

Returns:

• (Integer)

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

attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int

.stop_multithreaded ⇒ nil

Deallocate structures necessary to make LLVM safe for multithreading.

Must be executed in isolation from all other LLVM api calls.
@see llvm::llvm_stop_multithreaded

Returns:

• (nil)

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

attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void

.store_size_of_type(opaque_target_data, type_ref) ⇒ Integer

Computes the storage size of a type in bytes for a target.

See the method llvm::DataLayout::getTypeStoreSize.

Parameters:

• opaque_target_data (OpaqueTargetData)
• type_ref (FFI::Pointer(TypeRef))

Returns:

• (Integer)

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

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, :pointer], :ulong_long

.struct_create_named(c, name) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)
• name (String)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::StructTypellvm::StructType::create()

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

attach_function :struct_create_named, :LLVMStructCreateNamed, [OpaqueContext, :string], OpaqueType

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

Set the contents of a structure type.

Parameters:

• struct_ty (OpaqueType)
• 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 1423

attach_function :struct_set_body, :LLVMStructSetBody, [OpaqueType, :pointer, :uint, :int], :void

.struct_type(element_types, element_count, packed) ⇒ OpaqueType

Create a new structure type in the global context.

Parameters:

• element_types (FFI::Pointer(*TypeRef))
• element_count (Integer)
• packed (Integer)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::StructTypellvm::StructType::create()

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

attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], OpaqueType

.struct_type_in_context(c, element_types, element_count, packed) ⇒ OpaqueType

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 (OpaqueContext)
• element_types (FFI::Pointer(*TypeRef))
• element_count (Integer)
• packed (Integer)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::StructTypellvm::StructType::create()

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

attach_function :struct_type_in_context, :LLVMStructTypeInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueType

.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 475

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 459

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 467

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 558

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 570

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 (OpaqueType)

Returns:

• (Integer)

See Also:

• llvmllvm::Typellvm::Type::isSized()

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

attach_function :type_is_sized, :LLVMTypeIsSized, [OpaqueType], :int

.type_of(val) ⇒ OpaqueType

Obtain the type of a value.

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::Valuellvm::Value::getType()

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

attach_function :type_of, :LLVMTypeOf, [OpaqueValue], OpaqueType

.value_as_basic_block(val) ⇒ OpaqueBasicBlock

Convert a LLVMValueRef to a LLVMBasicBlockRef instance.

Parameters:

• val (OpaqueValue)

Returns:

• (OpaqueBasicBlock)

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

attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [OpaqueValue], OpaqueBasicBlock

.value_is_basic_block(val) ⇒ Integer

Determine whether a LLVMValueRef is itself a basic block.

Parameters:

• val (OpaqueValue)

Returns:

• (Integer)

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

attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [OpaqueValue], :int

.vector_type(element_type, element_count) ⇒ OpaqueType

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 (OpaqueType)
• element_count (Integer)

Returns:

• (OpaqueType)

See Also:

• llvmllvm::VectorTypellvm::VectorType::get()

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

attach_function :vector_type, :LLVMVectorType, [OpaqueType, :uint], OpaqueType

.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 56

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 46

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 65

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 73

attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [:pointer], :void

.void_type ⇒ OpaqueType

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

Returns:

• (OpaqueType)

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

attach_function :void_type, :LLVMVoidType, [], OpaqueType

.void_type_in_context(c) ⇒ OpaqueType

Create a void type in a context.

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :void_type_in_context, :LLVMVoidTypeInContext, [OpaqueContext], OpaqueType

.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 98

attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [:pointer, :int, :int, :int], :int

.write_bitcode_to_file(m, path) ⇒ Integer

(Not documented)

Parameters:

• m (FFI::Pointer(ModuleRef))
• path (String)

Returns:

• (Integer)

# File 'lib/llvm/core/bitcode_ffi.rb', line 87

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 108

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [:pointer, :int], :int

.x86fp80_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :x86fp80_type, :LLVMX86FP80Type, [], OpaqueType

.x86fp80_type_in_context(c) ⇒ OpaqueType

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

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [OpaqueContext], OpaqueType

.x86mmx_type ⇒ OpaqueType

(Not documented)

Returns:

• (OpaqueType)

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

attach_function :x86mmx_type, :LLVMX86MMXType, [], OpaqueType

.x86mmx_type_in_context(c) ⇒ OpaqueType

Create a X86 MMX type in a context.

Parameters:

• c (OpaqueContext)

Returns:

• (OpaqueType)

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

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [OpaqueContext], OpaqueType