Module: LLVM::C

Extended by:
FFI::Library
Defined in:
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, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMCJITMemoryManager, OpaquePassManagerBuilder, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, Target

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

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

Contexts are execution states for the core LLVM IR system.

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

@{

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (FFI::Pointer(DiagnosticInfoRef))


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

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

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

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

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer)


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

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

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

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer)


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

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

._callback_memory_manager_finalize_memory_callback_(bool, opaque, err_msg) ⇒ Integer

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer)


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

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

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

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (FFI::Pointer(ContextRef))


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

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

._enum_atomic_ordering_Symbol

(Not documented)

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

Options:

:not_atomic
:unordered

< A load or store which is not atomic

:monotonic

< Lowest level of atomicity, guarantees

somewhat sane results, lock free.
:acquire

< guarantees that if you take all the

operations affecting a specific address,
a consistent ordering exists
:release

< Acquire provides a barrier of the sort

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

< Release is similar to Acquire, but with

a barrier of the sort necessary to release
a lock.
:sequentially_consistent

< provides both an Acquire and a

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

Returns:

  • (Symbol)


737
738
739
740
741
742
743
744
745
# File 'lib/llvm/core_ffi.rb', line 737

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

._enum_atomic_rmw_bin_op_Symbol

(Not documented)

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

Options:

:xchg
:add

< Set the new value and return the one old

:sub

< Add a value and return the old one

:and_

< Subtract a value and return the old one

:nand

< And a value and return the old one

:or_

< Not-And a value and return the old one

:xor

< OR a value and return the old one

:max

< Xor a value and return the old one

:min

< Sets the value if it’s greater than the

original using a signed comparison and return
the old one
:u_max

< Sets the value if it’s Smaller than the

original using a signed comparison and return
the old one
:u_min

< Sets the value if it’s greater than the

original using an unsigned comparison and return
the old one

Returns:

  • (Symbol)


784
785
786
787
788
789
790
791
792
793
794
795
796
# File 'lib/llvm/core_ffi.rb', line 784

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

Returns:

  • (Symbol)


120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
# File 'lib/llvm/core_ffi.rb', line 120

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

._enum_byte_ordering_Symbol

(Not documented)

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

Options:

:big_endian
:little_endian

Returns:

  • (Symbol)


28
29
30
31
# 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
:web_kit_js
:any_reg
:x86_stdcall
:x86_fastcall

Returns:

  • (Symbol)


547
548
549
550
551
552
553
554
555
# File 'lib/llvm/core_ffi.rb', line 547

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

._enum_code_gen_file_type_Symbol

(Not documented)

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

Options:

:assembly
:object

Returns:

  • (Symbol)


426
427
428
429
# File 'lib/llvm/target_ffi.rb', line 426

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)


352
353
354
355
356
357
# File 'lib/llvm/target_ffi.rb', line 352

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)


404
405
406
407
408
409
410
411
# File 'lib/llvm/target_ffi.rb', line 404

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

._enum_diagnostic_severity_Symbol

(Not documented)

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

Options:

:ds_error
:ds_warning
:ds_remark
:ds_note

Returns:

  • (Symbol)


815
816
817
818
819
820
# File 'lib/llvm/core_ffi.rb', line 815

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

._enum_dll_storage_class_Symbol

(Not documented)

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

Options:

:default
:dll_import
:dll_export

< Function to be imported from DLL.

Returns:

  • (Symbol)


518
519
520
521
522
# File 'lib/llvm/core_ffi.rb', line 518

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

._enum_int_predicate_Symbol

(Not documented)

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

Options:

:eq
:ne

< equal

:ugt

< not equal

:uge

< unsigned greater than

:ult

< unsigned greater or equal

:ule

< unsigned less than

:sgt

< unsigned less or equal

:sge

< signed greater than

:slt

< signed greater or equal

:sle

< signed less than

Returns:

  • (Symbol)


586
587
588
589
590
591
592
593
594
595
596
597
# File 'lib/llvm/core_ffi.rb', line 586

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)


672
673
674
675
# File 'lib/llvm/core_ffi.rb', line 672

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

._enum_linkage_Symbol

(Not documented)

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

Options:

:external
:available_externally

< Externally visible function

:link_once_any
:link_once_odr

< Keep one copy of function when linking (inline)

:link_once_odr_auto_hide

< Same, but only replaced by something

equivalent.
:weak_any

< Obsolete

:weak_odr

< Keep one copy of function when linking (weak)

:appending

< Same, but only replaced by something

equivalent.
:internal

< Special purpose, only applies to global arrays

:private

< Rename collisions when linking (static

functions)
:dll_import

< Like Internal, but omit from symbol table

:dll_export

< Obsolete

:external_weak

< Obsolete

:ghost

< ExternalWeak linkage description

:common

< Obsolete

:linker_private

< Tentative definitions

:linker_private_weak

< Like Private, but linker removes.

Returns:

  • (Symbol)


462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
# File 'lib/llvm/core_ffi.rb', line 462

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

._enum_linker_mode_Symbol

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

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

Options:

:destroy_source
:preserve_source_removed

This is the default behavior.

Returns:

  • (Symbol)


28
29
30
31
# File 'lib/llvm/linker_ffi.rb', line 28

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

._enum_opcode_Symbol

(Not documented)

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

Options:

:ret

Terminator Instructions

:br
:switch
:indirect_br
:invoke
:unreachable

removed 6 due to API changes

:add

Standard Binary Operators

:f_add
:sub
:f_sub
:mul
:f_mul
:u_div
:s_div
:f_div
:u_rem
:s_rem
:f_rem
:shl

Logical Operators

:l_shr
:a_shr
:and_
:or_
:xor
:alloca

Memory Operators

:load
:store
:get_element_ptr
:trunc

Cast Operators

:z_ext
:s_ext
:fp_to_ui
:fp_to_si
:ui_to_fp
:si_to_fp
:fp_trunc
:fp_ext
:ptr_to_int
:int_to_ptr
:bit_cast
:addr_space_cast
:i_cmp

Other Operators

:f_cmp
:phi
:call
:select
:user_op1
:user_op2
:va_arg
:extract_element
:insert_element
:shuffle_vector
:extract_value
:insert_value
:fence

Atomic operators

:atomic_cmp_xchg
:atomic_rmw
:resume

Exception Handling Operators

:landing_pad
:cleanup_ret
:catch_ret
:catch_pad
:cleanup_pad
:catch_switch

Returns:

  • (Symbol)


286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
# File 'lib/llvm/core_ffi.rb', line 286

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

._enum_real_predicate_Symbol

(Not documented)

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

Options:

:predicate_false
:oeq

< Always false (always folded)

:ogt

< True if ordered and equal

:oge

< True if ordered and greater than

:olt

< True if ordered and greater than or equal

:ole

< True if ordered and less than

:one

< True if ordered and less than or equal

:ord

< True if ordered and operands are unequal

:uno

< True if ordered (no nans)

:ueq

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

:ugt

< True if unordered or equal

:uge

< True if unordered or greater than

:ult

< True if unordered, greater than, or equal

:ule

< True if unordered or less than

:une

< True if unordered, less than, or equal

:predicate_true

< True if unordered or not equal

Returns:

  • (Symbol)


640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
# File 'lib/llvm/core_ffi.rb', line 640

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)


376
377
378
379
380
381
# File 'lib/llvm/target_ffi.rb', line 376

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)


696
697
698
699
700
701
702
# File 'lib/llvm/core_ffi.rb', line 696

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

._enum_type_kind_Symbol

(Not documented)

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

Options:

:void
:half

< type with no size

:float

< 16 bit floating point type

:double

< 32 bit floating point type

:x86_fp80

< 64 bit floating point type

:fp128

< 80 bit floating point type (X87)

:ppc_fp128

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

:label

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

:integer

< Labels

:function

< Arbitrary bit width integers

:struct

< Functions

:array

< Structures

:pointer

< Arrays

:vector

< Pointers

:metadata

< SIMD ‘packed’ format, or other vector type

:x86_mmx

< Metadata

:token

< X86 MMX

Returns:

  • (Symbol)


396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
# File 'lib/llvm/core_ffi.rb', line 396

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

._enum_verifier_failure_action_Symbol

@{

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

Options:

:abort_process
:print_message

verifier will print to stderr and abort()

:return_status

verifier will print to stderr and return 1

Returns:

  • (Symbol)


33
34
35
36
37
# File 'lib/llvm/analysis_ffi.rb', line 33

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)


497
498
499
500
501
# File 'lib/llvm/core_ffi.rb', line 497

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

.abi_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

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

.abi_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

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

.add_aggressive_dce_pass(pm) ⇒ nil

See llvm::createAggressiveDCEPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

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

This group contains function that operate on global alias values.

@{

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::GlobalAlias


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

attach_function :add_alias, :LLVMAddAlias, [:pointer, :pointer, :pointer, :string], :pointer

.add_alignment_from_assumptions_pass(pm) ⇒ nil

See llvm::createAlignmentFromAssumptionsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_alignment_from_assumptions_pass, :LLVMAddAlignmentFromAssumptionsPass, [:pointer], :void

.add_always_inliner_pass(pm) ⇒ nil

See llvm::createAlwaysInlinerPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_analysis_passes(t, pm) ⇒ nil

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

Parameters:

Returns:

  • (nil)


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

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

.add_argument_promotion_pass(pm) ⇒ nil

See llvm::createArgumentPromotionPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_basic_alias_analysis_pass(pm) ⇒ nil

See llvm::createBasicAliasAnalysisPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_bb_vectorize_pass(pm) ⇒ nil

DEPRECATED - Use LLVMAddSLPVectorizePass

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_bit_tracking_dce_pass(pm) ⇒ nil

See llvm::createBitTrackingDCEPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_bit_tracking_dce_pass, :LLVMAddBitTrackingDCEPass, [:pointer], :void

.add_case(switch, on_val, dest) ⇒ nil

Add a case to the switch instruction

Parameters:

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

Returns:

  • (nil)


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

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

.add_cfg_simplification_pass(pm) ⇒ nil

See llvm::createCFGSimplificationPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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 (FFI::Pointer(ValueRef))
  • clause_val (FFI::Pointer(ValueRef))

Returns:

  • (nil)


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

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

.add_constant_merge_pass(pm) ⇒ nil

See llvm::createConstantMergePass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


29
# 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)


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

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)


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

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)


37
# 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)


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

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)


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

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 (FFI::Pointer(ValueRef))
  • dest (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)


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

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

.add_early_cse_mem_ssa_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_early_cse_mem_ssa_pass, :LLVMAddEarlyCSEMemSSAPass, [:pointer], :void

.add_early_cse_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

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

Add a function to a module under a specified name.

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

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


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

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

.add_function_attrs_pass(pm) ⇒ nil

See llvm::createFunctionAttrsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


45
# 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)


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

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

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

This group contains functions that operate on global variable values.

@{

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::GlobalVariable


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

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

.add_global_dce_pass(pm) ⇒ nil

See llvm::createGlobalDCEPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


69
# 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) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.add_global_mapping(ee, global, addr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

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)


77
# 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)


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

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 (FFI::Pointer(ValueRef))
  • incoming_values (FFI::Pointer(*ValueRef))
  • incoming_blocks (FFI::Pointer(*BasicBlockRef))
  • count (Integer)

Returns:

  • (nil)


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

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

.add_ind_var_simplify_pass(pm) ⇒ nil

See llvm::createIndVarSimplifyPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_instruction_combining_pass(pm) ⇒ nil

See llvm::createInstructionCombiningPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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)


110
# 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)


85
# 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)


101
# 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)


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

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

.add_late_cfg_simplification_pass(pm) ⇒ nil

See llvm::createLateCFGSimplificationPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_late_cfg_simplification_pass, :LLVMAddLateCFGSimplificationPass, [:pointer], :void

.add_licm_pass(pm) ⇒ nil

See llvm::createLICMPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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)


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

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)


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

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

.add_loop_reroll_pass(pm) ⇒ nil

See llvm::createLoopRerollPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_loop_reroll_pass, :LLVMAddLoopRerollPass, [:pointer], :void

.add_loop_rotate_pass(pm) ⇒ nil

See llvm::createLoopRotatePass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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)


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

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)


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

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)


29
# 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)


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

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

.add_lower_switch_pass(pm) ⇒ nil

See llvm::createLowerSwitchPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_lower_switch_pass, :LLVMAddLowerSwitchPass, [:pointer], :void

.add_mem_cpy_opt_pass(pm) ⇒ nil

See llvm::createMemCpyOptPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_mem_cpy_opt_pass, :LLVMAddMemCpyOptPass, [:pointer], :void

.add_merged_load_store_motion_pass(pm) ⇒ nil

See llvm::createMergedLoadStoreMotionPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_merged_load_store_motion_pass, :LLVMAddMergedLoadStoreMotionPass, [:pointer], :void

.add_module(ee, m) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

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

.add_named_metadata_operand(m, name, val) ⇒ nil

Add an operand to named metadata.

Parameters:

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

Returns:

  • (nil)

See Also:

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


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

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

.add_new_gvn_pass(pm) ⇒ nil

See llvm::createGVNPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_new_gvn_pass, :LLVMAddNewGVNPass, [:pointer], :void

.add_partially_inline_lib_calls_pass(pm) ⇒ nil

See llvm::createPartiallyInlineLibCallsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_partially_inline_lib_calls_pass, :LLVMAddPartiallyInlineLibCallsPass, [:pointer], :void

.add_promote_memory_to_register_pass(pm) ⇒ nil

See llvm::createPromoteMemoryToRegisterPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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)


93
# 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)


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

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

.add_scalar_repl_aggregates_pass(pm) ⇒ nil

See llvm::createSROAPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_scalar_repl_aggregates_pass_ssa(pm) ⇒ nil

See llvm::createSROAPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_scalar_repl_aggregates_pass_with_threshold(pm, threshold) ⇒ nil

See llvm::createSROAPass function.

Parameters:

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

Returns:

  • (nil)


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

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

.add_scalarizer_pass(pm) ⇒ nil

See llvm::createScalarizerPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_scalarizer_pass, :LLVMAddScalarizerPass, [:pointer], :void

.add_sccp_pass(pm) ⇒ nil

See llvm::createSCCPPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_scoped_no_alias_aa_pass(pm) ⇒ nil

See llvm::createScopedNoAliasAAPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :add_scoped_no_alias_aa_pass, :LLVMAddScopedNoAliasAAPass, [:pointer], :void

.add_simplify_lib_calls_pass(pm) ⇒ nil

See llvm::createSimplifyLibCallsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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)


37
# 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)


118
# 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)


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

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

.add_symbol(symbol_name, symbol_value) ⇒ nil

(Not documented)

Parameters:

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

Returns:

  • (nil)


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

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

.add_tail_call_elimination_pass(pm) ⇒ nil

See llvm::createTailCallEliminationPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

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

.add_target_dependent_function_attr(fn, a, v) ⇒ nil

Add a target-dependent attribute to a function

Parameters:

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

Returns:

  • (nil)

See Also:

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


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

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

.add_target_library_info(tli, pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

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)


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

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)


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

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

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

(Not documented)

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

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

Parameters:

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

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

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


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

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

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

Append a basic block to the end of a function.

Parameters:

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

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

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


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

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

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

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

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

Parameters:

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

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

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


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

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

.attach_function(name, *_) ⇒ Object



9
10
11
12
13
# 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) ⇒ FFI::Pointer(ValueRef)

Convert a basic block instance to a value type.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

Arithmetic

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.build_call(builder_ref, fn, args, num_args, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))
  • fn (FFI::Pointer(ValueRef))
  • args (FFI::Pointer(*ValueRef))
  • num_args (Integer)
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.build_gep(b, pointer, indices, num_indices, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

Comparisons

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.build_in_bounds_gep(b, pointer, indices, num_indices, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.build_invoke(builder_ref, fn, args, num_args, then_, catch, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))
  • fn (FFI::Pointer(ValueRef))
  • args (FFI::Pointer(*ValueRef))
  • num_args (Integer)
  • then_ (FFI::Pointer(BasicBlockRef))
  • catch (FFI::Pointer(BasicBlockRef))
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_invoke, :LLVMBuildInvoke, [:pointer, :pointer, :pointer, :uint, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.build_load(builder_ref, pointer_val, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_load, :LLVMBuildLoad, [:pointer, :pointer, :string], :pointer

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

Memory

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_not, :LLVMBuildNot, [:pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nsw_add, :LLVMBuildNSWAdd, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nsw_mul, :LLVMBuildNSWMul, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nsw_neg, :LLVMBuildNSWNeg, [:pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nsw_sub, :LLVMBuildNSWSub, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nuw_add, :LLVMBuildNUWAdd, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nuw_mul, :LLVMBuildNUWMul, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nuw_neg, :LLVMBuildNUWNeg, [:pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_nuw_sub, :LLVMBuildNUWSub, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_or, :LLVMBuildOr, [:pointer, :pointer, :pointer, :string], :pointer

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

Miscellaneous instructions

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_phi, :LLVMBuildPhi, [:pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_pointer_cast, :LLVMBuildPointerCast, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_ptr_diff, :LLVMBuildPtrDiff, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_ptr_to_int, :LLVMBuildPtrToInt, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

  • b (FFI::Pointer(BuilderRef))
  • exn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_resume, :LLVMBuildResume, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_ret, :LLVMBuildRet, [:pointer, :pointer], :pointer

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

Terminators

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_ret_void, :LLVMBuildRetVoid, [:pointer], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_s_div, :LLVMBuildSDiv, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_s_ext, :LLVMBuildSExt, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_s_ext_or_bit_cast, :LLVMBuildSExtOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_s_rem, :LLVMBuildSRem, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_select, :LLVMBuildSelect, [:pointer, :pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_shl, :LLVMBuildShl, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))
  • v1 (FFI::Pointer(ValueRef))
  • v2 (FFI::Pointer(ValueRef))
  • mask (FFI::Pointer(ValueRef))
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_shuffle_vector, :LLVMBuildShuffleVector, [:pointer, :pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_si_to_fp, :LLVMBuildSIToFP, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))
  • val (FFI::Pointer(ValueRef))
  • ptr (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_store, :LLVMBuildStore, [:pointer, :pointer, :pointer], :pointer

.build_struct_gep(b, pointer, idx, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • b (FFI::Pointer(BuilderRef))
  • pointer (FFI::Pointer(ValueRef))
  • idx (Integer)
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_struct_gep, :LLVMBuildStructGEP, [:pointer, :pointer, :uint, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_sub, :LLVMBuildSub, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))
  • v (FFI::Pointer(ValueRef))
  • else_ (FFI::Pointer(BasicBlockRef))
  • num_cases (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_switch, :LLVMBuildSwitch, [:pointer, :pointer, :pointer, :uint], :pointer

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

Casts

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_trunc, :LLVMBuildTrunc, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_trunc_or_bit_cast, :LLVMBuildTruncOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_u_div, :LLVMBuildUDiv, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_u_rem, :LLVMBuildURem, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_ui_to_fp, :LLVMBuildUIToFP, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

  • builder_ref (FFI::Pointer(BuilderRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_unreachable, :LLVMBuildUnreachable, [:pointer], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_va_arg, :LLVMBuildVAArg, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_xor, :LLVMBuildXor, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_z_ext, :LLVMBuildZExt, [:pointer, :pointer, :pointer, :string], :pointer

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

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :build_z_ext_or_bit_cast, :LLVMBuildZExtOrBitCast, [:pointer, :pointer, :pointer, :string], :pointer

.byte_order(td) ⇒ Symbol from _enum_byte_ordering_

(Not documented)

Parameters:

Returns:



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

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

.call_frame_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

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

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))

Returns:

  • (nil)


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

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

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

Return an exact copy of the specified module.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ModuleRef))


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

attach_function :clone_module, :LLVMCloneModule, [:pointer], :pointer

.const_a_shr(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_a_shr, :LLVMConstAShr, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_add, :LLVMConstAdd, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_addr_space_cast, :LLVMConstAddrSpaceCast, [:pointer, :pointer], :pointer

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

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

This is only valid for integer types.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

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


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

attach_function :const_all_ones, :LLVMConstAllOnes, [:pointer], :pointer

.const_and(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_and, :LLVMConstAnd, [:pointer, :pointer], :pointer

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

Create a ConstantArray from values.

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

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


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

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

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_bit_cast, :LLVMConstBitCast, [:pointer, :pointer], :pointer

.const_exact_s_div(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_exact_s_div, :LLVMConstExactSDiv, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • vector_constant (FFI::Pointer(ValueRef))
  • index_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_extract_element, :LLVMConstExtractElement, [:pointer, :pointer], :pointer

.const_extract_value(agg_constant, idx_list, num_idx) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.const_f_add(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_add, :LLVMConstFAdd, [:pointer, :pointer], :pointer

.const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • predicate (Symbol from _enum_real_predicate_)
  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

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

.const_f_div(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_div, :LLVMConstFDiv, [:pointer, :pointer], :pointer

.const_f_mul(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_mul, :LLVMConstFMul, [:pointer, :pointer], :pointer

.const_f_neg(constant_val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_neg, :LLVMConstFNeg, [:pointer], :pointer

.const_f_rem(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_rem, :LLVMConstFRem, [:pointer, :pointer], :pointer

.const_f_sub(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_f_sub, :LLVMConstFSub, [:pointer, :pointer], :pointer

.const_fp_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_fp_cast, :LLVMConstFPCast, [:pointer, :pointer], :pointer

.const_fp_ext(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_fp_ext, :LLVMConstFPExt, [:pointer, :pointer], :pointer

.const_fp_to_si(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_fp_to_si, :LLVMConstFPToSI, [:pointer, :pointer], :pointer

.const_fp_to_ui(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_fp_to_ui, :LLVMConstFPToUI, [:pointer, :pointer], :pointer

.const_fp_trunc(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_fp_trunc, :LLVMConstFPTrunc, [:pointer, :pointer], :pointer

.const_gep(constant_val, constant_indices, num_indices) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • constant_indices (FFI::Pointer(*ValueRef))
  • num_indices (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_gep, :LLVMConstGEP, [:pointer, :pointer, :uint], :pointer

.const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • predicate (Symbol from _enum_int_predicate_)
  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_i_cmp, :LLVMConstICmp, [:int_predicate, :pointer, :pointer], :pointer

.const_in_bounds_gep(constant_val, constant_indices, num_indices) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • constant_indices (FFI::Pointer(*ValueRef))
  • num_indices (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_in_bounds_gep, :LLVMConstInBoundsGEP, [:pointer, :pointer, :uint], :pointer

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

(Not documented)

Parameters:

  • ty (FFI::Pointer(TypeRef))
  • asm_string (String)
  • constraints (String)
  • has_side_effects (Integer)
  • is_align_stack (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_inline_asm, :LLVMConstInlineAsm, [:pointer, :string, :string, :int, :int], :pointer

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

(Not documented)

Parameters:

  • vector_constant (FFI::Pointer(ValueRef))
  • element_value_constant (FFI::Pointer(ValueRef))
  • index_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_insert_element, :LLVMConstInsertElement, [:pointer, :pointer, :pointer], :pointer

.const_insert_value(agg_constant, element_value_constant, idx_list, num_idx) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

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

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_insert_value, :LLVMConstInsertValue, [:pointer, :pointer, :pointer, :uint], :pointer

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

Obtain a constant value for an integer type.

The returned value corresponds to a llvm::ConstantInt.

Parameters:

  • IntTy

    Integer type to obtain value of.

  • N

    The value the returned instance should refer to.

  • SignExtend

    Whether to sign extend the produced value.

  • int_ty (FFI::Pointer(TypeRef))
  • n (Integer)
  • sign_extend (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::get()


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

attach_function :const_int, :LLVMConstInt, [:pointer, :ulong_long, :int], :pointer

.const_int_cast(constant_val, to_type, is_signed) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))
  • is_signed (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_int_cast, :LLVMConstIntCast, [:pointer, :pointer, :int], :pointer

.const_int_get_s_ext_value(constant_val) ⇒ Integer

Obtain the sign extended value for an integer constant value.

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::getSExtValue()


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

attach_function :const_int_get_s_ext_value, :LLVMConstIntGetSExtValue, [:pointer], :long_long

.const_int_get_z_ext_value(constant_val) ⇒ Integer

Obtain the zero extended value for an integer constant value.

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::getZExtValue()


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

attach_function :const_int_get_z_ext_value, :LLVMConstIntGetZExtValue, [:pointer], :ulong_long

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

Obtain a constant value for an integer of arbitrary precision.

Parameters:

  • int_ty (FFI::Pointer(TypeRef))
  • num_words (Integer)
  • words (FFI::Pointer(*U_long))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::get()


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

attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [:pointer, :uint, :pointer], :pointer

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

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

A similar API, LLVMConstIntOfStringAndSize is also available. If the string’s length is available, it is preferred to call that function instead.

Parameters:

  • int_ty (FFI::Pointer(TypeRef))
  • text (String)
  • radix (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::get()


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

attach_function :const_int_of_string, :LLVMConstIntOfString, [:pointer, :string, :uchar], :pointer

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

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

Parameters:

  • int_ty (FFI::Pointer(TypeRef))
  • text (String)
  • s_len (Integer)
  • radix (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantIntllvm::ConstantInt::get()


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

attach_function :const_int_of_string_and_size, :LLVMConstIntOfStringAndSize, [:pointer, :string, :uint, :uchar], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_int_to_ptr, :LLVMConstIntToPtr, [:pointer, :pointer], :pointer

.const_l_shr(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_l_shr, :LLVMConstLShr, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_mul, :LLVMConstMul, [:pointer, :pointer], :pointer

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

Create a non-anonymous ConstantStruct from values.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))
  • constant_vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantStructllvm::ConstantStruct::get()


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

attach_function :const_named_struct, :LLVMConstNamedStruct, [:pointer, :pointer, :uint], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_neg, :LLVMConstNeg, [:pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_not, :LLVMConstNot, [:pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nsw_add, :LLVMConstNSWAdd, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nsw_mul, :LLVMConstNSWMul, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nsw_neg, :LLVMConstNSWNeg, [:pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nsw_sub, :LLVMConstNSWSub, [:pointer, :pointer], :pointer

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

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

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Constantllvm::Constant::getNullValue()


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

attach_function :const_null, :LLVMConstNull, [:pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nuw_add, :LLVMConstNUWAdd, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nuw_mul, :LLVMConstNUWMul, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nuw_neg, :LLVMConstNUWNeg, [:pointer], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_nuw_sub, :LLVMConstNUWSub, [:pointer, :pointer], :pointer

.const_or(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_or, :LLVMConstOr, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_pointer_cast, :LLVMConstPointerCast, [:pointer, :pointer], :pointer

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

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

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_pointer_null, :LLVMConstPointerNull, [:pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_ptr_to_int, :LLVMConstPtrToInt, [:pointer, :pointer], :pointer

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

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

Parameters:

  • real_ty (FFI::Pointer(TypeRef))
  • n (Float)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_real, :LLVMConstReal, [:pointer, :double], :pointer

.const_real_get_double(constant_val, loses_info) ⇒ Float

Obtain the double value for an floating point constant value. losesInfo indicates if some precision was lost in the conversion.

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • loses_info (FFI::Pointer(*Bool))

Returns:

See Also:

  • llvmllvm::ConstantFPllvm::ConstantFP::getDoubleValue


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

attach_function :const_real_get_double, :LLVMConstRealGetDouble, [:pointer, :pointer], :double

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

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

A similar API, LLVMConstRealOfStringAndSize is also available. It should be used if the input string’s length is known.

Parameters:

  • real_ty (FFI::Pointer(TypeRef))
  • text (String)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_real_of_string, :LLVMConstRealOfString, [:pointer, :string], :pointer

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

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

Parameters:

  • real_ty (FFI::Pointer(TypeRef))
  • text (String)
  • s_len (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_real_of_string_and_size, :LLVMConstRealOfStringAndSize, [:pointer, :string, :uint], :pointer

.const_s_div(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_s_div, :LLVMConstSDiv, [:pointer, :pointer], :pointer

.const_s_ext(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_s_ext, :LLVMConstSExt, [:pointer, :pointer], :pointer

.const_s_ext_or_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_s_ext_or_bit_cast, :LLVMConstSExtOrBitCast, [:pointer, :pointer], :pointer

.const_s_rem(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_s_rem, :LLVMConstSRem, [:pointer, :pointer], :pointer

.const_select(constant_condition, constant_if_true, constant_if_false) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_condition (FFI::Pointer(ValueRef))
  • constant_if_true (FFI::Pointer(ValueRef))
  • constant_if_false (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_select, :LLVMConstSelect, [:pointer, :pointer, :pointer], :pointer

.const_shl(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_shl, :LLVMConstShl, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • vector_a_constant (FFI::Pointer(ValueRef))
  • vector_b_constant (FFI::Pointer(ValueRef))
  • mask_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_shuffle_vector, :LLVMConstShuffleVector, [:pointer, :pointer, :pointer], :pointer

.const_si_to_fp(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_si_to_fp, :LLVMConstSIToFP, [:pointer, :pointer], :pointer

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

Create a ConstantDataSequential with string content in the global context.

This is the same as LLVMConstStringInContext except it operates on the global context.

Parameters:

  • str (String)
  • length (Integer)
  • dont_null_terminate (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • LLVMConstStringInContext()
  • llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()


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

attach_function :const_string, :LLVMConstString, [:string, :uint, :int], :pointer

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

Create a ConstantDataSequential and initialize it with a string.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • str (String)
  • length (Integer)
  • dont_null_terminate (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()


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

attach_function :const_string_in_context, :LLVMConstStringInContext, [:pointer, :string, :uint, :int], :pointer

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

Create a ConstantStruct in the global Context.

This is the same as LLVMConstStructInContext except it operates on the global Context.

Parameters:

  • constant_vals (FFI::Pointer(*ValueRef))
  • count (Integer)
  • packed (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • LLVMConstStructInContext()


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

attach_function :const_struct, :LLVMConstStruct, [:pointer, :uint, :int], :pointer

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

Create an anonymous ConstantStruct with the specified values.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • constant_vals (FFI::Pointer(*ValueRef))
  • count (Integer)
  • packed (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantStructllvm::ConstantStruct::getAnon()


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

attach_function :const_struct_in_context, :LLVMConstStructInContext, [:pointer, :pointer, :uint, :int], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_sub, :LLVMConstSub, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_trunc, :LLVMConstTrunc, [:pointer, :pointer], :pointer

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

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_trunc_or_bit_cast, :LLVMConstTruncOrBitCast, [:pointer, :pointer], :pointer

.const_u_div(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_u_div, :LLVMConstUDiv, [:pointer, :pointer], :pointer

.const_u_rem(lhs_constant, rhs_constant) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_u_rem, :LLVMConstURem, [:pointer, :pointer], :pointer

.const_ui_to_fp(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_ui_to_fp, :LLVMConstUIToFP, [:pointer, :pointer], :pointer

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

Create a ConstantVector from values.

Parameters:

  • scalar_constant_vals (FFI::Pointer(*ValueRef))
  • size (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::ConstantVectorllvm::ConstantVector::get()


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

attach_function :const_vector, :LLVMConstVector, [:pointer, :uint], :pointer

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

(Not documented)

Parameters:

  • lhs_constant (FFI::Pointer(ValueRef))
  • rhs_constant (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_xor, :LLVMConstXor, [:pointer, :pointer], :pointer

.const_z_ext(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_z_ext, :LLVMConstZExt, [:pointer, :pointer], :pointer

.const_z_ext_or_bit_cast(constant_val, to_type) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • constant_val (FFI::Pointer(ValueRef))
  • to_type (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :const_z_ext_or_bit_cast, :LLVMConstZExtOrBitCast, [:pointer, :pointer], :pointer

.context_createFFI::Pointer(ContextRef)

Create a new context.

Every call to this function should be paired with a call to LLVMContextDispose() or the context will leak memory.

Returns:

  • (FFI::Pointer(ContextRef))


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

attach_function :context_create, :LLVMContextCreate, [], :pointer

.context_dispose(c) ⇒ nil

Destroy a context instance.

This should be called for every call to LLVMContextCreate() or memory will be leaked.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (nil)


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

attach_function :context_dispose, :LLVMContextDispose, [:pointer], :void

.context_set_diagnostic_handler(c, handler, diagnostic_context) ⇒ nil

Set the diagnostic handler for this context.

Parameters:

Returns:

  • (nil)


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

attach_function :context_set_diagnostic_handler, :LLVMContextSetDiagnosticHandler, [:pointer, :diagnostic_handler, :pointer], :void

.context_set_yield_callback(c, callback, opaque_handle) ⇒ nil

Set the yield callback function for this context.

Parameters:

Returns:

  • (nil)

See Also:

  • LLVMContext::setYieldCallback()


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

attach_function :context_set_yield_callback, :LLVMContextSetYieldCallback, [:pointer, :yield_callback, :pointer], :void

.copy_string_rep_of_target_data(td) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String)


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

attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :string

.count_basic_blocks(fn) ⇒ Integer

Obtain the number of basic blocks in a function.

Parameters:

  • Fn

    Function value to operate on.

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


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

attach_function :count_basic_blocks, :LLVMCountBasicBlocks, [:pointer], :uint

.count_incoming(phi_node) ⇒ Integer

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

Parameters:

  • phi_node (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


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

attach_function :count_incoming, :LLVMCountIncoming, [:pointer], :uint

.count_param_types(function_ty) ⇒ Integer

Obtain the number of parameters this function accepts.

Parameters:

  • function_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)


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

attach_function :count_param_types, :LLVMCountParamTypes, [:pointer], :uint

.count_params(fn) ⇒ Integer

Obtain the number of parameters in a function.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::arg_size()


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

attach_function :count_params, :LLVMCountParams, [:pointer], :uint

.count_struct_element_types(struct_ty) ⇒ Integer

Get the number of elements defined inside the structure.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::getNumElements()


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

attach_function :count_struct_element_types, :LLVMCountStructElementTypes, [:pointer], :uint

.create_builderFFI::Pointer(BuilderRef)

(Not documented)

Returns:

  • (FFI::Pointer(BuilderRef))


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

attach_function :create_builder, :LLVMCreateBuilder, [], :pointer

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

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

@{

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(BuilderRef))


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

attach_function :create_builder_in_context, :LLVMCreateBuilderInContext, [:pointer], :pointer

.create_execution_engine_for_module(out_ee, m, out_error) ⇒ Integer

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

Parameters:

  • out_ee (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer)


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

attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int

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

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

  • mp (FFI::Pointer(ModuleProviderRef))

Returns:

  • (FFI::Pointer(PassManagerRef))


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

attach_function :create_function_pass_manager, :LLVMCreateFunctionPassManager, [:pointer], :pointer

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

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

provider. It does not take ownership of the module provider. This type of
pipeline is suitable for code generation and JIT compilation tasks.
@see llvm::FunctionPassManager::FunctionPassManager

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(PassManagerRef))


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

attach_function :create_function_pass_manager_for_module, :LLVMCreateFunctionPassManagerForModule, [:pointer], :pointer

.create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

  • ty (FFI::Pointer(TypeRef))
  • n (Float)

Returns:



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

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:



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

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:



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

attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], OpaqueGenericValue

.create_interpreter_for_module(out_interp, m, out_error) ⇒ Integer

(Not documented)

Parameters:

  • out_interp (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer)


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

attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int

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

(Not documented)

Parameters:

  • out_jit (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • opt_level (Integer)
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer)


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

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)


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

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)


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

attach_function :create_memory_buffer_with_contents_of_file, :LLVMCreateMemoryBufferWithContentsOfFile, [:string, :pointer, :pointer], :int

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

(Not documented)

Parameters:

  • input_data (String)
  • input_data_length (Integer)
  • buffer_name (String)
  • requires_null_terminator (Integer)

Returns:

  • (FFI::Pointer(MemoryBufferRef))


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

attach_function :create_memory_buffer_with_memory_range, :LLVMCreateMemoryBufferWithMemoryRange, [:string, :ulong, :string, :int], :pointer

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

(Not documented)

Parameters:

  • input_data (String)
  • input_data_length (Integer)
  • buffer_name (String)

Returns:

  • (FFI::Pointer(MemoryBufferRef))


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

attach_function :create_memory_buffer_with_memory_range_copy, :LLVMCreateMemoryBufferWithMemoryRangeCopy, [:string, :ulong, :string], :pointer

.create_memory_buffer_with_stdin(out_mem_buf, out_message) ⇒ Integer

(Not documented)

Parameters:

  • out_mem_buf (FFI::Pointer(*MemoryBufferRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)


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

attach_function :create_memory_buffer_with_stdin, :LLVMCreateMemoryBufferWithSTDIN, [:pointer, :pointer], :int

.create_message(message) ⇒ String

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

Parameters:

  • message (String)

Returns:

  • (String)


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

attach_function :create_message, :LLVMCreateMessage, [:string], :string

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

Changes the type of M so it can be passed to FunctionPassManagers and the JIT. They take ModuleProviders for historical reasons.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ModuleProviderRef))


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

attach_function :create_module_provider_for_existing_module, :LLVMCreateModuleProviderForExistingModule, [:pointer], :pointer

.create_pass_managerFFI::Pointer(PassManagerRef)

Constructs a new whole-module pass pipeline. This type of pipeline is

suitable for link-time optimization and whole-module transformations.
@see llvm::PassManager::PassManager

Returns:

  • (FFI::Pointer(PassManagerRef))


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

attach_function :create_pass_manager, :LLVMCreatePassManager, [], :pointer

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

Create a simple custom MCJIT memory manager. This memory manager can intercept allocations in a module-oblivious way. This will return NULL if any of the passed functions are NULL.

Parameters:

Returns:



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

attach_function :create_simple_mcjit_memory_manager, :LLVMCreateSimpleMCJITMemoryManager, [:pointer, :memory_manager_allocate_code_section_callback, :memory_manager_allocate_data_section_callback, :memory_manager_finalize_memory_callback, :pointer], OpaqueMCJITMemoryManager

.create_target_data(string_rep) ⇒ OpaqueTargetData

(Not documented)

Parameters:

  • string_rep (String)

Returns:



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

attach_function :create_target_data, :LLVMCreateTargetData, [:string], OpaqueTargetData

.create_target_data_layout(t) ⇒ OpaqueTargetData

Create a DataLayout based on the targetMachine.

Parameters:

Returns:



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

attach_function :create_target_data_layout, :LLVMCreateTargetDataLayout, [OpaqueTargetMachine], OpaqueTargetData

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

Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine

Parameters:

Returns:



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

attach_function :create_target_machine, :LLVMCreateTargetMachine, [Target, :string, :string, :string, :code_gen_opt_level, :reloc_mode, :code_model], OpaqueTargetMachine

.delete_basic_block(bb) ⇒ nil

Remove a basic block from a function and delete it.

This deletes the basic block from its containing function and deletes the basic block itself.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::eraseFromParent()


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

attach_function :delete_basic_block, :LLVMDeleteBasicBlock, [:pointer], :void

.delete_function(fn) ⇒ nil

Remove a function from its containing module and deletes it.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::eraseFromParent()


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

attach_function :delete_function, :LLVMDeleteFunction, [:pointer], :void

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (nil)


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

attach_function :delete_global, :LLVMDeleteGlobal, [:pointer], :void

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))

Returns:

  • (nil)


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

attach_function :dispose_builder, :LLVMDisposeBuilder, [:pointer], :void

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [OpaqueExecutionEngine], :void

.dispose_generic_value(gen_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [OpaqueGenericValue], :void

.dispose_mcjit_memory_manager(mm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

  • (nil)


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

attach_function :dispose_memory_buffer, :LLVMDisposeMemoryBuffer, [:pointer], :void

.dispose_message(message) ⇒ nil

(Not documented)

Parameters:

  • message (String)

Returns:

  • (nil)


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

attach_function :dispose_message, :LLVMDisposeMessage, [:string], :void

.dispose_module(m) ⇒ nil

Destroy a module instance.

This must be called for every created module or memory will be leaked.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (nil)


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

attach_function :dispose_module, :LLVMDisposeModule, [:pointer], :void

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

  • m (FFI::Pointer(ModuleProviderRef))

Returns:

  • (nil)


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

attach_function :dispose_module_provider, :LLVMDisposeModuleProvider, [:pointer], :void

.dispose_pass_manager(pm) ⇒ nil

Frees the memory of a pass pipeline. For function pipelines, does not free

the module provider.
@see llvm::PassManagerBase::~PassManagerBase.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil)


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

attach_function :dispose_pass_manager, :LLVMDisposePassManager, [:pointer], :void

.dispose_target_data(td) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void

.dispose_target_machine(t) ⇒ nil

Dispose the LLVMTargetMachineRef instance generated by

LLVMCreateTargetMachine.

Parameters:

Returns:

  • (nil)


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

attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void

.double_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :double_type, :LLVMDoubleType, [], :pointer

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

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

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :double_type_in_context, :LLVMDoubleTypeInContext, [:pointer], :pointer

.dump_module(m) ⇒ nil

Dump a representation of a module to stderr.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (nil)

See Also:

  • Module::dump()


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

attach_function :dump_module, :LLVMDumpModule, [:pointer], :void

.dump_type(val) ⇒ nil

Dump a representation of a type to stderr.

Parameters:

  • val (FFI::Pointer(TypeRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Typellvm::Type::dump()


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

attach_function :dump_type, :LLVMDumpType, [:pointer], :void

.dump_value(val) ⇒ nil

Dump a representation of a value to stderr.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::dump()


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

attach_function :dump_value, :LLVMDumpValue, [:pointer], :void

.element_at_offset(td, struct_ty, offset) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :element_at_offset, :LLVMElementAtOffset, [OpaqueTargetData, :pointer, :ulong_long], :uint

.finalize_function_pass_manager(fpm) ⇒ Integer

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

manager. Returns 1 if any of the passes modified the module, 0 otherwise.
@see llvm::FunctionPassManager::doFinalization

Parameters:

  • fpm (FFI::Pointer(PassManagerRef))

Returns:

  • (Integer)


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

attach_function :finalize_function_pass_manager, :LLVMFinalizeFunctionPassManager, [:pointer], :int

.find_function(ee, name, out_fn) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :find_function, :LLVMFindFunction, [OpaqueExecutionEngine, :string, :pointer], :int

.float_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :float_type, :LLVMFloatType, [], :pointer

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

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

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :float_type_in_context, :LLVMFloatTypeInContext, [:pointer], :pointer

.fp128_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :fp128_type, :LLVMFP128Type, [], :pointer

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

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

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :fp128_type_in_context, :LLVMFP128TypeInContext, [:pointer], :pointer

.free_machine_code_for_function(ee, f) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


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

attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, :pointer], :void

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

Obtain a function type consisting of a specified signature.

The function is defined as a tuple of a return Type, a list of parameter types, and whether the function is variadic.

Parameters:

  • return_type (FFI::Pointer(TypeRef))
  • param_types (FFI::Pointer(*TypeRef))
  • param_count (Integer)
  • is_var_arg (Integer)

Returns:

  • (FFI::Pointer(TypeRef))


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

attach_function :function_type, :LLVMFunctionType, [:pointer, :pointer, :uint, :int], :pointer

.generic_value_int_width(gen_val_ref) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [OpaqueGenericValue], :uint

.generic_value_to_float(ty_ref, gen_val) ⇒ Float

(Not documented)

Parameters:

Returns:



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

attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, OpaqueGenericValue], :double

.generic_value_to_int(gen_val, is_signed) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :generic_value_to_int, :LLVMGenericValueToInt, [OpaqueGenericValue, :int], :ulong_long

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void))


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

attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [OpaqueGenericValue], :pointer

.get_alignment(v) ⇒ Integer

Obtain the preferred alignment of the value.

Parameters:

  • v (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::AllocaInstllvm::AllocaInst::getAlignment()
  • llvmllvm::LoadInstllvm::LoadInst::getAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::getAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::getAlignment()


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

attach_function :get_alignment, :LLVMGetAlignment, [:pointer], :uint

.get_array_length(array_ty) ⇒ Integer

Obtain the length of an array type.

This only works on types that represent arrays.

Parameters:

  • array_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::ArrayTypellvm::ArrayType::getNumElements()


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

attach_function :get_array_length, :LLVMGetArrayLength, [:pointer], :uint

.get_as_string(c, out) ⇒ String

Get the given constant data sequential as a string.

Parameters:

  • c (FFI::Pointer(ValueRef))
  • out (FFI::Pointer(*SizeT))

Returns:

  • (String)

See Also:

  • ConstantDataSequential::getAsString()


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

attach_function :get_as_string, :LLVMGetAsString, [:pointer, :pointer], :string

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

Obtain the function to which a basic block belongs.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::getParent()


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

attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [:pointer], :pointer

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

Obtain the terminator instruction for a basic block.

If the basic block does not have a terminator (it is not well-formed if it doesn’t), then NULL is returned.

The returned LLVMValueRef corresponds to a llvm::TerminatorInst.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::getTerminator()


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

attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [:pointer], :pointer

.get_basic_blocks(fn, basic_blocks) ⇒ nil

Obtain all of the basic blocks in a function.

This operates on a function value. The BasicBlocks parameter is a pointer to a pre-allocated array of LLVMBasicBlockRef of at least LLVMCountBasicBlocks() in length. This array is populated with LLVMBasicBlockRef instances.

Parameters:

  • fn (FFI::Pointer(ValueRef))
  • basic_blocks (FFI::Pointer(*BasicBlockRef))

Returns:

  • (nil)


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

attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [:pointer, :pointer], :void

.get_bitcode_module(mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_m (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)


84
# File 'lib/llvm/core/bitcode_ffi.rb', line 84

attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :pointer, :pointer], :int

.get_bitcode_module2(mem_buf, out_m) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_m (FFI::Pointer(*ModuleRef))

Returns:

  • (Integer)


93
# File 'lib/llvm/core/bitcode_ffi.rb', line 93

attach_function :get_bitcode_module2, :LLVMGetBitcodeModule2, [:pointer, :pointer], :int

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

(Not documented)

Parameters:

  • context_ref (FFI::Pointer(ContextRef))
  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_m (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)


64
# File 'lib/llvm/core/bitcode_ffi.rb', line 64

attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_bitcode_module_in_context2(context_ref, mem_buf, out_m) ⇒ Integer

(Not documented)

Parameters:

  • context_ref (FFI::Pointer(ContextRef))
  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_m (FFI::Pointer(*ModuleRef))

Returns:

  • (Integer)


74
# File 'lib/llvm/core/bitcode_ffi.rb', line 74

attach_function :get_bitcode_module_in_context2, :LLVMGetBitcodeModuleInContext2, [:pointer, :pointer, :pointer], :int

.get_buffer_size(mem_buf) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

  • (Integer)


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

attach_function :get_buffer_size, :LLVMGetBufferSize, [:pointer], :ulong

.get_buffer_start(mem_buf) ⇒ String

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))

Returns:

  • (String)


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

attach_function :get_buffer_start, :LLVMGetBufferStart, [:pointer], :string

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

Return the condition of a branch instruction.

This only works on llvm::BranchInst instructions.

Parameters:

  • branch (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::BranchInstllvm::BranchInst::getCondition


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

attach_function :get_condition, :LLVMGetCondition, [:pointer], :pointer

.get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

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

@{

Parameters:

  • constant_val (FFI::Pointer(ValueRef))

Returns:

See Also:

  • llvm::ConstantExpr.


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

attach_function :get_const_opcode, :LLVMGetConstOpcode, [:pointer], :opcode

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

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :get_current_debug_location, :LLVMGetCurrentDebugLocation, [:pointer], :pointer

.get_data_layout(m) ⇒ String

Obtain the data layout for a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (String)

See Also:

  • Module::getDataLayout()


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

attach_function :get_data_layout, :LLVMGetDataLayout, [:pointer], :string

.get_default_target_tripleString

Get a triple for the host machine as a string. The result needs to be

disposed with LLVMDisposeMessage.

Returns:

  • (String)


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

attach_function :get_default_target_triple, :LLVMGetDefaultTargetTriple, [], :string

.get_diag_info_description(di) ⇒ String

Return a string representation of the DiagnosticInfo. Use LLVMDisposeMessage to free the string.

Parameters:

  • di (FFI::Pointer(DiagnosticInfoRef))

Returns:

  • (String)

See Also:

  • DiagnosticInfo::print()


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

attach_function :get_diag_info_description, :LLVMGetDiagInfoDescription, [:pointer], :string

.get_diag_info_severity(di) ⇒ Symbol from _enum_diagnostic_severity_

Return an enum LLVMDiagnosticSeverity.

Parameters:

  • di (FFI::Pointer(DiagnosticInfoRef))

Returns:

See Also:

  • DiagnosticInfo::getSeverity()


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

attach_function :get_diag_info_severity, :LLVMGetDiagInfoSeverity, [:pointer], :diagnostic_severity

.get_dll_storage_class(global) ⇒ Symbol from _enum_dll_storage_class_

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:



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

attach_function :get_dll_storage_class, :LLVMGetDLLStorageClass, [:pointer], :dll_storage_class

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

Get an element at specified index as a constant.

Parameters:

  • c (FFI::Pointer(ValueRef))
  • idx (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • ConstantDataSequential::getElementAsConstant()


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

attach_function :get_element_as_constant, :LLVMGetElementAsConstant, [:pointer, :uint], :pointer

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

Obtain the type of elements within a sequential type.

This works on array, vector, and pointer types.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::SequentialTypellvm::SequentialType::getElementType()


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

attach_function :get_element_type, :LLVMGetElementType, [:pointer], :pointer

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

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

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::Functionllvm::Function::getEntryBlock()


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

attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [:pointer], :pointer

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TargetDataRef))


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

attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [OpaqueExecutionEngine], :pointer

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TargetMachineRef))


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

attach_function :get_execution_engine_target_machine, :LLVMGetExecutionEngineTargetMachine, [OpaqueExecutionEngine], :pointer

.get_f_cmp_predicate(inst) ⇒ Symbol from _enum_real_predicate_

Obtain the float predicate of an instruction.

This is only valid for instructions that correspond to llvm::FCmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::FCmp.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

See Also:

  • llvmllvm::FCmpInstllvm::FCmpInst::getPredicate()


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

attach_function :get_f_cmp_predicate, :LLVMGetFCmpPredicate, [:pointer], :real_predicate

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

Obtain the first basic block in a function.

The returned basic block can be used as an iterator. You will likely eventually call into LLVMGetNextBasicBlock() with it.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::Functionllvm::Function::begin()


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

attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [:pointer], :pointer

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

Obtain an iterator to the first Function in a Module.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Modulellvm::Module::begin()


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

attach_function :get_first_function, :LLVMGetFirstFunction, [:pointer], :pointer

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

(Not documented)

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :get_first_global, :LLVMGetFirstGlobal, [:pointer], :pointer

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

Obtain the first instruction in a basic block.

The returned LLVMValueRef corresponds to a llvm::Instruction instance.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :get_first_instruction, :LLVMGetFirstInstruction, [:pointer], :pointer

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

Obtain the first parameter to a function.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


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

attach_function :get_first_param, :LLVMGetFirstParam, [:pointer], :pointer

.get_first_targetTarget

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

Returns:



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

attach_function :get_first_target, :LLVMGetFirstTarget, [], Target

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

Obtain the first use of a value.

Uses are obtained in an iterator fashion. First, call this function to obtain a reference to the first use. Then, call LLVMGetNextUse() on that instance and all subsequently obtained instances until LLVMGetNextUse() returns NULL.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(UseRef))

See Also:

  • llvmllvm::Valuellvm::Value::use_begin()


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

attach_function :get_first_use, :LLVMGetFirstUse, [:pointer], :pointer

.get_function_address(ee, name) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :get_function_address, :LLVMGetFunctionAddress, [OpaqueExecutionEngine, :string], :ulong

.get_function_call_conv(fn) ⇒ Integer

Obtain the calling function of a function.

The returned value corresponds to the LLVMCallConv enumeration.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::getCallingConv()


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

attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [:pointer], :uint

.get_gc(fn) ⇒ String

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

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (String)

See Also:

  • llvmllvm::Functionllvm::Function::getGC()


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

attach_function :get_gc, :LLVMGetGC, [:pointer], :string

.get_global_contextFFI::Pointer(ContextRef)

Obtain the global context instance.

Returns:

  • (FFI::Pointer(ContextRef))


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

attach_function :get_global_context, :LLVMGetGlobalContext, [], :pointer

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

This group contains functions that operate on global values. Functions in this group relate to functions in the llvm::GlobalValue class tree.

@{

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ModuleRef))

See Also:

  • llvmllvm::GlobalValue


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

attach_function :get_global_parent, :LLVMGetGlobalParent, [:pointer], :pointer

.get_global_pass_registryFFI::Pointer(PassRegistryRef)

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

@see llvm::PassRegistry::getPassRegistry

Returns:

  • (FFI::Pointer(PassRegistryRef))


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

attach_function :get_global_pass_registry, :LLVMGetGlobalPassRegistry, [], :pointer

.get_global_value_address(ee, name) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


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

attach_function :get_global_value_address, :LLVMGetGlobalValueAddress, [OpaqueExecutionEngine, :string], :ulong

.get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

Obtain the predicate of an instruction.

This is only valid for instructions that correspond to llvm::ICmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

See Also:

  • llvmllvm::ICmpInstllvm::ICmpInst::getPredicate()


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

attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [:pointer], :int_predicate

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

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

Parameters:

  • phi_node (FFI::Pointer(ValueRef))
  • index (Integer)

Returns:

  • (FFI::Pointer(BasicBlockRef))


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

attach_function :get_incoming_block, :LLVMGetIncomingBlock, [:pointer, :uint], :pointer

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

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

Parameters:

  • phi_node (FFI::Pointer(ValueRef))
  • index (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :get_incoming_value, :LLVMGetIncomingValue, [:pointer, :uint], :pointer

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

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


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

attach_function :get_initializer, :LLVMGetInitializer, [:pointer], :pointer

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

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))


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

attach_function :get_insert_block, :LLVMGetInsertBlock, [:pointer], :pointer

.get_instruction_call_conv(instr) ⇒ Integer

Obtain the calling convention for a call instruction.

This is the opposite of LLVMSetInstructionCallConv(). Reads its usage.

Parameters:

  • instr (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • LLVMSetInstructionCallConv()


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

attach_function :get_instruction_call_conv, :LLVMGetInstructionCallConv, [:pointer], :uint

.get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

Obtain the code opcode for an individual instruction.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

See Also:

  • llvmllvm::Instructionllvm::Instruction::getOpCode()


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

attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [:pointer], :opcode

.get_instruction_parent(inst) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the basic block to which an instruction belongs.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::Instructionllvm::Instruction::getParent()


4389
# File 'lib/llvm/core_ffi.rb', line 4389

attach_function :get_instruction_parent, :LLVMGetInstructionParent, [:pointer], :pointer

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

  • integer_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)


1402
# File 'lib/llvm/core_ffi.rb', line 1402

attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [:pointer], :uint

.get_intrinsic_id(fn) ⇒ Integer

Obtain the ID number from a function instance.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::getIntrinsicID()


3856
# File 'lib/llvm/core_ffi.rb', line 3856

attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [:pointer], :uint

.get_last_basic_block(fn) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the last basic block in a function.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::Functionllvm::Function::end()


4206
# File 'lib/llvm/core_ffi.rb', line 4206

attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [:pointer], :pointer

.get_last_function(m) ⇒ FFI::Pointer(ValueRef)

Obtain an iterator to the last Function in a Module.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Modulellvm::Module::end()


1211
# File 'lib/llvm/core_ffi.rb', line 1211

attach_function :get_last_function, :LLVMGetLastFunction, [:pointer], :pointer

.get_last_global(m) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ValueRef))


3689
# File 'lib/llvm/core_ffi.rb', line 3689

attach_function :get_last_global, :LLVMGetLastGlobal, [:pointer], :pointer

.get_last_instruction(bb) ⇒ FFI::Pointer(ValueRef)

Obtain the last instruction in a basic block.

The returned LLVMValueRef corresponds to an LLVM:Instruction.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(ValueRef))


4352
# File 'lib/llvm/core_ffi.rb', line 4352

attach_function :get_last_instruction, :LLVMGetLastInstruction, [:pointer], :pointer

.get_last_param(fn) ⇒ FFI::Pointer(ValueRef)

Obtain the last parameter to a function.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Functionllvm::Function::arg_end()


3989
# File 'lib/llvm/core_ffi.rb', line 3989

attach_function :get_last_param, :LLVMGetLastParam, [:pointer], :pointer

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:



3535
# File 'lib/llvm/core_ffi.rb', line 3535

attach_function :get_linkage, :LLVMGetLinkage, [:pointer], :linkage

.get_md_kind_id(name, s_len) ⇒ Integer

(Not documented)

Parameters:

  • name (String)
  • s_len (Integer)

Returns:

  • (Integer)


973
# File 'lib/llvm/core_ffi.rb', line 973

attach_function :get_md_kind_id, :LLVMGetMDKindID, [:string, :uint], :uint

.get_md_kind_id_in_context(c, name, s_len) ⇒ Integer

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))
  • name (String)
  • s_len (Integer)

Returns:

  • (Integer)


964
# File 'lib/llvm/core_ffi.rb', line 964

attach_function :get_md_kind_id_in_context, :LLVMGetMDKindIDInContext, [:pointer, :string, :uint], :uint

.get_md_node_num_operands(v) ⇒ Object

Obtain the number of operands from an MDNode value.

Parameters:

  • V

    MDNode to get number of operands from.

  • v (FFI::Pointer(ValueRef))

Returns:

  • Number of operands of the MDNode.

  • (Integer)


4093
# File 'lib/llvm/core_ffi.rb', line 4093

attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [:pointer], :uint

.get_md_node_operands(v, dest) ⇒ nil

Obtain the given MDNode’s operands.

The passed LLVMValueRef pointer should point to enough memory to hold all of the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the MDNode’s operands.

Parameters:

  • V

    MDNode to get the operands from.

  • Dest

    Destination array for operands.

  • v (FFI::Pointer(ValueRef))
  • dest (FFI::Pointer(*ValueRef))

Returns:

  • (nil)


4110
# File 'lib/llvm/core_ffi.rb', line 4110

attach_function :get_md_node_operands, :LLVMGetMDNodeOperands, [:pointer, :pointer], :void

.get_md_string(v, len) ⇒ Object

Obtain the underlying string from a MDString value.

Parameters:

  • V

    Instance to obtain string from.

  • Len

    Memory address which will hold length of returned string.

  • v (FFI::Pointer(ValueRef))
  • len (FFI::Pointer(*UInt))

Returns:

  • String data in MDString.

  • (String)


4082
# File 'lib/llvm/core_ffi.rb', line 4082

attach_function :get_md_string, :LLVMGetMDString, [:pointer, :pointer], :string

.get_metadata(val, kind_id) ⇒ FFI::Pointer(ValueRef)

Return metadata associated with an instruction value.

Parameters:

  • val (FFI::Pointer(ValueRef))
  • kind_id (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


4369
# File 'lib/llvm/core_ffi.rb', line 4369

attach_function :get_metadata, :LLVMGetMetadata, [:pointer, :uint], :pointer

.get_module_context(m) ⇒ FFI::Pointer(ContextRef)

Obtain the context to which this module is associated.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(ContextRef))

See Also:

  • Module::getContext()


1115
# File 'lib/llvm/core_ffi.rb', line 1115

attach_function :get_module_context, :LLVMGetModuleContext, [:pointer], :pointer

.get_module_data_layout(m) ⇒ OpaqueTargetData

(Not documented)

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:



119
# File 'lib/llvm/target_ffi.rb', line 119

attach_function :get_module_data_layout, :LLVMGetModuleDataLayout, [:pointer], OpaqueTargetData

.get_named_function(m, name) ⇒ FFI::Pointer(ValueRef)

Obtain a Function value from a Module by its name.

The returned value corresponds to a llvm::Function value.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Modulellvm::Module::getFunction()


1191
# File 'lib/llvm/core_ffi.rb', line 1191

attach_function :get_named_function, :LLVMGetNamedFunction, [:pointer, :string], :pointer

.get_named_global(m, name) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • name (String)

Returns:

  • (FFI::Pointer(ValueRef))


3673
# File 'lib/llvm/core_ffi.rb', line 3673

attach_function :get_named_global, :LLVMGetNamedGlobal, [:pointer, :string], :pointer

.get_named_metadata_num_operands(m, name) ⇒ Integer

Obtain the number of operands for named metadata in a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • name (String)

Returns:

  • (Integer)

See Also:

  • llvmllvm::Modulellvm::Module::getNamedMetadata()


1135
# File 'lib/llvm/core_ffi.rb', line 1135

attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [:pointer, :string], :uint

.get_named_metadata_operands(m, name, dest) ⇒ nil

Obtain the named metadata operands for a module.

The passed LLVMValueRef pointer should refer to an array of LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This array will be populated with the LLVMValueRef instances. Each instance corresponds to a llvm::MDNode.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • name (String)
  • dest (FFI::Pointer(*ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Modulellvm::Module::getNamedMetadata()
  • llvmllvm::MDNodellvm::MDNode::getOperand()


1153
# File 'lib/llvm/core_ffi.rb', line 1153

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [:pointer, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

Advance a basic block iterator.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))


4214
# File 'lib/llvm/core_ffi.rb', line 4214

attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [:pointer], :pointer

.get_next_function(fn) ⇒ FFI::Pointer(ValueRef)

Advance a Function iterator to the next Function.

Returns NULL if the iterator was already at the end and there are no more functions.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1222
# File 'lib/llvm/core_ffi.rb', line 1222

attach_function :get_next_function, :LLVMGetNextFunction, [:pointer], :pointer

.get_next_global(global_var) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


3697
# File 'lib/llvm/core_ffi.rb', line 3697

attach_function :get_next_global, :LLVMGetNextGlobal, [:pointer], :pointer

.get_next_instruction(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the instruction that occurs after the one specified.

The next instruction will be from the same basic block.

If this is the last instruction in a basic block, NULL will be returned.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


4402
# File 'lib/llvm/core_ffi.rb', line 4402

attach_function :get_next_instruction, :LLVMGetNextInstruction, [:pointer], :pointer

.get_next_param(arg) ⇒ FFI::Pointer(ValueRef)

Obtain the next parameter to a function.

This takes an LLVMValueRef obtained from LLVMGetFirstParam() (which is actually a wrapped iterator) and obtains the next parameter from the underlying iterator.

Parameters:

  • arg (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


4001
# File 'lib/llvm/core_ffi.rb', line 4001

attach_function :get_next_param, :LLVMGetNextParam, [:pointer], :pointer

.get_next_target(t) ⇒ Target

Returns the next llvm::Target given a previous one (or null if there’s none)

Parameters:

Returns:



444
# File 'lib/llvm/target_ffi.rb', line 444

attach_function :get_next_target, :LLVMGetNextTarget, [Target], Target

.get_next_use(u) ⇒ FFI::Pointer(UseRef)

Obtain the next use of a value.

This effectively advances the iterator. It returns NULL if you are on the final use and no more are available.

Parameters:

  • u (FFI::Pointer(UseRef))

Returns:

  • (FFI::Pointer(UseRef))


2551
# File 'lib/llvm/core_ffi.rb', line 2551

attach_function :get_next_use, :LLVMGetNextUse, [:pointer], :pointer

.get_num_operands(val) ⇒ Integer

Obtain the number of operands in a llvm::User value.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Userllvm::User::getNumOperands()


2617
# File 'lib/llvm/core_ffi.rb', line 2617

attach_function :get_num_operands, :LLVMGetNumOperands, [:pointer], :int

.get_num_successors(term) ⇒ Integer

Return the number of successors that this terminator has.

Parameters:

  • term (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::TerminatorInstllvm::TerminatorInst::getNumSuccessors


4548
# File 'lib/llvm/core_ffi.rb', line 4548

attach_function :get_num_successors, :LLVMGetNumSuccessors, [:pointer], :uint

.get_operand(val, index) ⇒ FFI::Pointer(ValueRef)

Obtain an operand at a specific index in a llvm::User value.

Parameters:

  • val (FFI::Pointer(ValueRef))
  • index (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Userllvm::User::getOperand()


2584
# File 'lib/llvm/core_ffi.rb', line 2584

attach_function :get_operand, :LLVMGetOperand, [:pointer, :uint], :pointer

.get_operand_use(val, index) ⇒ FFI::Pointer(UseRef)

Obtain the use of an operand at a specific index in a llvm::User value.

Parameters:

  • val (FFI::Pointer(ValueRef))
  • index (Integer)

Returns:

  • (FFI::Pointer(UseRef))

See Also:

  • llvmllvm::Userllvm::User::getOperandUse()


2595
# File 'lib/llvm/core_ffi.rb', line 2595

attach_function :get_operand_use, :LLVMGetOperandUse, [:pointer, :uint], :pointer

.get_ordering(memory_access_inst) ⇒ Symbol from _enum_atomic_ordering_

(Not documented)

Parameters:

  • memory_access_inst (FFI::Pointer(ValueRef))

Returns:



5410
# File 'lib/llvm/core_ffi.rb', line 5410

attach_function :get_ordering, :LLVMGetOrdering, [:pointer], :atomic_ordering

.get_param(fn, index) ⇒ FFI::Pointer(ValueRef)

Obtain the parameter at the specified index.

Parameters are indexed from 0.

Parameters:

  • fn (FFI::Pointer(ValueRef))
  • index (Integer)

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


3955
# File 'lib/llvm/core_ffi.rb', line 3955

attach_function :get_param, :LLVMGetParam, [:pointer, :uint], :pointer

.get_param_parent(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the function to which this argument belongs.

Unlike other functions in this group, this one takes an LLVMValueRef that corresponds to a llvm::Attribute.

The returned LLVMValueRef is the llvm::Function to which this argument belongs.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


3969
# File 'lib/llvm/core_ffi.rb', line 3969

attach_function :get_param_parent, :LLVMGetParamParent, [:pointer], :pointer

.get_param_types(function_ty, dest) ⇒ nil

Obtain the types of a function’s parameters.

The Dest parameter should point to a pre-allocated array of LLVMTypeRef at least LLVMCountParamTypes() large. On return, the first LLVMCountParamTypes() entries in the array will be populated with LLVMTypeRef instances.

Parameters:

  • FunctionTy

    The function type to operate on.

  • Dest

    Memory address of an array to be filled with result.

  • function_ty (FFI::Pointer(TypeRef))
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil)


1550
# File 'lib/llvm/core_ffi.rb', line 1550

attach_function :get_param_types, :LLVMGetParamTypes, [:pointer, :pointer], :void

.get_params(fn, params) ⇒ nil

Obtain the parameters in a function.

The takes a pointer to a pre-allocated array of LLVMValueRef that is at least LLVMCountParams() long. This array will be filled with LLVMValueRef instances which correspond to the parameters the function receives. Each LLVMValueRef corresponds to a llvm::Argument instance.

Parameters:

  • fn (FFI::Pointer(ValueRef))
  • params (FFI::Pointer(*ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


3942
# File 'lib/llvm/core_ffi.rb', line 3942

attach_function :get_params, :LLVMGetParams, [:pointer, :pointer], :void

.get_personality_fn(fn) ⇒ FFI::Pointer(ValueRef)

Obtain the personality function attached to the function.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Functionllvm::Function::getPersonalityFn()


3835
# File 'lib/llvm/core_ffi.rb', line 3835

attach_function :get_personality_fn, :LLVMGetPersonalityFn, [:pointer], :pointer

.get_pointer_address_space(pointer_ty) ⇒ Integer

Obtain the address space of a pointer type.

This only works on types that represent pointers.

Parameters:

  • pointer_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::PointerTypellvm::PointerType::getAddressSpace()


1733
# File 'lib/llvm/core_ffi.rb', line 1733

attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [:pointer], :uint

.get_pointer_to_global(ee, global) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void))


331
# File 'lib/llvm/execution_engine_ffi.rb', line 331

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, :pointer], :pointer

.get_previous_basic_block(bb) ⇒ FFI::Pointer(BasicBlockRef)

Go backwards in a basic block iterator.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))


4222
# File 'lib/llvm/core_ffi.rb', line 4222

attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [:pointer], :pointer

.get_previous_function(fn) ⇒ FFI::Pointer(ValueRef)

Decrement a Function iterator to the previous Function.

Returns NULL if the iterator was already at the beginning and there are no previous functions.

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1233
# File 'lib/llvm/core_ffi.rb', line 1233

attach_function :get_previous_function, :LLVMGetPreviousFunction, [:pointer], :pointer

.get_previous_global(global_var) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


3705
# File 'lib/llvm/core_ffi.rb', line 3705

attach_function :get_previous_global, :LLVMGetPreviousGlobal, [:pointer], :pointer

.get_previous_instruction(inst) ⇒ FFI::Pointer(ValueRef)

Obtain the instruction that occurred before this one.

If the instruction is the first instruction in a basic block, NULL will be returned.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


4413
# File 'lib/llvm/core_ffi.rb', line 4413

attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [:pointer], :pointer

.get_previous_param(arg) ⇒ FFI::Pointer(ValueRef)

Obtain the previous parameter to a function.

This is the opposite of LLVMGetNextParam().

Parameters:

  • arg (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


4011
# File 'lib/llvm/core_ffi.rb', line 4011

attach_function :get_previous_param, :LLVMGetPreviousParam, [:pointer], :pointer

.get_return_type(function_ty) ⇒ FFI::Pointer(TypeRef)

Obtain the Type this function Type returns.

Parameters:

  • function_ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(TypeRef))


1525
# File 'lib/llvm/core_ffi.rb', line 1525

attach_function :get_return_type, :LLVMGetReturnType, [:pointer], :pointer

.get_section(global) ⇒ String

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:

  • (String)


3552
# File 'lib/llvm/core_ffi.rb', line 3552

attach_function :get_section, :LLVMGetSection, [:pointer], :string

.get_struct_element_types(struct_ty, dest) ⇒ nil

Get the elements within a structure.

The function is passed the address of a pre-allocated array of LLVMTypeRef at least LLVMCountStructElementTypes() long. After invocation, this array will be populated with the structure’s elements. The objects in the destination array will have a lifetime of the structure type itself, which is the lifetime of the context it is contained in.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil)


1638
# File 'lib/llvm/core_ffi.rb', line 1638

attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [:pointer, :pointer], :void

.get_struct_name(ty) ⇒ String

Obtain the name of a structure.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (String)

See Also:

  • llvmllvm::StructTypellvm::StructType::getName()


1599
# File 'lib/llvm/core_ffi.rb', line 1599

attach_function :get_struct_name, :LLVMGetStructName, [:pointer], :string

.get_successor(term, i) ⇒ FFI::Pointer(BasicBlockRef)

Return the specified successor.

Parameters:

  • term (FFI::Pointer(ValueRef))
  • i (Integer)

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::TerminatorInstllvm::TerminatorInst::getSuccessor


4559
# File 'lib/llvm/core_ffi.rb', line 4559

attach_function :get_successor, :LLVMGetSuccessor, [:pointer, :uint], :pointer

.get_switch_default_dest(switch_instr) ⇒ FFI::Pointer(BasicBlockRef)

Obtain the default destination basic block of a switch instruction.

This only works on llvm::SwitchInst instructions.

Parameters:

  • switch_instr (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::SwitchInstllvm::SwitchInst::getDefaultDest()


4620
# File 'lib/llvm/core_ffi.rb', line 4620

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [:pointer], :pointer

.get_target(m) ⇒ String

Obtain the target triple for a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (String)

See Also:

  • Module::getTargetTriple()


1049
# File 'lib/llvm/core_ffi.rb', line 1049

attach_function :get_target, :LLVMGetTarget, [:pointer], :string

.get_target_description(t) ⇒ String

Returns the description of a target. See llvm::Target::getDescription

Parameters:

Returns:

  • (String)


481
# File 'lib/llvm/target_ffi.rb', line 481

attach_function :get_target_description, :LLVMGetTargetDescription, [Target], :string

.get_target_from_name(name) ⇒ Target

Finds the target corresponding to the given name and stores it in p T.

Returns 0 on success.

Parameters:

  • name (String)

Returns:



453
# File 'lib/llvm/target_ffi.rb', line 453

attach_function :get_target_from_name, :LLVMGetTargetFromName, [:string], Target

.get_target_from_triple(triple, t, error_message) ⇒ Integer

Finds the target corresponding to the given triple and stores it in p T.

Returns 0 on success. Optionally returns any error in ErrorMessage.
Use LLVMDisposeMessage to dispose the message.

Parameters:

  • triple (String)
  • t (FFI::Pointer(*TargetRef))
  • error_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)


465
# File 'lib/llvm/target_ffi.rb', line 465

attach_function :get_target_from_triple, :LLVMGetTargetFromTriple, [:string, :pointer, :pointer], :int

.get_target_machine_cpu(t) ⇒ String

Returns the cpu used creating this target machine. See

llvm::TargetMachine::getCPU. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

Returns:

  • (String)


556
# File 'lib/llvm/target_ffi.rb', line 556

attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string

.get_target_machine_feature_string(t) ⇒ String

Returns the feature string used creating this target machine. See

llvm::TargetMachine::getFeatureString. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

Returns:

  • (String)


566
# File 'lib/llvm/target_ffi.rb', line 566

attach_function :get_target_machine_feature_string, :LLVMGetTargetMachineFeatureString, [OpaqueTargetMachine], :string

.get_target_machine_target(t) ⇒ Target

Returns the Target used in a TargetMachine

Parameters:

Returns:



536
# File 'lib/llvm/target_ffi.rb', line 536

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:

Returns:

  • (String)


546
# File 'lib/llvm/target_ffi.rb', line 546

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:

Returns:

  • (String)


473
# File 'lib/llvm/target_ffi.rb', line 473

attach_function :get_target_name, :LLVMGetTargetName, [Target], :string

.get_thread_local_mode(global_var) ⇒ Symbol from _enum_thread_local_mode_

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:



3772
# File 'lib/llvm/core_ffi.rb', line 3772

attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [:pointer], :thread_local_mode

.get_type_by_name(m, name) ⇒ FFI::Pointer(TypeRef)

Obtain a Type from a module by its registered name.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • name (String)

Returns:

  • (FFI::Pointer(TypeRef))


1124
# File 'lib/llvm/core_ffi.rb', line 1124

attach_function :get_type_by_name, :LLVMGetTypeByName, [:pointer, :string], :pointer

.get_type_context(ty) ⇒ FFI::Pointer(ContextRef)

Obtain the context to which this type instance is associated.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ContextRef))

See Also:

  • llvmllvm::Typellvm::Type::getContext()


1265
# File 'lib/llvm/core_ffi.rb', line 1265

attach_function :get_type_context, :LLVMGetTypeContext, [:pointer], :pointer

.get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

Obtain the enumerated type of a Type instance.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

See Also:

  • llvm::Type:getTypeID()


1243
# File 'lib/llvm/core_ffi.rb', line 1243

attach_function :get_type_kind, :LLVMGetTypeKind, [:pointer], :type_kind

.get_undef(ty) ⇒ FFI::Pointer(ValueRef)

Obtain a constant value referring to an undefined value of a type.

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::UndefValuellvm::UndefValue::get()


2650
# File 'lib/llvm/core_ffi.rb', line 2650

attach_function :get_undef, :LLVMGetUndef, [:pointer], :pointer

.get_used_value(u) ⇒ FFI::Pointer(ValueRef)

Obtain the value this use corresponds to.

Parameters:

  • u (FFI::Pointer(UseRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvm::Use::get().


2573
# File 'lib/llvm/core_ffi.rb', line 2573

attach_function :get_used_value, :LLVMGetUsedValue, [:pointer], :pointer

.get_user(u) ⇒ FFI::Pointer(ValueRef)

Obtain the user value for a user.

The returned value corresponds to a llvm::User type.

Parameters:

  • u (FFI::Pointer(UseRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Usellvm::Use::getUser()


2563
# File 'lib/llvm/core_ffi.rb', line 2563

attach_function :get_user, :LLVMGetUser, [:pointer], :pointer

.get_value_name(val) ⇒ String

Obtain the string name of a value.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (String)

See Also:

  • llvmllvm::Valuellvm::Value::getName()


1826
# File 'lib/llvm/core_ffi.rb', line 1826

attach_function :get_value_name, :LLVMGetValueName, [:pointer], :string

.get_vector_size(vector_ty) ⇒ Integer

Obtain the number of elements in a vector type.

This only works on types that represent vectors.

Parameters:

  • vector_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::VectorTypellvm::VectorType::getNumElements()


1760
# File 'lib/llvm/core_ffi.rb', line 1760

attach_function :get_vector_size, :LLVMGetVectorSize, [:pointer], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:



3569
# File 'lib/llvm/core_ffi.rb', line 3569

attach_function :get_visibility, :LLVMGetVisibility, [:pointer], :visibility

.get_volatile(memory_access_inst) ⇒ Integer

(Not documented)

Parameters:

  • memory_access_inst (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


5393
# File 'lib/llvm/core_ffi.rb', line 5393

attach_function :get_volatile, :LLVMGetVolatile, [:pointer], :int

.half_typeFFI::Pointer(TypeRef)

Obtain a floating point type from the global context.

These map to the functions in this group of the same name.

Returns:

  • (FFI::Pointer(TypeRef))


1460
# File 'lib/llvm/core_ffi.rb', line 1460

attach_function :half_type, :LLVMHalfType, [], :pointer

.half_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 16-bit floating point type from a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1410
# File 'lib/llvm/core_ffi.rb', line 1410

attach_function :half_type_in_context, :LLVMHalfTypeInContext, [:pointer], :pointer

.has_metadata(val) ⇒ Integer

Determine whether an instruction has any metadata attached.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


4360
# File 'lib/llvm/core_ffi.rb', line 4360

attach_function :has_metadata, :LLVMHasMetadata, [:pointer], :int

.has_unnamed_addr(global) ⇒ Integer

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


3603
# File 'lib/llvm/core_ffi.rb', line 3603

attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [:pointer], :int

.initialize_all_asm_parsersnil

(Not documented)

Returns:

  • (nil)


76
# File 'lib/llvm/target_ffi.rb', line 76

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

.initialize_all_asm_printersnil

(Not documented)

Returns:

  • (nil)


69
# File 'lib/llvm/target_ffi.rb', line 69

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

.initialize_all_disassemblersnil

(Not documented)

Returns:

  • (nil)


83
# File 'lib/llvm/target_ffi.rb', line 83

attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void

.initialize_all_target_infosnil

(Not documented)

Returns:

  • (nil)


48
# File 'lib/llvm/target_ffi.rb', line 48

attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void

.initialize_all_target_m_csnil

(Not documented)

Returns:

  • (nil)


62
# File 'lib/llvm/target_ffi.rb', line 62

attach_function :initialize_all_target_m_cs, :LLVMInitializeAllTargetMCs, [], :void

.initialize_all_targetsnil

(Not documented)

Returns:

  • (nil)


55
# File 'lib/llvm/target_ffi.rb', line 55

attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void

.initialize_core(r) ⇒ nil

@}

Parameters:

  • r (FFI::Pointer(PassRegistryRef))

Returns:

  • (nil)


828
# File 'lib/llvm/core_ffi.rb', line 828

attach_function :initialize_core, :LLVMInitializeCore, [:pointer], :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 (FFI::Pointer(PassManagerRef))

Returns:

  • (Integer)


5963
# File 'lib/llvm/core_ffi.rb', line 5963

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [:pointer], :int

.initialize_mcjit_compiler_options(options, size_of_options) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


175
# File 'lib/llvm/execution_engine_ffi.rb', line 175

attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void

.initialize_native_asm_parserInteger

(Not documented)

Returns:

  • (Integer)


97
# File 'lib/llvm/target_ffi.rb', line 97

attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int

.initialize_native_asm_printerInteger

(Not documented)

Returns:

  • (Integer)


104
# File 'lib/llvm/target_ffi.rb', line 104

attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int

.initialize_native_disassemblerInteger

(Not documented)

Returns:

  • (Integer)


111
# File 'lib/llvm/target_ffi.rb', line 111

attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int

.initialize_native_targetInteger

(Not documented)

Returns:

  • (Integer)


90
# File 'lib/llvm/target_ffi.rb', line 90

attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int

.insert_basic_block(insert_before_bb, name) ⇒ FFI::Pointer(BasicBlockRef)

Insert a basic block in a function using the global context.

Parameters:

  • insert_before_bb (FFI::Pointer(BasicBlockRef))
  • name (String)

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::Create()


4283
# File 'lib/llvm/core_ffi.rb', line 4283

attach_function :insert_basic_block, :LLVMInsertBasicBlock, [:pointer, :string], :pointer

.insert_basic_block_in_context(c, bb, name) ⇒ FFI::Pointer(BasicBlockRef)

Insert a basic block in a function before another basic block.

The function to add to is determined by the function of the passed basic block.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • bb (FFI::Pointer(BasicBlockRef))
  • name (String)

Returns:

  • (FFI::Pointer(BasicBlockRef))

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::Create()


4272
# File 'lib/llvm/core_ffi.rb', line 4272

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [:pointer, :pointer, :string], :pointer

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • instr (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4730
# File 'lib/llvm/core_ffi.rb', line 4730

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [:pointer, :pointer], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • instr (FFI::Pointer(ValueRef))
  • name (String)

Returns:

  • (nil)


4740
# File 'lib/llvm/core_ffi.rb', line 4740

attach_function :insert_into_builder_with_name, :LLVMInsertIntoBuilderWithName, [:pointer, :pointer, :string], :void

.instruction_clone(inst) ⇒ FFI::Pointer(ValueRef)

Create a copy of ‘this’ instruction that is identical in all ways except the following:

* The instruction has no parent
* The instruction has no name

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))

See Also:

  • llvmllvm::Instructionllvm::Instruction::clone()


4475
# File 'lib/llvm/core_ffi.rb', line 4475

attach_function :instruction_clone, :LLVMInstructionClone, [:pointer], :pointer

.instruction_erase_from_parent(inst) ⇒ nil

Remove and delete an instruction.

The instruction specified is removed from its containing building block and then deleted.

Parameters:

  • inst (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Instructionllvm::Instruction::eraseFromParent()


4426
# File 'lib/llvm/core_ffi.rb', line 4426

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [:pointer], :void

.int128_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1386
# File 'lib/llvm/core_ffi.rb', line 1386

attach_function :int128_type, :LLVMInt128Type, [], :pointer

.int128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1334
# File 'lib/llvm/core_ffi.rb', line 1334

attach_function :int128_type_in_context, :LLVMInt128TypeInContext, [:pointer], :pointer

.int16_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1365
# File 'lib/llvm/core_ffi.rb', line 1365

attach_function :int16_type, :LLVMInt16Type, [], :pointer

.int16_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1310
# File 'lib/llvm/core_ffi.rb', line 1310

attach_function :int16_type_in_context, :LLVMInt16TypeInContext, [:pointer], :pointer

.int1_typeFFI::Pointer(TypeRef)

Obtain an integer type from the global context with a specified bit width.

Returns:

  • (FFI::Pointer(TypeRef))


1351
# File 'lib/llvm/core_ffi.rb', line 1351

attach_function :int1_type, :LLVMInt1Type, [], :pointer

.int1_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain an integer type from a context with specified bit width.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1294
# File 'lib/llvm/core_ffi.rb', line 1294

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [:pointer], :pointer

.int32_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1372
# File 'lib/llvm/core_ffi.rb', line 1372

attach_function :int32_type, :LLVMInt32Type, [], :pointer

.int32_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1318
# File 'lib/llvm/core_ffi.rb', line 1318

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [:pointer], :pointer

.int64_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1379
# File 'lib/llvm/core_ffi.rb', line 1379

attach_function :int64_type, :LLVMInt64Type, [], :pointer

.int64_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1326
# File 'lib/llvm/core_ffi.rb', line 1326

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [:pointer], :pointer

.int8_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1358
# File 'lib/llvm/core_ffi.rb', line 1358

attach_function :int8_type, :LLVMInt8Type, [], :pointer

.int8_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1302
# File 'lib/llvm/core_ffi.rb', line 1302

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [:pointer], :pointer

.int_ptr_type(td) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TypeRef))


194
# File 'lib/llvm/target_ffi.rb', line 194

attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], :pointer

.int_ptr_type_for_as(td, as) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TypeRef))


203
# File 'lib/llvm/target_ffi.rb', line 203

attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], :pointer

.int_ptr_type_for_as_in_context(c, td, as) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TypeRef))


222
# File 'lib/llvm/target_ffi.rb', line 222

attach_function :int_ptr_type_for_as_in_context, :LLVMIntPtrTypeForASInContext, [:pointer, OpaqueTargetData, :uint], :pointer

.int_ptr_type_in_context(c, td) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TypeRef))


212
# File 'lib/llvm/target_ffi.rb', line 212

attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [:pointer, OpaqueTargetData], :pointer

.int_type(num_bits) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • num_bits (Integer)

Returns:

  • (FFI::Pointer(TypeRef))


1394
# File 'lib/llvm/core_ffi.rb', line 1394

attach_function :int_type, :LLVMIntType, [:uint], :pointer

.int_type_in_context(c, num_bits) ⇒ FFI::Pointer(TypeRef)

(Not documented)

Parameters:

  • c (FFI::Pointer(ContextRef))
  • num_bits (Integer)

Returns:

  • (FFI::Pointer(TypeRef))


1343
# File 'lib/llvm/core_ffi.rb', line 1343

attach_function :int_type_in_context, :LLVMIntTypeInContext, [:pointer, :uint], :pointer

.is_a_addr_space_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2389
# File 'lib/llvm/core_ffi.rb', line 2389

attach_function :is_a_addr_space_cast_inst, :LLVMIsAAddrSpaceCastInst, [:pointer], :pointer

.is_a_alloca_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2373
# File 'lib/llvm/core_ffi.rb', line 2373

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [:pointer], :pointer

.is_a_argument(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1893
# File 'lib/llvm/core_ffi.rb', line 1893

attach_function :is_a_argument, :LLVMIsAArgument, [:pointer], :pointer

.is_a_basic_block(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1901
# File 'lib/llvm/core_ffi.rb', line 1901

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [:pointer], :pointer

.is_a_binary_operator(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2093
# File 'lib/llvm/core_ffi.rb', line 2093

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [:pointer], :pointer

.is_a_bit_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2397
# File 'lib/llvm/core_ffi.rb', line 2397

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [:pointer], :pointer

.is_a_block_address(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1933
# File 'lib/llvm/core_ffi.rb', line 1933

attach_function :is_a_block_address, :LLVMIsABlockAddress, [:pointer], :pointer

.is_a_branch_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2269
# File 'lib/llvm/core_ffi.rb', line 2269

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [:pointer], :pointer

.is_a_call_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2101
# File 'lib/llvm/core_ffi.rb', line 2101

attach_function :is_a_call_inst, :LLVMIsACallInst, [:pointer], :pointer

.is_a_cast_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2381
# File 'lib/llvm/core_ffi.rb', line 2381

attach_function :is_a_cast_inst, :LLVMIsACastInst, [:pointer], :pointer

.is_a_catch_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2349
# File 'lib/llvm/core_ffi.rb', line 2349

attach_function :is_a_catch_pad_inst, :LLVMIsACatchPadInst, [:pointer], :pointer

.is_a_catch_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2333
# File 'lib/llvm/core_ffi.rb', line 2333

attach_function :is_a_catch_return_inst, :LLVMIsACatchReturnInst, [:pointer], :pointer

.is_a_cleanup_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2357
# File 'lib/llvm/core_ffi.rb', line 2357

attach_function :is_a_cleanup_pad_inst, :LLVMIsACleanupPadInst, [:pointer], :pointer

.is_a_cleanup_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2325
# File 'lib/llvm/core_ffi.rb', line 2325

attach_function :is_a_cleanup_return_inst, :LLVMIsACleanupReturnInst, [:pointer], :pointer

.is_a_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2165
# File 'lib/llvm/core_ffi.rb', line 2165

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [:pointer], :pointer

.is_a_constant(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1925
# File 'lib/llvm/core_ffi.rb', line 1925

attach_function :is_a_constant, :LLVMIsAConstant, [:pointer], :pointer

.is_a_constant_aggregate_zero(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1941
# File 'lib/llvm/core_ffi.rb', line 1941

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [:pointer], :pointer

.is_a_constant_array(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1949
# File 'lib/llvm/core_ffi.rb', line 1949

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [:pointer], :pointer

.is_a_constant_data_array(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1965
# File 'lib/llvm/core_ffi.rb', line 1965

attach_function :is_a_constant_data_array, :LLVMIsAConstantDataArray, [:pointer], :pointer

.is_a_constant_data_sequential(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1957
# File 'lib/llvm/core_ffi.rb', line 1957

attach_function :is_a_constant_data_sequential, :LLVMIsAConstantDataSequential, [:pointer], :pointer

.is_a_constant_data_vector(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1973
# File 'lib/llvm/core_ffi.rb', line 1973

attach_function :is_a_constant_data_vector, :LLVMIsAConstantDataVector, [:pointer], :pointer

.is_a_constant_expr(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1981
# File 'lib/llvm/core_ffi.rb', line 1981

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [:pointer], :pointer

.is_a_constant_fp(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1989
# File 'lib/llvm/core_ffi.rb', line 1989

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [:pointer], :pointer

.is_a_constant_int(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1997
# File 'lib/llvm/core_ffi.rb', line 1997

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [:pointer], :pointer

.is_a_constant_pointer_null(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2005
# File 'lib/llvm/core_ffi.rb', line 2005

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [:pointer], :pointer

.is_a_constant_struct(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2013
# File 'lib/llvm/core_ffi.rb', line 2013

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [:pointer], :pointer

.is_a_constant_token_none(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2021
# File 'lib/llvm/core_ffi.rb', line 2021

attach_function :is_a_constant_token_none, :LLVMIsAConstantTokenNone, [:pointer], :pointer

.is_a_constant_vector(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2029
# File 'lib/llvm/core_ffi.rb', line 2029

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [:pointer], :pointer

.is_a_dbg_declare_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2125
# File 'lib/llvm/core_ffi.rb', line 2125

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [:pointer], :pointer

.is_a_dbg_info_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2117
# File 'lib/llvm/core_ffi.rb', line 2117

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [:pointer], :pointer

.is_a_extract_element_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2189
# File 'lib/llvm/core_ffi.rb', line 2189

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [:pointer], :pointer

.is_a_extract_value_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2493
# File 'lib/llvm/core_ffi.rb', line 2493

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [:pointer], :pointer

.is_a_funclet_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2341
# File 'lib/llvm/core_ffi.rb', line 2341

attach_function :is_a_funclet_pad_inst, :LLVMIsAFuncletPadInst, [:pointer], :pointer

.is_a_function(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2061
# File 'lib/llvm/core_ffi.rb', line 2061

attach_function :is_a_function, :LLVMIsAFunction, [:pointer], :pointer

.is_a_get_element_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2197
# File 'lib/llvm/core_ffi.rb', line 2197

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [:pointer], :pointer

.is_a_global_alias(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2045
# File 'lib/llvm/core_ffi.rb', line 2045

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [:pointer], :pointer

.is_a_global_object(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2053
# File 'lib/llvm/core_ffi.rb', line 2053

attach_function :is_a_global_object, :LLVMIsAGlobalObject, [:pointer], :pointer

.is_a_global_value(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2037
# File 'lib/llvm/core_ffi.rb', line 2037

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [:pointer], :pointer

.is_a_global_variable(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2069
# File 'lib/llvm/core_ffi.rb', line 2069

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [:pointer], :pointer

.is_a_indirect_br_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2277
# File 'lib/llvm/core_ffi.rb', line 2277

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [:pointer], :pointer

.is_a_inline_asm(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1909
# File 'lib/llvm/core_ffi.rb', line 1909

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [:pointer], :pointer

.is_a_insert_element_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2205
# File 'lib/llvm/core_ffi.rb', line 2205

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [:pointer], :pointer

.is_a_insert_value_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2213
# File 'lib/llvm/core_ffi.rb', line 2213

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [:pointer], :pointer

.is_a_instruction(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2085
# File 'lib/llvm/core_ffi.rb', line 2085

attach_function :is_a_instruction, :LLVMIsAInstruction, [:pointer], :pointer

.is_a_int_to_ptr_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2437
# File 'lib/llvm/core_ffi.rb', line 2437

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [:pointer], :pointer

.is_a_intrinsic_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2109
# File 'lib/llvm/core_ffi.rb', line 2109

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [:pointer], :pointer

.is_a_invoke_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2285
# File 'lib/llvm/core_ffi.rb', line 2285

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [:pointer], :pointer

.is_a_landing_pad_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2221
# File 'lib/llvm/core_ffi.rb', line 2221

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [:pointer], :pointer

.is_a_load_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2501
# File 'lib/llvm/core_ffi.rb', line 2501

attach_function :is_a_load_inst, :LLVMIsALoadInst, [:pointer], :pointer

.is_a_mem_cpy_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2141
# File 'lib/llvm/core_ffi.rb', line 2141

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [:pointer], :pointer

.is_a_mem_intrinsic(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2133
# File 'lib/llvm/core_ffi.rb', line 2133

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [:pointer], :pointer

.is_a_mem_move_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2149
# File 'lib/llvm/core_ffi.rb', line 2149

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [:pointer], :pointer

.is_a_mem_set_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2157
# File 'lib/llvm/core_ffi.rb', line 2157

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [:pointer], :pointer

.is_a_ptr_to_int_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2445
# File 'lib/llvm/core_ffi.rb', line 2445

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [:pointer], :pointer

.is_a_resume_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2317
# File 'lib/llvm/core_ffi.rb', line 2317

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [:pointer], :pointer

.is_a_return_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2293
# File 'lib/llvm/core_ffi.rb', line 2293

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [:pointer], :pointer

.is_a_select_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2237
# File 'lib/llvm/core_ffi.rb', line 2237

attach_function :is_a_select_inst, :LLVMIsASelectInst, [:pointer], :pointer

.is_a_shuffle_vector_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2245
# File 'lib/llvm/core_ffi.rb', line 2245

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [:pointer], :pointer

.is_a_store_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2253
# File 'lib/llvm/core_ffi.rb', line 2253

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [:pointer], :pointer

.is_a_switch_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2301
# File 'lib/llvm/core_ffi.rb', line 2301

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [:pointer], :pointer

.is_a_terminator_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2261
# File 'lib/llvm/core_ffi.rb', line 2261

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [:pointer], :pointer

.is_a_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2469
# File 'lib/llvm/core_ffi.rb', line 2469

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [:pointer], :pointer

.is_a_unary_instruction(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2365
# File 'lib/llvm/core_ffi.rb', line 2365

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [:pointer], :pointer

.is_a_undef_value(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2077
# File 'lib/llvm/core_ffi.rb', line 2077

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [:pointer], :pointer

.is_a_unreachable_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2309
# File 'lib/llvm/core_ffi.rb', line 2309

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [:pointer], :pointer

.is_a_user(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


1917
# File 'lib/llvm/core_ffi.rb', line 1917

attach_function :is_a_user, :LLVMIsAUser, [:pointer], :pointer

.is_af_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2173
# File 'lib/llvm/core_ffi.rb', line 2173

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [:pointer], :pointer

.is_afp_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2405
# File 'lib/llvm/core_ffi.rb', line 2405

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [:pointer], :pointer

.is_afp_to_si_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2413
# File 'lib/llvm/core_ffi.rb', line 2413

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [:pointer], :pointer

.is_afp_to_ui_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2421
# File 'lib/llvm/core_ffi.rb', line 2421

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [:pointer], :pointer

.is_afp_trunc_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2429
# File 'lib/llvm/core_ffi.rb', line 2429

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [:pointer], :pointer

.is_ai_cmp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2181
# File 'lib/llvm/core_ffi.rb', line 2181

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [:pointer], :pointer

.is_amd_node(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2517
# File 'lib/llvm/core_ffi.rb', line 2517

attach_function :is_amd_node, :LLVMIsAMDNode, [:pointer], :pointer

.is_amd_string(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2525
# File 'lib/llvm/core_ffi.rb', line 2525

attach_function :is_amd_string, :LLVMIsAMDString, [:pointer], :pointer

.is_aphi_node(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2229
# File 'lib/llvm/core_ffi.rb', line 2229

attach_function :is_aphi_node, :LLVMIsAPHINode, [:pointer], :pointer

.is_as_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2453
# File 'lib/llvm/core_ffi.rb', line 2453

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [:pointer], :pointer

.is_asi_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2461
# File 'lib/llvm/core_ffi.rb', line 2461

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [:pointer], :pointer

.is_aui_to_fp_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2477
# File 'lib/llvm/core_ffi.rb', line 2477

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [:pointer], :pointer

.is_ava_arg_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2509
# File 'lib/llvm/core_ffi.rb', line 2509

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [:pointer], :pointer

.is_az_ext_inst(val) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(ValueRef))


2485
# File 'lib/llvm/core_ffi.rb', line 2485

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [:pointer], :pointer

.is_conditional(branch) ⇒ Integer

Return if a branch is conditional.

This only works on llvm::BranchInst instructions.

Parameters:

  • branch (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::BranchInstllvm::BranchInst::isConditional


4583
# File 'lib/llvm/core_ffi.rb', line 4583

attach_function :is_conditional, :LLVMIsConditional, [:pointer], :int

.is_constant(val) ⇒ Integer

Determine whether the specified constant instance is constant.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


1877
# File 'lib/llvm/core_ffi.rb', line 1877

attach_function :is_constant, :LLVMIsConstant, [:pointer], :int

.is_constant_string(c) ⇒ Integer

Returns true if the specified constant is an array of i8.

Parameters:

  • c (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • ConstantDataSequential::getAsString()


2831
# File 'lib/llvm/core_ffi.rb', line 2831

attach_function :is_constant_string, :LLVMIsConstantString, [:pointer], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


3527
# File 'lib/llvm/core_ffi.rb', line 3527

attach_function :is_declaration, :LLVMIsDeclaration, [:pointer], :int

.is_externally_initialized(global_var) ⇒ Integer

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


3789
# File 'lib/llvm/core_ffi.rb', line 3789

attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [:pointer], :int

.is_function_var_arg(function_ty) ⇒ Integer

Returns whether a function type is variadic.

Parameters:

  • function_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)


1517
# File 'lib/llvm/core_ffi.rb', line 1517

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [:pointer], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


3755
# File 'lib/llvm/core_ffi.rb', line 3755

attach_function :is_global_constant, :LLVMIsGlobalConstant, [:pointer], :int

.is_multithreadedInteger

Check whether LLVM is executing in thread-safe mode or not.

@see llvm::llvm_is_multithreaded

Returns:

  • (Integer)


6020
# File 'lib/llvm/core_ffi.rb', line 6020

attach_function :is_multithreaded, :LLVMIsMultithreaded, [], :int

.is_null(val) ⇒ Integer

Determine whether a value instance is null.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Constantllvm::Constant::isNullValue()


2660
# File 'lib/llvm/core_ffi.rb', line 2660

attach_function :is_null, :LLVMIsNull, [:pointer], :int

.is_opaque_struct(struct_ty) ⇒ Integer

Determine whether a structure is opaque.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::isOpaque()


1669
# File 'lib/llvm/core_ffi.rb', line 1669

attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [:pointer], :int

.is_packed_struct(struct_ty) ⇒ Integer

Determine whether a structure is packed.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::isPacked()


1659
# File 'lib/llvm/core_ffi.rb', line 1659

attach_function :is_packed_struct, :LLVMIsPackedStruct, [:pointer], :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 (FFI::Pointer(ValueRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::CallInstllvm::CallInst::isTailCall()


4525
# File 'lib/llvm/core_ffi.rb', line 4525

attach_function :is_tail_call, :LLVMIsTailCall, [:pointer], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


3738
# File 'lib/llvm/core_ffi.rb', line 3738

attach_function :is_thread_local, :LLVMIsThreadLocal, [:pointer], :int

.is_undef(val) ⇒ Integer

Determine whether a value instance is undefined.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


1885
# File 'lib/llvm/core_ffi.rb', line 1885

attach_function :is_undef, :LLVMIsUndef, [:pointer], :int

.label_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1799
# File 'lib/llvm/core_ffi.rb', line 1799

attach_function :label_type, :LLVMLabelType, [], :pointer

.label_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a label type in a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1776
# File 'lib/llvm/core_ffi.rb', line 1776

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [:pointer], :pointer

(Not documented)

Returns:

  • (nil)


30
# File 'lib/llvm/execution_engine_ffi.rb', line 30

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

@{

Returns:

  • (nil)


23
# File 'lib/llvm/execution_engine_ffi.rb', line 23

attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void

Links the source module into the destination module. The source module is destroyed. The return value is true if an error occurred, false otherwise. Use the diagnostic handler to get any diagnostic message.

Parameters:

  • dest (FFI::Pointer(ModuleRef))
  • src (FFI::Pointer(ModuleRef))

Returns:

  • (Integer)


43
# File 'lib/llvm/linker_ffi.rb', line 43

attach_function :link_modules2, :LLVMLinkModules2, [:pointer, :pointer], :int

.load_library_permanently(filename) ⇒ Integer

(Not documented)

Parameters:

  • filename (String)

Returns:

  • (Integer)


25
# File 'lib/llvm/core_ffi.rb', line 25

attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int

.md_node(vals, count) ⇒ FFI::Pointer(ValueRef)

Obtain a MDNode value from the global context.

Parameters:

  • vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


4069
# File 'lib/llvm/core_ffi.rb', line 4069

attach_function :md_node, :LLVMMDNode, [:pointer, :uint], :pointer

.md_node_in_context(c, vals, count) ⇒ FFI::Pointer(ValueRef)

Obtain a MDNode value from a context.

The returned value corresponds to the llvm::MDNode class.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


4060
# File 'lib/llvm/core_ffi.rb', line 4060

attach_function :md_node_in_context, :LLVMMDNodeInContext, [:pointer, :pointer, :uint], :pointer

.md_string(str, s_len) ⇒ FFI::Pointer(ValueRef)

Obtain a MDString value from the global context.

Parameters:

  • str (String)
  • s_len (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


4048
# File 'lib/llvm/core_ffi.rb', line 4048

attach_function :md_string, :LLVMMDString, [:string, :uint], :pointer

.md_string_in_context(c, str, s_len) ⇒ FFI::Pointer(ValueRef)

Obtain a MDString value from a context.

The returned instance corresponds to the llvm::MDString class.

The instance is specified by string data of a specified length. The string content is copied, so the backing memory can be freed after this function returns.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • str (String)
  • s_len (Integer)

Returns:

  • (FFI::Pointer(ValueRef))


4039
# File 'lib/llvm/core_ffi.rb', line 4039

attach_function :md_string_in_context, :LLVMMDStringInContext, [:pointer, :string, :uint], :pointer

.module_create_with_name(module_id) ⇒ FFI::Pointer(ModuleRef)

Create a new, empty module in the global context.

This is equivalent to calling LLVMModuleCreateWithNameInContext with LLVMGetGlobalContext() as the context parameter.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

  • module_id (String)

Returns:

  • (FFI::Pointer(ModuleRef))


987
# File 'lib/llvm/core_ffi.rb', line 987

attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], :pointer

.module_create_with_name_in_context(module_id, c) ⇒ FFI::Pointer(ModuleRef)

Create a new, empty module in a specific context.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

  • module_id (String)
  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(ModuleRef))


999
# File 'lib/llvm/core_ffi.rb', line 999

attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, :pointer], :pointer

.move_basic_block_after(bb, move_pos) ⇒ nil

Move a basic block to after another one.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))
  • move_pos (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::moveAfter()


4331
# File 'lib/llvm/core_ffi.rb', line 4331

attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [:pointer, :pointer], :void

.move_basic_block_before(bb, move_pos) ⇒ nil

Move a basic block to before another one.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))
  • move_pos (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::moveBefore()


4320
# File 'lib/llvm/core_ffi.rb', line 4320

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [:pointer, :pointer], :void

.offset_of_element(td, struct_ty, element) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


305
# File 'lib/llvm/target_ffi.rb', line 305

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)


23
# File 'lib/llvm/core/bitcode_ffi.rb', line 23

attach_function :parse_bitcode, :LLVMParseBitcode, [:pointer, :pointer, :pointer], :int

.parse_bitcode2(mem_buf, out_module) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_module (FFI::Pointer(*ModuleRef))

Returns:

  • (Integer)


32
# File 'lib/llvm/core/bitcode_ffi.rb', line 32

attach_function :parse_bitcode2, :LLVMParseBitcode2, [:pointer, :pointer], :int

.parse_bitcode_in_context(context_ref, mem_buf, out_module, out_message) ⇒ Integer

(Not documented)

Parameters:

  • context_ref (FFI::Pointer(ContextRef))
  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_module (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)


43
# File 'lib/llvm/core/bitcode_ffi.rb', line 43

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [:pointer, :pointer, :pointer, :pointer], :int

.parse_bitcode_in_context2(context_ref, mem_buf, out_module) ⇒ Integer

(Not documented)

Parameters:

  • context_ref (FFI::Pointer(ContextRef))
  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_module (FFI::Pointer(*ModuleRef))

Returns:

  • (Integer)


53
# File 'lib/llvm/core/bitcode_ffi.rb', line 53

attach_function :parse_bitcode_in_context2, :LLVMParseBitcodeInContext2, [:pointer, :pointer, :pointer], :int

.parse_command_line_options(argc, argv, overview) ⇒ nil

This function parses the given arguments using the LLVM command line parser. Note that the only stable thing about this function is its signature; you cannot rely on any particular set of command line arguments being interpreted the same way across LLVM versions.

Parameters:

  • argc (Integer)
  • argv (FFI::Pointer(**CharS))
  • overview (String)

Returns:

  • (nil)

See Also:

  • llvmllvm::clllvm::cl::ParseCommandLineOptions()


40
# File 'lib/llvm/core_ffi.rb', line 40

attach_function :parse_command_line_options, :LLVMParseCommandLineOptions, [:int, :pointer, :string], :void

.pass_manager_builder_createOpaquePassManagerBuilder

See llvm::PassManagerBuilder.



25
# 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:

Returns:

  • (nil)


33
# 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:

Returns:

  • (nil)


96
# 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:

Returns:

  • (nil)


116
# 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:

Returns:

  • (nil)


105
# 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:

Returns:

  • (nil)


78
# 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:

Returns:

  • (nil)


60
# 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:

Returns:

  • (nil)


69
# 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:

Returns:

  • (nil)


42
# 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:

Returns:

  • (nil)


51
# 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:

Returns:

  • (nil)


87
# File 'lib/llvm/transforms/builder_ffi.rb', line 87

attach_function :pass_manager_builder_use_inliner_with_threshold, :LLVMPassManagerBuilderUseInlinerWithThreshold, [OpaquePassManagerBuilder, :uint], :void

.pointer_size(td) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


177
# File 'lib/llvm/target_ffi.rb', line 177

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_size_for_as(td, as) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


186
# File 'lib/llvm/target_ffi.rb', line 186

attach_function :pointer_size_for_as, :LLVMPointerSizeForAS, [OpaqueTargetData, :uint], :uint

.pointer_type(element_type, address_space) ⇒ FFI::Pointer(TypeRef)

Create a pointer type that points to a defined type.

The created type will exist in the context that its pointee type exists in.

Parameters:

  • element_type (FFI::Pointer(TypeRef))
  • address_space (Integer)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::PointerTypellvm::PointerType::get()


1721
# File 'lib/llvm/core_ffi.rb', line 1721

attach_function :pointer_type, :LLVMPointerType, [:pointer, :uint], :pointer

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • block (FFI::Pointer(BasicBlockRef))
  • instr (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4687
# File 'lib/llvm/core_ffi.rb', line 4687

attach_function :position_builder, :LLVMPositionBuilder, [:pointer, :pointer, :pointer], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • block (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)


4705
# File 'lib/llvm/core_ffi.rb', line 4705

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [:pointer, :pointer], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • instr (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4696
# File 'lib/llvm/core_ffi.rb', line 4696

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [:pointer, :pointer], :void

.ppcfp128_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1495
# File 'lib/llvm/core_ffi.rb', line 1495

attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], :pointer

.ppcfp128_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 128-bit floating point type (two 64-bits) from a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1451
# File 'lib/llvm/core_ffi.rb', line 1451

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [:pointer], :pointer

.preferred_alignment_of_global(td, global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


285
# File 'lib/llvm/target_ffi.rb', line 285

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, :pointer], :uint

.preferred_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


276
# File 'lib/llvm/target_ffi.rb', line 276

attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, :pointer], :uint

Print a representation of a module to a file. The ErrorMessage needs to be disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • filename (String)
  • error_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)

See Also:

  • Module::print()


1083
# File 'lib/llvm/core_ffi.rb', line 1083

attach_function :print_module_to_file, :LLVMPrintModuleToFile, [:pointer, :string, :pointer], :int

Return a string representation of the module. Use LLVMDisposeMessage to free the string.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (String)

See Also:

  • Module::print()


1094
# File 'lib/llvm/core_ffi.rb', line 1094

attach_function :print_module_to_string, :LLVMPrintModuleToString, [:pointer], :string

Return a string representation of the type. Use LLVMDisposeMessage to free the string.

Parameters:

  • val (FFI::Pointer(TypeRef))

Returns:

  • (String)

See Also:

  • llvmllvm::Typellvm::Type::print()


1286
# File 'lib/llvm/core_ffi.rb', line 1286

attach_function :print_type_to_string, :LLVMPrintTypeToString, [:pointer], :string

Return a string representation of the value. Use LLVMDisposeMessage to free the string.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (String)

See Also:

  • llvmllvm::Valuellvm::Value::print()


1858
# File 'lib/llvm/core_ffi.rb', line 1858

attach_function :print_value_to_string, :LLVMPrintValueToString, [:pointer], :string

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void))


296
# File 'lib/llvm/execution_engine_ffi.rb', line 296

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, :pointer], :pointer

.remove_basic_block_from_parent(bb) ⇒ nil

Remove a basic block from a function.

This deletes the basic block from its containing function but keep the basic block alive.

Parameters:

  • bb (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::removeFromParent()


4309
# File 'lib/llvm/core_ffi.rb', line 4309

attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [:pointer], :void

.remove_module(ee, m, out_mod, out_error) ⇒ Integer

(Not documented)

Parameters:

  • ee (OpaqueExecutionEngine)
  • m (FFI::Pointer(ModuleRef))
  • out_mod (FFI::Pointer(*ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer)


277
# File 'lib/llvm/execution_engine_ffi.rb', line 277

attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int

.replace_all_uses_with(old_val, new_val) ⇒ nil

Replace all uses of a value with another one.

Parameters:

  • old_val (FFI::Pointer(ValueRef))
  • new_val (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::replaceAllUsesWith()


1869
# File 'lib/llvm/core_ffi.rb', line 1869

attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [:pointer, :pointer], :void

.run_function(ee, f, num_args, args) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

  • ee (OpaqueExecutionEngine)
  • f (FFI::Pointer(ValueRef))
  • num_args (Integer)
  • args (FFI::Pointer(*GenericValueRef))

Returns:



248
# File 'lib/llvm/execution_engine_ffi.rb', line 248

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)


237
# File 'lib/llvm/execution_engine_ffi.rb', line 237

attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [OpaqueExecutionEngine, :pointer, :uint, :pointer, :pointer], :int

.run_function_pass_manager(fpm, f) ⇒ Integer

Executes all of the function passes scheduled in the function pass manager

on the provided function. Returns 1 if any of the passes modified the
function, false otherwise.
@see llvm::FunctionPassManager::run(Function&)

Parameters:

  • fpm (FFI::Pointer(PassManagerRef))
  • f (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


5975
# File 'lib/llvm/core_ffi.rb', line 5975

attach_function :run_function_pass_manager, :LLVMRunFunctionPassManager, [:pointer, :pointer], :int

.run_pass_manager(pm, m) ⇒ Integer

Initializes, executes on the provided module, and finalizes all of the

passes scheduled in the pass manager. Returns 1 if any of the passes
modified the module, 0 otherwise.
@see llvm::PassManager::run(Module&)

Parameters:

  • pm (FFI::Pointer(PassManagerRef))
  • m (FFI::Pointer(ModuleRef))

Returns:

  • (Integer)


5953
# File 'lib/llvm/core_ffi.rb', line 5953

attach_function :run_pass_manager, :LLVMRunPassManager, [:pointer, :pointer], :int

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


217
# File 'lib/llvm/execution_engine_ffi.rb', line 217

attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void

.run_static_destructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


225
# File 'lib/llvm/execution_engine_ffi.rb', line 225

attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void

.search_for_address_of_symbol(symbol_name) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

  • symbol_name (String)

Returns:

  • (FFI::Pointer(*Void))


48
# File 'lib/llvm/core_ffi.rb', line 48

attach_function :search_for_address_of_symbol, :LLVMSearchForAddressOfSymbol, [:string], :pointer

.set_alignment(v, bytes) ⇒ nil

Set the preferred alignment of the value.

Parameters:

  • v (FFI::Pointer(ValueRef))
  • bytes (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::AllocaInstllvm::AllocaInst::setAlignment()
  • llvmllvm::LoadInstllvm::LoadInst::setAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::setAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::setAlignment()


3637
# File 'lib/llvm/core_ffi.rb', line 3637

attach_function :set_alignment, :LLVMSetAlignment, [:pointer, :uint], :void

.set_cleanup(landing_pad, val) ⇒ nil

Set the ‘cleanup’ flag in the landingpad instruction

Parameters:

  • landing_pad (FFI::Pointer(ValueRef))
  • val (Integer)

Returns:

  • (nil)


4922
# File 'lib/llvm/core_ffi.rb', line 4922

attach_function :set_cleanup, :LLVMSetCleanup, [:pointer, :int], :void

.set_condition(branch, cond) ⇒ nil

Set the condition of a branch instruction.

This only works on llvm::BranchInst instructions.

Parameters:

  • branch (FFI::Pointer(ValueRef))
  • cond (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::BranchInstllvm::BranchInst::setCondition


4608
# File 'lib/llvm/core_ffi.rb', line 4608

attach_function :set_condition, :LLVMSetCondition, [:pointer, :pointer], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • l (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4757
# File 'lib/llvm/core_ffi.rb', line 4757

attach_function :set_current_debug_location, :LLVMSetCurrentDebugLocation, [:pointer, :pointer], :void

.set_data_layout(m, triple) ⇒ nil

Set the data layout for a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • triple (String)

Returns:

  • (nil)

See Also:

  • Module::setDataLayout()


1039
# File 'lib/llvm/core_ffi.rb', line 1039

attach_function :set_data_layout, :LLVMSetDataLayout, [:pointer, :string], :void

.set_dll_storage_class(global, class_) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


3595
# File 'lib/llvm/core_ffi.rb', line 3595

attach_function :set_dll_storage_class, :LLVMSetDLLStorageClass, [:pointer, :dll_storage_class], :void

.set_externally_initialized(global_var, is_ext_init) ⇒ nil

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))
  • is_ext_init (Integer)

Returns:

  • (nil)


3798
# File 'lib/llvm/core_ffi.rb', line 3798

attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [:pointer, :int], :void

.set_function_call_conv(fn, cc) ⇒ nil

Set the calling convention of a function.

Parameters:

  • Fn

    Function to operate on

  • CC

    LLVMCallConv to set calling convention to

  • fn (FFI::Pointer(ValueRef))
  • cc (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::setCallingConv()


3882
# File 'lib/llvm/core_ffi.rb', line 3882

attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [:pointer, :uint], :void

.set_gc(fn, name) ⇒ nil

Define the garbage collector to use during code generation.

Parameters:

  • fn (FFI::Pointer(ValueRef))
  • name (String)

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::setGC()


3904
# File 'lib/llvm/core_ffi.rb', line 3904

attach_function :set_gc, :LLVMSetGC, [:pointer, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))
  • is_constant (Integer)

Returns:

  • (nil)


3764
# File 'lib/llvm/core_ffi.rb', line 3764

attach_function :set_global_constant, :LLVMSetGlobalConstant, [:pointer, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))
  • constant_val (FFI::Pointer(ValueRef))

Returns:

  • (nil)


3730
# File 'lib/llvm/core_ffi.rb', line 3730

attach_function :set_initializer, :LLVMSetInitializer, [:pointer, :pointer], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

  • builder (FFI::Pointer(BuilderRef))
  • inst (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4774
# File 'lib/llvm/core_ffi.rb', line 4774

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [:pointer, :pointer], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

  • instr (FFI::Pointer(ValueRef))
  • index (Integer)
  • align (Integer)

Returns:

  • (nil)


4513
# File 'lib/llvm/core_ffi.rb', line 4513

attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [:pointer, :uint, :uint], :void

.set_instruction_call_conv(instr, cc) ⇒ nil

Set the calling convention for a call instruction.

This expects an LLVMValueRef that corresponds to a llvm::CallInst or llvm::InvokeInst.

Parameters:

  • instr (FFI::Pointer(ValueRef))
  • cc (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::CallInstllvm::CallInst::setCallingConv()
  • llvmllvm::InvokeInstllvm::InvokeInst::setCallingConv()


4490
# File 'lib/llvm/core_ffi.rb', line 4490

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [:pointer, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))
  • linkage (Symbol from _enum_linkage_)

Returns:

  • (nil)


3544
# File 'lib/llvm/core_ffi.rb', line 3544

attach_function :set_linkage, :LLVMSetLinkage, [:pointer, :linkage], :void

.set_metadata(val, kind_id, node) ⇒ nil

Set metadata associated with an instruction value.

Parameters:

  • val (FFI::Pointer(ValueRef))
  • kind_id (Integer)
  • node (FFI::Pointer(ValueRef))

Returns:

  • (nil)


4379
# File 'lib/llvm/core_ffi.rb', line 4379

attach_function :set_metadata, :LLVMSetMetadata, [:pointer, :uint, :pointer], :void

.set_module_data_layout(m, dl) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


128
# File 'lib/llvm/target_ffi.rb', line 128

attach_function :set_module_data_layout, :LLVMSetModuleDataLayout, [:pointer, OpaqueTargetData], :void

.set_module_inline_asm(m, asm) ⇒ nil

Set inline assembly for a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • asm (String)

Returns:

  • (nil)

See Also:

  • Module::setModuleInlineAsm()


1105
# File 'lib/llvm/core_ffi.rb', line 1105

attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [:pointer, :string], :void

.set_operand(user, index, val) ⇒ nil

Set an operand at a specific index in a llvm::User value.

Parameters:

  • user (FFI::Pointer(ValueRef))
  • index (Integer)
  • val (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Userllvm::User::setOperand()


2607
# File 'lib/llvm/core_ffi.rb', line 2607

attach_function :set_operand, :LLVMSetOperand, [:pointer, :uint, :pointer], :void

.set_ordering(memory_access_inst, ordering) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


5419
# File 'lib/llvm/core_ffi.rb', line 5419

attach_function :set_ordering, :LLVMSetOrdering, [:pointer, :atomic_ordering], :void

.set_param_alignment(arg, align) ⇒ nil

Set the alignment for a function parameter.

Parameters:

  • arg (FFI::Pointer(ValueRef))
  • align (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::Argumentllvm::Argument::addAttr()
  • llvmllvm::AttrBuilderllvm::AttrBuilder::addAlignmentAttr()


4023
# File 'lib/llvm/core_ffi.rb', line 4023

attach_function :set_param_alignment, :LLVMSetParamAlignment, [:pointer, :uint], :void

.set_personality_fn(fn, personality_fn) ⇒ nil

Set the personality function attached to the function.

Parameters:

  • fn (FFI::Pointer(ValueRef))
  • personality_fn (FFI::Pointer(ValueRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::setPersonalityFn()


3846
# File 'lib/llvm/core_ffi.rb', line 3846

attach_function :set_personality_fn, :LLVMSetPersonalityFn, [:pointer, :pointer], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))
  • section (String)

Returns:

  • (nil)


3561
# File 'lib/llvm/core_ffi.rb', line 3561

attach_function :set_section, :LLVMSetSection, [:pointer, :string], :void

.set_successor(term, i, block) ⇒ nil

Update the specified successor to point at the provided block.

Parameters:

  • term (FFI::Pointer(ValueRef))
  • i (Integer)
  • block (FFI::Pointer(BasicBlockRef))

Returns:

  • (nil)

See Also:

  • llvmllvm::TerminatorInstllvm::TerminatorInst::setSuccessor


4571
# File 'lib/llvm/core_ffi.rb', line 4571

attach_function :set_successor, :LLVMSetSuccessor, [:pointer, :uint, :pointer], :void

.set_tail_call(call_inst, is_tail_call) ⇒ nil

Set whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

Parameters:

  • call_inst (FFI::Pointer(ValueRef))
  • is_tail_call (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::CallInstllvm::CallInst::setTailCall()


4538
# File 'lib/llvm/core_ffi.rb', line 4538

attach_function :set_tail_call, :LLVMSetTailCall, [:pointer, :int], :void

.set_target(m, triple) ⇒ nil

Set the target triple for a module.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • triple (String)

Returns:

  • (nil)

See Also:

  • Module::setTargetTriple()


1060
# File 'lib/llvm/core_ffi.rb', line 1060

attach_function :set_target, :LLVMSetTarget, [:pointer, :string], :void

.set_target_machine_asm_verbosity(t, verbose_asm) ⇒ nil

Set the target machine’s ASM verbosity.

Parameters:

Returns:

  • (nil)


583
# File 'lib/llvm/target_ffi.rb', line 583

attach_function :set_target_machine_asm_verbosity, :LLVMSetTargetMachineAsmVerbosity, [OpaqueTargetMachine, :int], :void

.set_thread_local(global_var, is_thread_local) ⇒ nil

(Not documented)

Parameters:

  • global_var (FFI::Pointer(ValueRef))
  • is_thread_local (Integer)

Returns:

  • (nil)


3747
# File 'lib/llvm/core_ffi.rb', line 3747

attach_function :set_thread_local, :LLVMSetThreadLocal, [:pointer, :int], :void

.set_thread_local_mode(global_var, mode) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


3781
# File 'lib/llvm/core_ffi.rb', line 3781

attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [:pointer, :thread_local_mode], :void

.set_unnamed_addr(global, has_unnamed_addr) ⇒ nil

(Not documented)

Parameters:

  • global (FFI::Pointer(ValueRef))
  • has_unnamed_addr (Integer)

Returns:

  • (nil)


3612
# File 'lib/llvm/core_ffi.rb', line 3612

attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [:pointer, :int], :void

.set_value_name(val, name) ⇒ nil

Set the string name of a value.

Parameters:

  • val (FFI::Pointer(ValueRef))
  • name (String)

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::setName()


1837
# File 'lib/llvm/core_ffi.rb', line 1837

attach_function :set_value_name, :LLVMSetValueName, [:pointer, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil)


3578
# File 'lib/llvm/core_ffi.rb', line 3578

attach_function :set_visibility, :LLVMSetVisibility, [:pointer, :visibility], :void

.set_volatile(memory_access_inst, is_volatile) ⇒ nil

(Not documented)

Parameters:

  • memory_access_inst (FFI::Pointer(ValueRef))
  • is_volatile (Integer)

Returns:

  • (nil)


5402
# File 'lib/llvm/core_ffi.rb', line 5402

attach_function :set_volatile, :LLVMSetVolatile, [:pointer, :int], :void

.shutdownnil

Deallocate and destroy all ManagedStatic variables.

@see llvm::llvm_shutdown
@see ManagedStatic

Returns:

  • (nil)


837
# File 'lib/llvm/core_ffi.rb', line 837

attach_function :shutdown, :LLVMShutdown, [], :void

.size_of(ty) ⇒ FFI::Pointer(ValueRef)

(Not documented)

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (FFI::Pointer(ValueRef))


2946
# File 'lib/llvm/core_ffi.rb', line 2946

attach_function :size_of, :LLVMSizeOf, [:pointer], :pointer

.size_of_type_in_bits(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


231
# File 'lib/llvm/target_ffi.rb', line 231

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, :pointer], :ulong_long

.start_multithreadedInteger

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.  This function always returns
LLVMIsMultithreaded().

Returns:

  • (Integer)


6004
# File 'lib/llvm/core_ffi.rb', line 6004

attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int

.stop_multithreadednil

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.

Returns:

  • (nil)


6012
# File 'lib/llvm/core_ffi.rb', line 6012

attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void

.store_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer)


240
# File 'lib/llvm/target_ffi.rb', line 240

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, :pointer], :ulong_long

.struct_create_named(c, name) ⇒ FFI::Pointer(TypeRef)

Create an empty structure in a context having a specified name.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • name (String)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1589
# File 'lib/llvm/core_ffi.rb', line 1589

attach_function :struct_create_named, :LLVMStructCreateNamed, [:pointer, :string], :pointer

.struct_get_type_at_index(struct_ty, i) ⇒ FFI::Pointer(TypeRef)

Get the type of the element at a given index in the structure.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))
  • i (Integer)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::StructTypellvm::StructType::getTypeAtIndex()


1649
# File 'lib/llvm/core_ffi.rb', line 1649

attach_function :struct_get_type_at_index, :LLVMStructGetTypeAtIndex, [:pointer, :uint], :pointer

.struct_set_body(struct_ty, element_types, element_count, packed) ⇒ nil

Set the contents of a structure type.

Parameters:

  • struct_ty (FFI::Pointer(TypeRef))
  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::StructTypellvm::StructType::setBody()


1612
# File 'lib/llvm/core_ffi.rb', line 1612

attach_function :struct_set_body, :LLVMStructSetBody, [:pointer, :pointer, :uint, :int], :void

.struct_type(element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

Create a new structure type in the global context.

Parameters:

  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1578
# File 'lib/llvm/core_ffi.rb', line 1578

attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], :pointer

.struct_type_in_context(c, element_types, element_count, packed) ⇒ FFI::Pointer(TypeRef)

Create a new structure type in a context.

A structure is specified by a list of inner elements/types and whether these can be packed together.

Parameters:

  • c (FFI::Pointer(ContextRef))
  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1566
# File 'lib/llvm/core_ffi.rb', line 1566

attach_function :struct_type_in_context, :LLVMStructTypeInContext, [:pointer, :pointer, :uint, :int], :pointer

.target_has_asm_backend(t) ⇒ Integer

Returns if the target as an ASM backend (required for emitting output)

Parameters:

Returns:

  • (Integer)


505
# File 'lib/llvm/target_ffi.rb', line 505

attach_function :target_has_asm_backend, :LLVMTargetHasAsmBackend, [Target], :int

.target_has_jit(t) ⇒ Integer

Returns if the target has a JIT

Parameters:

Returns:

  • (Integer)


489
# File 'lib/llvm/target_ffi.rb', line 489

attach_function :target_has_jit, :LLVMTargetHasJIT, [Target], :int

.target_has_target_machine(t) ⇒ Integer

Returns if the target has a TargetMachine associated

Parameters:

Returns:

  • (Integer)


497
# File 'lib/llvm/target_ffi.rb', line 497

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:

Returns:

  • (Integer)


597
# File 'lib/llvm/target_ffi.rb', line 597

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:

Returns:

  • (Integer)


609
# File 'lib/llvm/target_ffi.rb', line 609

attach_function :target_machine_emit_to_memory_buffer, :LLVMTargetMachineEmitToMemoryBuffer, [OpaqueTargetMachine, :pointer, :code_gen_file_type, :pointer, :pointer], :int

.type_is_sized(ty) ⇒ Integer

Whether the type has a known size.

Things that don’t have a size are abstract types, labels, and void.a

Parameters:

  • ty (FFI::Pointer(TypeRef))

Returns:

  • (Integer)

See Also:

  • llvmllvm::Typellvm::Type::isSized()


1255
# File 'lib/llvm/core_ffi.rb', line 1255

attach_function :type_is_sized, :LLVMTypeIsSized, [:pointer], :int

.type_of(val) ⇒ FFI::Pointer(TypeRef)

Obtain the type of a value.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::Valuellvm::Value::getType()


1816
# File 'lib/llvm/core_ffi.rb', line 1816

attach_function :type_of, :LLVMTypeOf, [:pointer], :pointer

.value_as_basic_block(val) ⇒ FFI::Pointer(BasicBlockRef)

Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (FFI::Pointer(BasicBlockRef))


4134
# File 'lib/llvm/core_ffi.rb', line 4134

attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [:pointer], :pointer

.value_is_basic_block(val) ⇒ Integer

Determine whether an LLVMValueRef is itself a basic block.

Parameters:

  • val (FFI::Pointer(ValueRef))

Returns:

  • (Integer)


4126
# File 'lib/llvm/core_ffi.rb', line 4126

attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [:pointer], :int

.vector_type(element_type, element_count) ⇒ FFI::Pointer(TypeRef)

Create a vector type that contains a defined type and has a specific number of elements.

The created type will exist in the context thats its element type exists in.

Parameters:

  • element_type (FFI::Pointer(TypeRef))
  • element_count (Integer)

Returns:

  • (FFI::Pointer(TypeRef))

See Also:

  • llvmllvm::VectorTypellvm::VectorType::get()


1748
# File 'lib/llvm/core_ffi.rb', line 1748

attach_function :vector_type, :LLVMVectorType, [:pointer, :uint], :pointer

.verify_function(fn, action) ⇒ Integer

Verifies that a single function is valid, taking the specified action. Useful

for debugging.

Parameters:

Returns:

  • (Integer)


59
# File 'lib/llvm/analysis_ffi.rb', line 59

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:

Returns:

  • (Integer)


49
# File 'lib/llvm/analysis_ffi.rb', line 49

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)


68
# File 'lib/llvm/analysis_ffi.rb', line 68

attach_function :view_function_cfg, :LLVMViewFunctionCFG, [:pointer], :void

.view_function_cfg_only(fn) ⇒ nil

(Not documented)

Parameters:

  • fn (FFI::Pointer(ValueRef))

Returns:

  • (nil)


76
# File 'lib/llvm/analysis_ffi.rb', line 76

attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [:pointer], :void

.void_typeFFI::Pointer(TypeRef)

These are similar to the above functions except they operate on the global context.

Returns:

  • (FFI::Pointer(TypeRef))


1792
# File 'lib/llvm/core_ffi.rb', line 1792

attach_function :void_type, :LLVMVoidType, [], :pointer

.void_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a void type in a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1768
# File 'lib/llvm/core_ffi.rb', line 1768

attach_function :void_type_in_context, :LLVMVoidTypeInContext, [:pointer], :pointer

.write_bitcode_to_fd(m, fd, should_close, unbuffered) ⇒ Integer

Writes a module to an open file descriptor. Returns 0 on success.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • fd (Integer)
  • should_close (Integer)
  • unbuffered (Integer)

Returns:

  • (Integer)


113
# File 'lib/llvm/core/bitcode_ffi.rb', line 113

attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [:pointer, :int, :int, :int], :int

.write_bitcode_to_file(m, path) ⇒ Integer

Writes a module to the specified path. Returns 0 on success.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • path (String)

Returns:

  • (Integer)


102
# File 'lib/llvm/core/bitcode_ffi.rb', line 102

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)


123
# File 'lib/llvm/core/bitcode_ffi.rb', line 123

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [:pointer, :int], :int

.write_bitcode_to_memory_buffer(m) ⇒ FFI::Pointer(MemoryBufferRef)

Writes a module to a new memory buffer and returns it.

Parameters:

  • m (FFI::Pointer(ModuleRef))

Returns:

  • (FFI::Pointer(MemoryBufferRef))


131
# File 'lib/llvm/core/bitcode_ffi.rb', line 131

attach_function :write_bitcode_to_memory_buffer, :LLVMWriteBitcodeToMemoryBuffer, [:pointer], :pointer

.x86fp80_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1481
# File 'lib/llvm/core_ffi.rb', line 1481

attach_function :x86fp80_type, :LLVMX86FP80Type, [], :pointer

.x86fp80_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Obtain a 80-bit floating point type (X87) from a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1434
# File 'lib/llvm/core_ffi.rb', line 1434

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [:pointer], :pointer

.x86mmx_typeFFI::Pointer(TypeRef)

(Not documented)

Returns:

  • (FFI::Pointer(TypeRef))


1806
# File 'lib/llvm/core_ffi.rb', line 1806

attach_function :x86mmx_type, :LLVMX86MMXType, [], :pointer

.x86mmx_type_in_context(c) ⇒ FFI::Pointer(TypeRef)

Create a X86 MMX type in a context.

Parameters:

  • c (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(TypeRef))


1784
# File 'lib/llvm/core_ffi.rb', line 1784

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [:pointer], :pointer

Instance Method Details

#for_each_value_subclass(macro) ⇒ Object



15
16
17
# File 'lib/llvm/core_ffi.rb', line 15

def for_each_value_subclass(macro)
  macroARGUMENTmacroBASIC_BLOCKmacroINLINE_ASMmacroUSERmacroCONSTANTmacroBLOCK_ADDRESSmacroCONSTANT_AGGREGATE_ZEROmacroCONSTANT_ARRAYmacroCONSTANT_DATA_SEQUENTIALmacroCONSTANT_DATA_ARRAYmacroCONSTANT_DATA_VECTORmacroCONSTANT_EXPRmacroCONSTANT_FPmacroCONSTANT_INTmacroCONSTANT_POINTER_NULLmacroCONSTANT_STRUCTmacroCONSTANT_TOKEN_NONEmacroCONSTANT_VECTORmacroGLOBAL_VALUEmacroGLOBAL_ALIASmacroGLOBAL_OBJECTmacroFUNCTIONmacroGLOBAL_VARIABLEmacroUNDEF_VALUEmacroINSTRUCTIONmacroBINARY_OPERATORmacroCALL_INSTmacroINTRINSIC_INSTmacroDBG_INFO_INTRINSICmacroDBG_DECLARE_INSTmacroMEM_INTRINSICmacroMEM_CPY_INSTmacroMEM_MOVE_INSTmacroMEM_SET_INSTmacroCMP_INSTmacroF_CMP_INSTmacroI_CMP_INSTmacroEXTRACT_ELEMENT_INSTmacroGET_ELEMENT_PTR_INSTmacroINSERT_ELEMENT_INSTmacroINSERT_VALUE_INSTmacroLANDING_PAD_INSTmacroPHI_NODEmacroSELECT_INSTmacroSHUFFLE_VECTOR_INSTmacroSTORE_INSTmacroTERMINATOR_INSTmacroBRANCH_INSTmacroINDIRECT_BR_INSTmacroINVOKE_INSTmacroRETURN_INSTmacroSWITCH_INSTmacroUNREACHABLE_INSTmacroRESUME_INSTmacroCLEANUP_RETURN_INSTmacroCATCH_RETURN_INSTmacroFUNCLET_PAD_INSTmacroCATCH_PAD_INSTmacroCLEANUP_PAD_INSTmacroUNARY_INSTRUCTIONmacroALLOCA_INSTmacroCAST_INSTmacroADDR_SPACE_CAST_INSTmacroBIT_CAST_INSTmacroFP_EXT_INSTmacroFP_TO_SI_INSTmacroFP_TO_UI_INSTmacroFP_TRUNC_INSTmacroINT_TO_PTR_INSTmacroPTR_TO_INT_INSTmacroS_EXT_INSTmacroSI_TO_FP_INSTmacroTRUNC_INSTmacroUI_TO_FP_INSTmacroZ_EXT_INSTmacroEXTRACT_VALUE_INSTmacroLOAD_INSTmacroVA_ARG_INST
end