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, OpaqueBasicBlock, OpaqueBuilder, OpaqueContext, OpaqueDiagnosticInfo, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMCJITMemoryManager, OpaqueMemoryBuffer, OpaqueModule, OpaqueModuleProvider, OpaquePassManager, OpaquePassManagerBuilder, OpaquePassRegistry, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, OpaqueType, OpaqueUse, OpaqueValue, Target

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

._callback_diagnostic_handler_(void) ⇒ OpaqueDiagnosticInfo

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:

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

Returns:



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

callback :diagnostic_handler, [:pointer], OpaqueDiagnosticInfo

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

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

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer) 


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

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

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

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer) 


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

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

._callback_memory_manager_finalize_memory_callback_(opaque, err_msg) ⇒ Integer

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:

  • (Integer) 


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

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

._callback_yield_callback_(void) ⇒ OpaqueContext

(Not documented)

This entry is only for documentation and no real method.

Parameters:

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

Returns:



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

callback :yield_callback, [:pointer], OpaqueContext

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


767
768
769
770
771
772
773
774
775
 
# File 'lib/llvm/core_ffi.rb', line 767

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) 


814
815
816
817
818
819
820
821
822
823
824
825
826
 
# File 'lib/llvm/core_ffi.rb', line 814

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) 


168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/llvm/core_ffi.rb', line 168

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) 


577
578
579
580
581
582
583
584
585
 
# File 'lib/llvm/core_ffi.rb', line 577

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) 


418
419
420
421
 
# File 'lib/llvm/target_ffi.rb', line 418

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) 


344
345
346
347
348
349
 
# File 'lib/llvm/target_ffi.rb', line 344

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) 


396
397
398
399
400
401
402
403
 
# File 'lib/llvm/target_ffi.rb', line 396

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) 


845
846
847
848
849
850
 
# File 'lib/llvm/core_ffi.rb', line 845

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) 


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

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) 


616
617
618
619
620
621
622
623
624
625
626
627
 
# File 'lib/llvm/core_ffi.rb', line 616

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) 


702
703
704
705
 
# File 'lib/llvm/core_ffi.rb', line 702

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) 


492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/llvm/core_ffi.rb', line 492

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

._enum_linker_mode_ ⇒ Symbol

(Not documented)

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

Options:

:destroy_source
:preserve_source

Allow source module to be destroyed.

Returns:

  • (Symbol) 


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

enum :linker_mode, [
  :destroy_source, 0,
  :preserve_source, 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

Returns:

  • (Symbol) 


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
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
 
# File 'lib/llvm/core_ffi.rb', line 324

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
]

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


670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
 
# File 'lib/llvm/core_ffi.rb', line 670

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) 


368
369
370
371
372
373
 
# File 'lib/llvm/target_ffi.rb', line 368

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) 


726
727
728
729
730
731
732
 
# File 'lib/llvm/core_ffi.rb', line 726

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

._enum_type_kind_ ⇒ Symbol

(Not documented)

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

Options:

:void
:half

< type with no size

:float

< 16 bit floating point type

:double

< 32 bit floating point type

:x86_fp80

< 64 bit floating point type

:fp128

< 80 bit floating point type (X87)

:ppc_fp128

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

:label

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

:integer

< Labels

:function

< Arbitrary bit width integers

:struct

< Functions

:array

< Structures

:pointer

< Arrays

:vector

< Pointers

:metadata

< SIMD ‘packed’ format, or other vector type

:x86_mmx

< Metadata

Returns:

  • (Symbol) 


427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
 
# File 'lib/llvm/core_ffi.rb', line 427

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

._enum_verifier_failure_action_ ⇒ Symbol

@{

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) 


527
528
529
530
531
 
# File 'lib/llvm/core_ffi.rb', line 527

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

.abi_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

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

.abi_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

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

This group contains function that operate on global alias values.

@{

Parameters:

Returns:

See Also:

  • llvmllvm::GlobalAlias


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

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

.add_always_inliner_pass(pm) ⇒ nil

See llvm::createAlwaysInlinerPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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) 


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

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_attribute(arg, pa) ⇒ nil

Add an attribute to a function argument.

Parameters:

Returns:

  • (nil)

See Also:

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


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

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

.add_basic_alias_analysis_pass(pm) ⇒ nil

See llvm::createBasicAliasAnalysisPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_bb_vectorize_pass(pm) ⇒ nil

See llvm::createBBVectorizePass function.

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_case(switch, on_val, dest) ⇒ nil

Add a case to the switch instruction

Parameters:

Returns:

  • (nil) 


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

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

.add_cfg_simplification_pass(pm) ⇒ nil

See llvm::createCFGSimplificationPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_clause(landing_pad, clause_val) ⇒ nil

Add a catch or filter clause to the landingpad instruction

Parameters:

Returns:

  • (nil) 


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

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

.add_constant_merge_pass(pm) ⇒ nil

See llvm::createConstantMergePass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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) 


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

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) 


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

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) 


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

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

.add_demote_memory_to_register_pass(pm) ⇒ nil

See llvm::demotePromoteMemoryToRegisterPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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:

Returns:

  • (nil) 


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

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

.add_early_cse_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_function(m, name, function_ty) ⇒ OpaqueValue

Add a function to a module under a specified name.

Parameters:

Returns:

See Also:

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


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

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

.add_function_attr(fn, pa) ⇒ nil

Add an attribute to a function.

Parameters:

Returns:

  • (nil)

See Also:

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


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

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

.add_function_attrs_pass(pm) ⇒ nil

See llvm::createFunctionAttrsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

This group contains functions that operate on global variable values.

@{

Parameters:

Returns:

See Also:

  • llvmllvm::GlobalVariable


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

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

.add_global_dce_pass(pm) ⇒ nil

See llvm::createGlobalDCEPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

(Not documented)

Parameters:

Returns:



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

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

.add_global_mapping(ee, global, addr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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) 


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

attach_function :add_gvn_pass, :LLVMAddGVNPass, [:pointer], :void

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

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

Parameters:

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

Returns:

  • (nil) 


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

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

.add_ind_var_simplify_pass(pm) ⇒ nil

See llvm::createIndVarSimplifyPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_instruction_combining_pass(pm) ⇒ nil

See llvm::createInstructionCombiningPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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) 


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

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

.add_licm_pass(pm) ⇒ nil

See llvm::createLICMPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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) 


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

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

.add_mem_cpy_opt_pass(pm) ⇒ nil

See llvm::createMemCpyOptPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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) 


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

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

.add_module(ee, m) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_module_provider(ee, mp) ⇒ nil

Deprecated: Use LLVMAddModule instead.

Parameters:

Returns:

  • (nil) 


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

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

.add_named_metadata_operand(m, name, val) ⇒ nil

Add an operand to named metadata.

Parameters:

Returns:

  • (nil)

See Also:

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


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

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

.add_partially_inline_lib_calls_pass(pm) ⇒ nil

See llvm::createPartiallyInlineLibCallsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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) 


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

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) 


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

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

.add_scalar_repl_aggregates_pass(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_scalar_repl_aggregates_pass_ssa(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_scalar_repl_aggregates_pass_with_threshold(pm, threshold) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

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

Returns:

  • (nil) 


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

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) 


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

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

.add_sccp_pass(pm) ⇒ nil

See llvm::createSCCPPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_simplify_lib_calls_pass(pm) ⇒ nil

See llvm::createSimplifyLibCallsPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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_tail_call_elimination_pass(pm) ⇒ nil

See llvm::createTailCallEliminationPass function.

Parameters:

  • pm (FFI::Pointer(PassManagerRef))

Returns:

  • (nil) 


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

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

.add_target_data(td, pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_target_dependent_function_attr(fn, a, v) ⇒ nil

Add a target-dependent attribute to a fuction

Parameters:

Returns:

  • (nil)

See Also:

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


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

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

.add_target_library_info(tli, pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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) 


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

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) 


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

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

.align_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.append_basic_block(fn, name) ⇒ OpaqueBasicBlock

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

Parameters:

Returns:

See Also:

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


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

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

.append_basic_block_in_context(c, fn, name) ⇒ OpaqueBasicBlock

Append a basic block to the end of a function.

Parameters:

Returns:

See Also:

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


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

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

.array_type(element_type, element_count) ⇒ OpaqueType

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

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

Parameters:

  • element_type (OpaqueType)
  • element_count (Integer)

Returns:

See Also:

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


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

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

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

Convert a basic block instance to a value type.

Parameters:

Returns:



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

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

.block_address(f, bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

Arithmetic

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

attach_function :build_addr_space_cast, :LLVMBuildAddrSpaceCast, [OpaqueBuilder, OpaqueValue, OpaqueType, :string], OpaqueValue

.build_aggregate_ret(opaque_builder, ret_vals, n) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

.build_alloca(opaque_builder, ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_br(opaque_builder, dest) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_f_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_fence(b, ordering, single_thread, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :build_fence, :LLVMBuildFence, [OpaqueBuilder, :atomic_ordering, :int, :string], OpaqueValue

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_free(opaque_builder, pointer_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_global_string(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_global_string_ptr(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

Comparisons

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_indirect_br(b, addr, num_dests) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_is_not_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_is_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_load(opaque_builder, pointer_val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_malloc(opaque_builder, ty, name) ⇒ OpaqueValue

Memory

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_not(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_nsw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_nuw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_phi(opaque_builder, ty, name) ⇒ OpaqueValue

Miscellaneous instructions

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_resume(b, exn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_ret(opaque_builder, v) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_ret_void(opaque_builder) ⇒ OpaqueValue

Terminators

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_store(opaque_builder, val, ptr) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

Casts

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_unreachable(opaque_builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.byte_order(td) ⇒ Symbol from _enum_byte_ordering_

(Not documented)

Parameters:

Returns:



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

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

.call_frame_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

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

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.const_a_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_addr_space_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_addr_space_cast, :LLVMConstAddrSpaceCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_all_ones(ty) ⇒ OpaqueValue

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

This is only valid for integer types.

Parameters:

Returns:

See Also:

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


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

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

.const_and(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_array(element_ty, constant_vals, length) ⇒ OpaqueValue

Create a ConstantArray from values.

Parameters:

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

Returns:

See Also:

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


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

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

.const_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_exact_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_extract_element(vector_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_extract_value(agg_constant, idx_list, num_idx) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

.const_f_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_f_div, :LLVMConstFDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_f_mul, :LLVMConstFMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_f_neg, :LLVMConstFNeg, [OpaqueValue], OpaqueValue

.const_f_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_f_rem, :LLVMConstFRem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_f_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_f_sub, :LLVMConstFSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_fp_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_fp_cast, :LLVMConstFPCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_fp_ext, :LLVMConstFPExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_to_si(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_fp_to_si, :LLVMConstFPToSI, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_to_ui(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_fp_to_ui, :LLVMConstFPToUI, [OpaqueValue, OpaqueType], OpaqueValue

.const_fp_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_fp_trunc, :LLVMConstFPTrunc, [OpaqueValue, OpaqueType], OpaqueValue

.const_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

.const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_in_bounds_gep(constant_val, constant_indices, num_indices) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

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

(Not documented)

Parameters:

  • ty (OpaqueType)
  • asm_string (String)
  • constraints (String)
  • has_side_effects (Integer)
  • is_align_stack (Integer)

Returns:



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

attach_function :const_inline_asm, :LLVMConstInlineAsm, [OpaqueType, :string, :string, :int, :int], OpaqueValue

.const_insert_element(vector_constant, element_value_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_insert_element, :LLVMConstInsertElement, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

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

(Not documented)

Parameters:

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

Returns:



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

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

.const_int(int_ty, n, sign_extend) ⇒ OpaqueValue

Obtain a constant value for an integer type.

The returned value corresponds to a llvm::ConstantInt.

Parameters:

  • IntTy —

    Integer type to obtain value of.

  • N —

    The value the returned instance should refer to.

  • SignExtend —

    Whether to sign extend the produced value.

  • int_ty (OpaqueType)
  • n (Integer)
  • sign_extend (Integer)

Returns:

See Also:

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


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

attach_function :const_int, :LLVMConstInt, [OpaqueType, :ulong_long, :int], OpaqueValue

.const_int_cast(constant_val, to_type, is_signed) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_int_cast, :LLVMConstIntCast, [OpaqueValue, OpaqueType, :int], OpaqueValue

.const_int_get_s_ext_value(constant_val) ⇒ Integer

Obtain the sign extended value for an integer constant value.

Parameters:

Returns:

  • (Integer)

See Also:

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


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

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

.const_int_get_z_ext_value(constant_val) ⇒ Integer

Obtain the zero extended value for an integer constant value.

Parameters:

Returns:

  • (Integer)

See Also:

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


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

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

.const_int_of_arbitrary_precision(int_ty, num_words, words) ⇒ OpaqueValue

Obtain a constant value for an integer of arbitrary precision.

Parameters:

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

Returns:

See Also:

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


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

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

.const_int_of_string(int_ty, text, radix) ⇒ OpaqueValue

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

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

Parameters:

  • int_ty (OpaqueType)
  • text (String)
  • radix (Integer)

Returns:

See Also:

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


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

attach_function :const_int_of_string, :LLVMConstIntOfString, [OpaqueType, :string, :uchar], OpaqueValue

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

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

Parameters:

  • int_ty (OpaqueType)
  • text (String)
  • s_len (Integer)
  • radix (Integer)

Returns:

See Also:

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


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

attach_function :const_int_of_string_and_size, :LLVMConstIntOfStringAndSize, [OpaqueType, :string, :uint, :uchar], OpaqueValue

.const_int_to_ptr(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_int_to_ptr, :LLVMConstIntToPtr, [OpaqueValue, OpaqueType], OpaqueValue

.const_l_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_l_shr, :LLVMConstLShr, [OpaqueValue, OpaqueValue], OpaqueValue

.const_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_mul, :LLVMConstMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_named_struct(struct_ty, constant_vals, count) ⇒ OpaqueValue

Create a non-anonymous ConstantStruct from values.

Parameters:

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

Returns:

See Also:

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


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

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

.const_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_neg, :LLVMConstNeg, [OpaqueValue], OpaqueValue

.const_not(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_not, :LLVMConstNot, [OpaqueValue], OpaqueValue

.const_nsw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nsw_add, :LLVMConstNSWAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nsw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nsw_mul, :LLVMConstNSWMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nsw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nsw_neg, :LLVMConstNSWNeg, [OpaqueValue], OpaqueValue

.const_nsw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nsw_sub, :LLVMConstNSWSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_null(ty) ⇒ OpaqueValue

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

Parameters:

Returns:

See Also:

  • llvmllvm::Constantllvm::Constant::getNullValue()


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

attach_function :const_null, :LLVMConstNull, [OpaqueType], OpaqueValue

.const_nuw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nuw_add, :LLVMConstNUWAdd, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nuw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nuw_mul, :LLVMConstNUWMul, [OpaqueValue, OpaqueValue], OpaqueValue

.const_nuw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nuw_neg, :LLVMConstNUWNeg, [OpaqueValue], OpaqueValue

.const_nuw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_nuw_sub, :LLVMConstNUWSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_or(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_or, :LLVMConstOr, [OpaqueValue, OpaqueValue], OpaqueValue

.const_pointer_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_pointer_cast, :LLVMConstPointerCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_pointer_null(ty) ⇒ OpaqueValue

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

Parameters:

Returns:



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

attach_function :const_pointer_null, :LLVMConstPointerNull, [OpaqueType], OpaqueValue

.const_ptr_to_int(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_ptr_to_int, :LLVMConstPtrToInt, [OpaqueValue, OpaqueType], OpaqueValue

.const_real(real_ty, n) ⇒ OpaqueValue

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

Parameters:

Returns:



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

attach_function :const_real, :LLVMConstReal, [OpaqueType, :double], OpaqueValue

.const_real_of_string(real_ty, text) ⇒ OpaqueValue

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

A similar API, LLVMConstRealOfStringAndSize is also available. It should be used if the input string’s length is known.

Parameters:

Returns:



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

attach_function :const_real_of_string, :LLVMConstRealOfString, [OpaqueType, :string], OpaqueValue

.const_real_of_string_and_size(real_ty, text, s_len) ⇒ OpaqueValue

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

Parameters:

  • real_ty (OpaqueType)
  • text (String)
  • s_len (Integer)

Returns:



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

attach_function :const_real_of_string_and_size, :LLVMConstRealOfStringAndSize, [OpaqueType, :string, :uint], OpaqueValue

.const_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_s_div, :LLVMConstSDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_s_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_s_ext, :LLVMConstSExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_s_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_s_ext_or_bit_cast, :LLVMConstSExtOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_s_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_s_rem, :LLVMConstSRem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_select(constant_condition, constant_if_true, constant_if_false) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_select, :LLVMConstSelect, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

.const_shl(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_shl, :LLVMConstShl, [OpaqueValue, OpaqueValue], OpaqueValue

.const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_shuffle_vector, :LLVMConstShuffleVector, [OpaqueValue, OpaqueValue, OpaqueValue], OpaqueValue

.const_si_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_si_to_fp, :LLVMConstSIToFP, [OpaqueValue, OpaqueType], OpaqueValue

.const_string(str, length, dont_null_terminate) ⇒ OpaqueValue

Create a ConstantDataSequential with string content in the global context.

This is the same as LLVMConstStringInContext except it operates on the global context.

Parameters:

  • str (String)
  • length (Integer)
  • dont_null_terminate (Integer)

Returns:

See Also:

  • LLVMConstStringInContext()
  • llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()


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

attach_function :const_string, :LLVMConstString, [:string, :uint, :int], OpaqueValue

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

Create a ConstantDataSequential and initialize it with a string.

Parameters:

  • c (OpaqueContext)
  • str (String)
  • length (Integer)
  • dont_null_terminate (Integer)

Returns:

See Also:

  • llvmllvm::ConstantDataArrayllvm::ConstantDataArray::getString()


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

attach_function :const_string_in_context, :LLVMConstStringInContext, [OpaqueContext, :string, :uint, :int], OpaqueValue

.const_struct(constant_vals, count, packed) ⇒ OpaqueValue

Create a ConstantStruct in the global Context.

This is the same as LLVMConstStructInContext except it operates on the global Context.

Parameters:

  • constant_vals (FFI::Pointer(*ValueRef))
  • count (Integer)
  • packed (Integer)

Returns:

See Also:

  • LLVMConstStructInContext()


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

attach_function :const_struct, :LLVMConstStruct, [:pointer, :uint, :int], OpaqueValue

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

Create an anonymous ConstantStruct with the specified values.

Parameters:

  • c (OpaqueContext)
  • constant_vals (FFI::Pointer(*ValueRef))
  • count (Integer)
  • packed (Integer)

Returns:

See Also:

  • llvmllvm::ConstantStructllvm::ConstantStruct::getAnon()


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

attach_function :const_struct_in_context, :LLVMConstStructInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueValue

.const_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_sub, :LLVMConstSub, [OpaqueValue, OpaqueValue], OpaqueValue

.const_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_trunc, :LLVMConstTrunc, [OpaqueValue, OpaqueType], OpaqueValue

.const_trunc_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_trunc_or_bit_cast, :LLVMConstTruncOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.const_u_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_u_div, :LLVMConstUDiv, [OpaqueValue, OpaqueValue], OpaqueValue

.const_u_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_u_rem, :LLVMConstURem, [OpaqueValue, OpaqueValue], OpaqueValue

.const_ui_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_ui_to_fp, :LLVMConstUIToFP, [OpaqueValue, OpaqueType], OpaqueValue

.const_vector(scalar_constant_vals, size) ⇒ OpaqueValue

Create a ConstantVector from values.

Parameters:

  • scalar_constant_vals (FFI::Pointer(*ValueRef))
  • size (Integer)

Returns:

See Also:

  • llvmllvm::ConstantVectorllvm::ConstantVector::get()


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

attach_function :const_vector, :LLVMConstVector, [:pointer, :uint], OpaqueValue

.const_xor(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_xor, :LLVMConstXor, [OpaqueValue, OpaqueValue], OpaqueValue

.const_z_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_z_ext, :LLVMConstZExt, [OpaqueValue, OpaqueType], OpaqueValue

.const_z_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :const_z_ext_or_bit_cast, :LLVMConstZExtOrBitCast, [OpaqueValue, OpaqueType], OpaqueValue

.context_create ⇒ OpaqueContext

Create a new context.

Every call to this function should be paired with a call to LLVMContextDispose() or the context will leak memory.

Returns:



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

attach_function :context_create, :LLVMContextCreate, [], OpaqueContext

.context_dispose(c) ⇒ nil

Destroy a context instance.

This should be called for every call to LLVMContextCreate() or memory will be leaked.

Parameters:

Returns:

  • (nil) 


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

attach_function :context_dispose, :LLVMContextDispose, [OpaqueContext], :void

.context_set_diagnostic_handler(c, handler, diagnostic_context) ⇒ nil

Set the diagnostic handler for this context.

Parameters:

Returns:

  • (nil) 


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

attach_function :context_set_diagnostic_handler, :LLVMContextSetDiagnosticHandler, [OpaqueContext, :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()


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

attach_function :context_set_yield_callback, :LLVMContextSetYieldCallback, [OpaqueContext, :yield_callback, :pointer], :void

.copy_string_rep_of_target_data(td) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :string

.count_basic_blocks(fn) ⇒ Integer

Obtain the number of basic blocks in a function.

Parameters:

  • Fn —

    Function value to operate on.

  • fn (OpaqueValue)

Returns:

  • (Integer) 


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

attach_function :count_basic_blocks, :LLVMCountBasicBlocks, [OpaqueValue], :uint

.count_incoming(phi_node) ⇒ Integer

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

Parameters:

Returns:

  • (Integer) 


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

attach_function :count_incoming, :LLVMCountIncoming, [OpaqueValue], :uint

.count_param_types(function_ty) ⇒ Integer

Obtain the number of parameters this function accepts.

Parameters:

Returns:

  • (Integer) 


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

attach_function :count_param_types, :LLVMCountParamTypes, [OpaqueType], :uint

.count_params(fn) ⇒ Integer

Obtain the number of parameters in a function.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::arg_size()


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

attach_function :count_params, :LLVMCountParams, [OpaqueValue], :uint

.count_struct_element_types(struct_ty) ⇒ Integer

Get the number of elements defined inside the structure.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::getNumElements()


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

attach_function :count_struct_element_types, :LLVMCountStructElementTypes, [OpaqueType], :uint

.create_builder ⇒ OpaqueBuilder

(Not documented)

Returns:



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

attach_function :create_builder, :LLVMCreateBuilder, [], OpaqueBuilder

.create_builder_in_context(c) ⇒ OpaqueBuilder

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

@{

Parameters:

Returns:



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

attach_function :create_builder_in_context, :LLVMCreateBuilderInContext, [OpaqueContext], OpaqueBuilder

.create_execution_engine(out_ee, mp, out_error) ⇒ Integer

Deprecated: Use LLVMCreateExecutionEngineForModule instead.

Parameters:

  • out_ee (FFI::Pointer(*ExecutionEngineRef))
  • mp (FFI::Pointer(ModuleProviderRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_execution_engine, :LLVMCreateExecutionEngine, [:pointer, :pointer, :pointer], :int

.create_execution_engine_for_module(out_ee, m, out_error) ⇒ Integer

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

Parameters:

  • out_ee (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int

.create_function_pass_manager(mp) ⇒ OpaquePassManager

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

Returns:



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

attach_function :create_function_pass_manager, :LLVMCreateFunctionPassManager, [OpaqueModuleProvider], OpaquePassManager

.create_function_pass_manager_for_module(m) ⇒ OpaquePassManager

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

provider. It does not take ownership of the module provider. This type of
pipeline is suitable for code generation and JIT compilation tasks.
@see llvm::FunctionPassManager::FunctionPassManager

Parameters:

Returns:



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

attach_function :create_function_pass_manager_for_module, :LLVMCreateFunctionPassManagerForModule, [OpaqueModule], OpaquePassManager

.create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

  • ty (FFI::Pointer(TypeRef))
  • n (Float)

Returns:



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

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:



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

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:



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

attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], OpaqueGenericValue

.create_interpreter(out_interp, mp, out_error) ⇒ Integer

Deprecated: Use LLVMCreateInterpreterForModule instead.

Parameters:

  • out_interp (FFI::Pointer(*ExecutionEngineRef))
  • mp (FFI::Pointer(ModuleProviderRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_interpreter, :LLVMCreateInterpreter, [:pointer, :pointer, :pointer], :int

.create_interpreter_for_module(out_interp, m, out_error) ⇒ Integer

(Not documented)

Parameters:

  • out_interp (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int

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

Deprecated: Use LLVMCreateJITCompilerForModule instead.

Parameters:

  • out_jit (FFI::Pointer(*ExecutionEngineRef))
  • mp (FFI::Pointer(ModuleProviderRef))
  • opt_level (Integer)
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, :pointer, :uint, :pointer], :int

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

(Not documented)

Parameters:

  • out_jit (FFI::Pointer(*ExecutionEngineRef))
  • m (FFI::Pointer(ModuleRef))
  • opt_level (Integer)
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

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) 


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

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) 


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

attach_function :create_memory_buffer_with_contents_of_file, :LLVMCreateMemoryBufferWithContentsOfFile, [:string, :pointer, :pointer], :int

.create_memory_buffer_with_memory_range(input_data, input_data_length, buffer_name, requires_null_terminator) ⇒ OpaqueMemoryBuffer

(Not documented)

Parameters:

  • input_data (String)
  • input_data_length (Integer)
  • buffer_name (String)
  • requires_null_terminator (Integer)

Returns:



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

attach_function :create_memory_buffer_with_memory_range, :LLVMCreateMemoryBufferWithMemoryRange, [:string, :ulong, :string, :int], OpaqueMemoryBuffer

.create_memory_buffer_with_memory_range_copy(input_data, input_data_length, buffer_name) ⇒ OpaqueMemoryBuffer

(Not documented)

Parameters:

  • input_data (String)
  • input_data_length (Integer)
  • buffer_name (String)

Returns:



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

attach_function :create_memory_buffer_with_memory_range_copy, :LLVMCreateMemoryBufferWithMemoryRangeCopy, [:string, :ulong, :string], OpaqueMemoryBuffer

.create_memory_buffer_with_stdin(out_mem_buf, out_message) ⇒ Integer

(Not documented)

Parameters:

  • out_mem_buf (FFI::Pointer(*MemoryBufferRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


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

attach_function :create_memory_buffer_with_stdin, :LLVMCreateMemoryBufferWithSTDIN, [:pointer, :pointer], :int

.create_message(message) ⇒ String

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

Parameters:

  • message (String)

Returns:

  • (String) 


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

attach_function :create_message, :LLVMCreateMessage, [:string], :string

.create_module_provider_for_existing_module(m) ⇒ OpaqueModuleProvider

Changes the type of M so it can be passed to FunctionPassManagers and the JIT. They take ModuleProviders for historical reasons.

Parameters:

Returns:



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

attach_function :create_module_provider_for_existing_module, :LLVMCreateModuleProviderForExistingModule, [OpaqueModule], OpaqueModuleProvider

.create_pass_manager ⇒ OpaquePassManager

Constructs a new whole-module pass pipeline. This type of pipeline is

suitable for link-time optimization and whole-module transformations.
@see llvm::PassManager::PassManager

Returns:



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

attach_function :create_pass_manager, :LLVMCreatePassManager, [], OpaquePassManager

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



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

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:



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

attach_function :create_target_data, :LLVMCreateTargetData, [:string], OpaqueTargetData

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

Creates a new llvm::TargetMachine. See llvm::Target::createTargetMachine

Parameters:

Returns:



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

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:

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::eraseFromParent()


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

attach_function :delete_basic_block, :LLVMDeleteBasicBlock, [OpaqueBasicBlock], :void

.delete_function(fn) ⇒ nil

Remove a function from its containing module and deletes it.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::eraseFromParent()


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

attach_function :delete_function, :LLVMDeleteFunction, [OpaqueValue], :void

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :delete_global, :LLVMDeleteGlobal, [OpaqueValue], :void

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_builder, :LLVMDisposeBuilder, [OpaqueBuilder], :void

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [OpaqueExecutionEngine], :void

.dispose_generic_value(gen_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [OpaqueGenericValue], :void

.dispose_mcjit_memory_manager(mm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_memory_buffer, :LLVMDisposeMemoryBuffer, [OpaqueMemoryBuffer], :void

.dispose_message(message) ⇒ nil

(Not documented)

Parameters:

  • message (String)

Returns:

  • (nil) 


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

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:

Returns:

  • (nil) 


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

attach_function :dispose_module, :LLVMDisposeModule, [OpaqueModule], :void

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_module_provider, :LLVMDisposeModuleProvider, [OpaqueModuleProvider], :void

.dispose_pass_manager(pm) ⇒ nil

Frees the memory of a pass pipeline. For function pipelines, does not free

the module provider.
@see llvm::PassManagerBase::~PassManagerBase.

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_pass_manager, :LLVMDisposePassManager, [OpaquePassManager], :void

.dispose_target_data(td) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void

.dispose_target_machine(t) ⇒ nil

Dispose the LLVMTargetMachineRef instance generated by

LLVMCreateTargetMachine.

Parameters:

Returns:

  • (nil) 


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

attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void

.double_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :double_type, :LLVMDoubleType, [], OpaqueType

.double_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



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

attach_function :double_type_in_context, :LLVMDoubleTypeInContext, [OpaqueContext], OpaqueType

.dump_module(m) ⇒ nil

Dump a representation of a module to stderr.

Parameters:

Returns:

  • (nil)

See Also:

  • Module::dump()


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

attach_function :dump_module, :LLVMDumpModule, [OpaqueModule], :void

.dump_type(val) ⇒ nil

Dump a representation of a type to stderr.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Typellvm::Type::dump()


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

attach_function :dump_type, :LLVMDumpType, [OpaqueType], :void

.dump_value(val) ⇒ nil

Dump a representation of a value to stderr.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::dump()


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

attach_function :dump_value, :LLVMDumpValue, [OpaqueValue], :void

.element_at_offset(td, struct_ty, offset) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :element_at_offset, :LLVMElementAtOffset, [OpaqueTargetData, :pointer, :ulong_long], :uint

.enable_pretty_stack_trace ⇒ nil

Enable LLVM’s built-in stack trace code. This intercepts the OS’s crash signals and prints which component of LLVM you were in at the time if the crash.

Returns:

  • (nil) 


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

attach_function :enable_pretty_stack_trace, :LLVMEnablePrettyStackTrace, [], :void

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

Returns:

  • (Integer) 


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

attach_function :finalize_function_pass_manager, :LLVMFinalizeFunctionPassManager, [OpaquePassManager], :int

.find_function(ee, name, out_fn) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :find_function, :LLVMFindFunction, [OpaqueExecutionEngine, :string, :pointer], :int

.float_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :float_type, :LLVMFloatType, [], OpaqueType

.float_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



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

attach_function :float_type_in_context, :LLVMFloatTypeInContext, [OpaqueContext], OpaqueType

.fp128_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :fp128_type, :LLVMFP128Type, [], OpaqueType

.fp128_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



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

attach_function :fp128_type_in_context, :LLVMFP128TypeInContext, [OpaqueContext], OpaqueType

.free_machine_code_for_function(ee, f) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, :pointer], :void

.function_type(return_type, param_types, param_count, is_var_arg) ⇒ OpaqueType

Obtain a function type consisting of a specified signature.

The function is defined as a tuple of a return Type, a list of parameter types, and whether the function is variadic.

Parameters:

  • return_type (OpaqueType)
  • param_types (FFI::Pointer(*TypeRef))
  • param_count (Integer)
  • is_var_arg (Integer)

Returns:



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

attach_function :function_type, :LLVMFunctionType, [OpaqueType, :pointer, :uint, :int], OpaqueType

.generic_value_int_width(gen_val_ref) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [OpaqueGenericValue], :uint

.generic_value_to_float(ty_ref, gen_val) ⇒ Float

(Not documented)

Parameters:

Returns:



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

attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, OpaqueGenericValue], :double

.generic_value_to_int(gen_val, is_signed) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

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


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

attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [OpaqueGenericValue], :pointer

.get_alignment(v) ⇒ Integer

Obtain the preferred alignment of the value.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::AllocaInstllvm::AllocaInst::getAlignment()
  • llvmllvm::LoadInstllvm::LoadInst::getAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::getAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::getAlignment()


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

attach_function :get_alignment, :LLVMGetAlignment, [OpaqueValue], :uint

.get_array_length(array_ty) ⇒ Integer

Obtain the length of an array type.

This only works on types that represent arrays.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::ArrayTypellvm::ArrayType::getNumElements()


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

attach_function :get_array_length, :LLVMGetArrayLength, [OpaqueType], :uint

.get_attribute(arg) ⇒ Symbol from _enum_attribute_

Get an attribute from a function argument.

Parameters:

Returns:



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

attach_function :get_attribute, :LLVMGetAttribute, [OpaqueValue], :attribute

.get_basic_block_parent(bb) ⇒ OpaqueValue

Obtain the function to which a basic block belongs.

Parameters:

Returns:

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::getParent()


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

attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [OpaqueBasicBlock], OpaqueValue

.get_basic_block_terminator(bb) ⇒ OpaqueValue

Obtain the terminator instruction for a basic block.

If the basic block does not have a terminator (it is not well-formed if it doesn’t), then NULL is returned.

The returned LLVMValueRef corresponds to a llvm::TerminatorInst.

Parameters:

Returns:

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::getTerminator()


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

attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [OpaqueBasicBlock], OpaqueValue

.get_basic_blocks(fn, basic_blocks) ⇒ nil

Obtain all of the basic blocks in a function.

This operates on a function value. The BasicBlocks parameter is a pointer to a pre-allocated array of LLVMBasicBlockRef of at least LLVMCountBasicBlocks() in length. This array is populated with LLVMBasicBlockRef instances.

Parameters:

  • fn (OpaqueValue)
  • basic_blocks (FFI::Pointer(*BasicBlockRef))

Returns:

  • (nil) 


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

attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [OpaqueValue, :pointer], :void

.get_bitcode_module(mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_m (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


55
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 55

attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [:pointer, :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) 


45
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 45

attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_bitcode_module_provider(mem_buf, out_mp, out_message) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_mp (FFI::Pointer(*ModuleProviderRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


76
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 76

attach_function :get_bitcode_module_provider, :LLVMGetBitcodeModuleProvider, [:pointer, :pointer, :pointer], :int

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

(Not documented)

Parameters:

  • context_ref (FFI::Pointer(ContextRef))
  • mem_buf (FFI::Pointer(MemoryBufferRef))
  • out_mp (FFI::Pointer(*ModuleProviderRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


66
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 66

attach_function :get_bitcode_module_provider_in_context, :LLVMGetBitcodeModuleProviderInContext, [:pointer, :pointer, :pointer, :pointer], :int

.get_buffer_size(mem_buf) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :get_buffer_size, :LLVMGetBufferSize, [OpaqueMemoryBuffer], :ulong

.get_buffer_start(mem_buf) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_buffer_start, :LLVMGetBufferStart, [OpaqueMemoryBuffer], :string

.get_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

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

@{

Parameters:

Returns:

See Also:

  • llvm::ConstantExpr.


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

attach_function :get_const_opcode, :LLVMGetConstOpcode, [OpaqueValue], :opcode

.get_current_debug_location(builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_current_debug_location, :LLVMGetCurrentDebugLocation, [OpaqueBuilder], OpaqueValue

.get_data_layout(m) ⇒ String

Obtain the data layout for a module.

Parameters:

Returns:

  • (String)

See Also:

  • Module::getDataLayout()


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

attach_function :get_data_layout, :LLVMGetDataLayout, [OpaqueModule], :string

.get_default_target_triple ⇒ String

Get a triple for the host machine as a string. The result needs to be

disposed with LLVMDisposeMessage.

Returns:

  • (String) 


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

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:

Returns:

  • (String)

See Also:

  • DiagnosticInfo::print()


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

attach_function :get_diag_info_description, :LLVMGetDiagInfoDescription, [OpaqueDiagnosticInfo], :string

.get_diag_info_severity(di) ⇒ Symbol from _enum_diagnostic_severity_

Return an enum LLVMDiagnosticSeverity.

Parameters:

Returns:

See Also:

  • DiagnosticInfo::getSeverity()


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

attach_function :get_diag_info_severity, :LLVMGetDiagInfoSeverity, [OpaqueDiagnosticInfo], :diagnostic_severity

.get_dll_storage_class(global) ⇒ Symbol from _enum_dll_storage_class_

(Not documented)

Parameters:

Returns:



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

attach_function :get_dll_storage_class, :LLVMGetDLLStorageClass, [OpaqueValue], :dll_storage_class

.get_element_type(ty) ⇒ OpaqueType

Obtain the type of elements within a sequential type.

This works on array, vector, and pointer types.

Parameters:

Returns:

See Also:

  • llvmllvm::SequentialTypellvm::SequentialType::getElementType()


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

attach_function :get_element_type, :LLVMGetElementType, [OpaqueType], OpaqueType

.get_entry_basic_block(fn) ⇒ OpaqueBasicBlock

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

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::getEntryBlock()


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

attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [OpaqueValue], OpaqueBasicBlock

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TargetDataRef)) 


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

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


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

attach_function :get_execution_engine_target_machine, :LLVMGetExecutionEngineTargetMachine, [OpaqueExecutionEngine], :pointer

.get_first_basic_block(fn) ⇒ OpaqueBasicBlock

Obtain the first basic block in a function.

The returned basic block can be used as an iterator. You will likely eventually call into LLVMGetNextBasicBlock() with it.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::begin()


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

attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_first_function(m) ⇒ OpaqueValue

Obtain an iterator to the first Function in a Module.

Parameters:

Returns:

See Also:

  • llvmllvm::Modulellvm::Module::begin()


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

attach_function :get_first_function, :LLVMGetFirstFunction, [OpaqueModule], OpaqueValue

.get_first_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_first_global, :LLVMGetFirstGlobal, [OpaqueModule], OpaqueValue

.get_first_instruction(bb) ⇒ OpaqueValue

Obtain the first instruction in a basic block.

The returned LLVMValueRef corresponds to a llvm::Instruction instance.

Parameters:

Returns:



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

attach_function :get_first_instruction, :LLVMGetFirstInstruction, [OpaqueBasicBlock], OpaqueValue

.get_first_param(fn) ⇒ OpaqueValue

Obtain the first parameter to a function.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


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

attach_function :get_first_param, :LLVMGetFirstParam, [OpaqueValue], OpaqueValue

.get_first_target ⇒ Target

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

Returns:



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

attach_function :get_first_target, :LLVMGetFirstTarget, [], Target

.get_first_use(val) ⇒ OpaqueUse

Obtain the first use of a value.

Uses are obtained in an iterator fashion. First, call this function to obtain a reference to the first use. Then, call LLVMGetNextUse() on that instance and all subsequently obtained instances until LLVMGetNextUse() returns NULL.

Parameters:

Returns:

See Also:

  • llvmllvm::Valuellvm::Value::use_begin()


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

attach_function :get_first_use, :LLVMGetFirstUse, [OpaqueValue], OpaqueUse

.get_function_attr(fn) ⇒ Symbol from _enum_attribute_

Obtain an attribute from a function.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::getAttributes()


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

attach_function :get_function_attr, :LLVMGetFunctionAttr, [OpaqueValue], :attribute

.get_function_call_conv(fn) ⇒ Integer

Obtain the calling function of a function.

The returned value corresponds to the LLVMCallConv enumeration.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::getCallingConv()


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

attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [OpaqueValue], :uint

.get_gc(fn) ⇒ String

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

Parameters:

Returns:

  • (String)

See Also:

  • llvmllvm::Functionllvm::Function::getGC()


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

attach_function :get_gc, :LLVMGetGC, [OpaqueValue], :string

.get_global_context ⇒ OpaqueContext

Obtain the global context instance.

Returns:



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

attach_function :get_global_context, :LLVMGetGlobalContext, [], OpaqueContext

.get_global_parent(global) ⇒ OpaqueModule

This group contains functions that operate on global values. Functions in this group relate to functions in the llvm::GlobalValue class tree.

@{

Parameters:

Returns:

See Also:

  • llvmllvm::GlobalValue


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

attach_function :get_global_parent, :LLVMGetGlobalParent, [OpaqueValue], OpaqueModule

.get_global_pass_registry ⇒ OpaquePassRegistry

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

@see llvm::PassRegistry::getPassRegistry

Returns:



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

attach_function :get_global_pass_registry, :LLVMGetGlobalPassRegistry, [], OpaquePassRegistry

.get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

Obtain the predicate of an instruction.

This is only valid for instructions that correspond to llvm::ICmpInst or llvm::ConstantExpr whose opcode is llvm::Instruction::ICmp.

Parameters:

Returns:

See Also:

  • llvmllvm::ICmpInstllvm::ICmpInst::getPredicate()


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

attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [OpaqueValue], :int_predicate

.get_incoming_block(phi_node, index) ⇒ OpaqueBasicBlock

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

Parameters:

Returns:



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

attach_function :get_incoming_block, :LLVMGetIncomingBlock, [OpaqueValue, :uint], OpaqueBasicBlock

.get_incoming_value(phi_node, index) ⇒ OpaqueValue

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

Parameters:

Returns:



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

attach_function :get_incoming_value, :LLVMGetIncomingValue, [OpaqueValue, :uint], OpaqueValue

.get_initializer(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_initializer, :LLVMGetInitializer, [OpaqueValue], OpaqueValue

.get_insert_block(builder) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_insert_block, :LLVMGetInsertBlock, [OpaqueBuilder], OpaqueBasicBlock

.get_instruction_call_conv(instr) ⇒ Integer

Obtain the calling convention for a call instruction.

This is the opposite of LLVMSetInstructionCallConv(). Reads its usage.

Parameters:

Returns:

  • (Integer)

See Also:

  • LLVMSetInstructionCallConv()


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

attach_function :get_instruction_call_conv, :LLVMGetInstructionCallConv, [OpaqueValue], :uint

.get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

Obtain the code opcode for an individual instruction.

Parameters:

Returns:

See Also:

  • llvmllvm::Instructionllvm::Instruction::getOpCode()


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

attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [OpaqueValue], :opcode

.get_instruction_parent(inst) ⇒ OpaqueBasicBlock

Obtain the basic block to which an instruction belongs.

Parameters:

Returns:

See Also:

  • llvmllvm::Instructionllvm::Instruction::getParent()


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

attach_function :get_instruction_parent, :LLVMGetInstructionParent, [OpaqueValue], OpaqueBasicBlock

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [OpaqueType], :uint

.get_intrinsic_id(fn) ⇒ Integer

Obtain the ID number from a function instance.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Functionllvm::Function::getIntrinsicID()


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

attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [OpaqueValue], :uint

.get_last_basic_block(fn) ⇒ OpaqueBasicBlock

Obtain the last basic block in a function.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::end()


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

attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_last_function(m) ⇒ OpaqueValue

Obtain an iterator to the last Function in a Module.

Parameters:

Returns:

See Also:

  • llvmllvm::Modulellvm::Module::end()


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

attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue

.get_last_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_global, :LLVMGetLastGlobal, [OpaqueModule], OpaqueValue

.get_last_instruction(bb) ⇒ OpaqueValue

Obtain the last instruction in a basic block.

The returned LLVMValueRef corresponds to an LLVM:Instruction.

Parameters:

Returns:



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

attach_function :get_last_instruction, :LLVMGetLastInstruction, [OpaqueBasicBlock], OpaqueValue

.get_last_param(fn) ⇒ OpaqueValue

Obtain the last parameter to a function.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::arg_end()


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

attach_function :get_last_param, :LLVMGetLastParam, [OpaqueValue], OpaqueValue

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

Returns:



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

attach_function :get_linkage, :LLVMGetLinkage, [OpaqueValue], :linkage

.get_md_kind_id(name, s_len) ⇒ Integer

(Not documented)

Parameters:

  • name (String)
  • s_len (Integer)

Returns:

  • (Integer) 


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

attach_function :get_md_kind_id, :LLVMGetMDKindID, [:string, :uint], :uint

.get_md_kind_id_in_context(c, name, s_len) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :get_md_kind_id_in_context, :LLVMGetMDKindIDInContext, [OpaqueContext, :string, :uint], :uint

.get_md_node_num_operands(v) ⇒ Object

Obtain the number of operands from an MDNode value.

Parameters:

  • V —

    MDNode to get number of operands from.

  • v (OpaqueValue)

Returns:

  • Number of operands of the MDNode.

  • (Integer) 


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

attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [OpaqueValue], :uint

.get_md_node_operands(v, dest) ⇒ nil

Obtain the given MDNode’s operands.

The passed LLVMValueRef pointer should point to enough memory to hold all of the operands of the given MDNode (see LLVMGetMDNodeNumOperands) as LLVMValueRefs. This memory will be populated with the LLVMValueRefs of the MDNode’s operands.

Parameters:

  • V —

    MDNode to get the operands from.

  • Dest —

    Destination array for operands.

  • v (OpaqueValue)
  • dest (FFI::Pointer(*ValueRef))

Returns:

  • (nil) 


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

attach_function :get_md_node_operands, :LLVMGetMDNodeOperands, [OpaqueValue, :pointer], :void

.get_md_string(v, len) ⇒ Object

Obtain the underlying string from a MDString value.

Parameters:

  • V —

    Instance to obtain string from.

  • Len —

    Memory address which will hold length of returned string.

  • v (OpaqueValue)
  • len (FFI::Pointer(*UInt))

Returns:

  • String data in MDString.

  • (String) 


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

attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string

.get_metadata(val, kind_id) ⇒ OpaqueValue

Return metadata associated with an instruction value.

Parameters:

Returns:



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

attach_function :get_metadata, :LLVMGetMetadata, [OpaqueValue, :uint], OpaqueValue

.get_module_context(m) ⇒ OpaqueContext

Obtain the context to which this module is associated.

Parameters:

Returns:

See Also:

  • Module::getContext()


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

attach_function :get_module_context, :LLVMGetModuleContext, [OpaqueModule], OpaqueContext

.get_named_function(m, name) ⇒ OpaqueValue

Obtain a Function value from a Module by its name.

The returned value corresponds to a llvm::Function value.

Parameters:

Returns:

See Also:

  • llvmllvm::Modulellvm::Module::getFunction()


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

attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue

.get_named_global(m, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_named_global, :LLVMGetNamedGlobal, [OpaqueModule, :string], OpaqueValue

.get_named_metadata_num_operands(m, name) ⇒ Integer

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

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Modulellvm::Module::getNamedMetadata()


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

attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [OpaqueModule, :string], :uint

.get_named_metadata_operands(m, name, dest) ⇒ nil

Obtain the named metadata operands for a module.

The passed LLVMValueRef pointer should refer to an array of LLVMValueRef at least LLVMGetNamedMetadataNumOperands long. This array will be populated with the LLVMValueRef instances. Each instance corresponds to a llvm::MDNode.

Parameters:

  • m (OpaqueModule)
  • name (String)
  • dest (FFI::Pointer(*ValueRef))

Returns:

  • (nil)

See Also:

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


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

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ OpaqueBasicBlock

Advance a basic block iterator.

Parameters:

Returns:



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

attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_next_function(fn) ⇒ OpaqueValue

Advance a Function iterator to the next Function.

Returns NULL if the iterator was already at the end and there are no more functions.

Parameters:

Returns:



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

attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue

.get_next_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_global, :LLVMGetNextGlobal, [OpaqueValue], OpaqueValue

.get_next_instruction(inst) ⇒ OpaqueValue

Obtain the instruction that occurs after the one specified.

The next instruction will be from the same basic block.

If this is the last instruction in a basic block, NULL will be returned.

Parameters:

Returns:



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

attach_function :get_next_instruction, :LLVMGetNextInstruction, [OpaqueValue], OpaqueValue

.get_next_param(arg) ⇒ OpaqueValue

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:

Returns:



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

attach_function :get_next_param, :LLVMGetNextParam, [OpaqueValue], OpaqueValue

.get_next_target(t) ⇒ Target

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

Parameters:

Returns:



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

attach_function :get_next_target, :LLVMGetNextTarget, [Target], Target

.get_next_use(u) ⇒ OpaqueUse

Obtain the next use of a value.

This effectively advances the iterator. It returns NULL if you are on the final use and no more are available.

Parameters:

Returns:



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

attach_function :get_next_use, :LLVMGetNextUse, [OpaqueUse], OpaqueUse

.get_num_operands(val) ⇒ Integer

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

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Userllvm::User::getNumOperands()


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

attach_function :get_num_operands, :LLVMGetNumOperands, [OpaqueValue], :int

.get_operand(val, index) ⇒ OpaqueValue

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

Parameters:

Returns:

See Also:

  • llvmllvm::Userllvm::User::getOperand()


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

attach_function :get_operand, :LLVMGetOperand, [OpaqueValue, :uint], OpaqueValue

.get_param(fn, index) ⇒ OpaqueValue

Obtain the parameter at the specified index.

Parameters are indexed from 0.

Parameters:

Returns:

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


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

attach_function :get_param, :LLVMGetParam, [OpaqueValue, :uint], OpaqueValue

.get_param_parent(inst) ⇒ OpaqueValue

Obtain the function to which this argument belongs.

Unlike other functions in this group, this one takes an LLVMValueRef that corresponds to a llvm::Attribute.

The returned LLVMValueRef is the llvm::Function to which this argument belongs.

Parameters:

Returns:



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

attach_function :get_param_parent, :LLVMGetParamParent, [OpaqueValue], OpaqueValue

.get_param_types(function_ty, dest) ⇒ nil

Obtain the types of a function’s parameters.

The Dest parameter should point to a pre-allocated array of LLVMTypeRef at least LLVMCountParamTypes() large. On return, the first LLVMCountParamTypes() entries in the array will be populated with LLVMTypeRef instances.

Parameters:

  • FunctionTy —

    The function type to operate on.

  • Dest —

    Memory address of an array to be filled with result.

  • function_ty (OpaqueType)
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil) 


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

attach_function :get_param_types, :LLVMGetParamTypes, [OpaqueType, :pointer], :void

.get_params(fn, params) ⇒ nil

Obtain the parameters in a function.

The takes a pointer to a pre-allocated array of LLVMValueRef that is at least LLVMCountParams() long. This array will be filled with LLVMValueRef instances which correspond to the parameters the function receives. Each LLVMValueRef corresponds to a llvm::Argument instance.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::arg_begin()


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

attach_function :get_params, :LLVMGetParams, [OpaqueValue, :pointer], :void

.get_pointer_address_space(pointer_ty) ⇒ Integer

Obtain the address space of a pointer type.

This only works on types that represent pointers.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::PointerTypellvm::PointerType::getAddressSpace()


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

attach_function :get_pointer_address_space, :LLVMGetPointerAddressSpace, [OpaqueType], :uint

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void)) 


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

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, :pointer], :pointer

.get_previous_basic_block(bb) ⇒ OpaqueBasicBlock

Go backwards in a basic block iterator.

Parameters:

Returns:



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

attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_previous_function(fn) ⇒ OpaqueValue

Decrement a Function iterator to the previous Function.

Returns NULL if the iterator was already at the beginning and there are no previous functions.

Parameters:

Returns:



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

attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue

.get_previous_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_global, :LLVMGetPreviousGlobal, [OpaqueValue], OpaqueValue

.get_previous_instruction(inst) ⇒ OpaqueValue

Obtain the instruction that occurred before this one.

If the instruction is the first instruction in a basic block, NULL will be returned.

Parameters:

Returns:



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

attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [OpaqueValue], OpaqueValue

.get_previous_param(arg) ⇒ OpaqueValue

Obtain the previous parameter to a function.

This is the opposite of LLVMGetNextParam().

Parameters:

Returns:



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

attach_function :get_previous_param, :LLVMGetPreviousParam, [OpaqueValue], OpaqueValue

.get_return_type(function_ty) ⇒ OpaqueType

Obtain the Type this function Type returns.

Parameters:

Returns:



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

attach_function :get_return_type, :LLVMGetReturnType, [OpaqueType], OpaqueType

.get_section(global) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_section, :LLVMGetSection, [OpaqueValue], :string

.get_struct_element_types(struct_ty, dest) ⇒ nil

Get the elements within a structure.

The function is passed the address of a pre-allocated array of LLVMTypeRef at least LLVMCountStructElementTypes() long. After invocation, this array will be populated with the structure’s elements. The objects in the destination array will have a lifetime of the structure type itself, which is the lifetime of the context it is contained in.

Parameters:

  • struct_ty (OpaqueType)
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil) 


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

attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [OpaqueType, :pointer], :void

.get_struct_name(ty) ⇒ String

Obtain the name of a structure.

Parameters:

Returns:

  • (String)

See Also:

  • llvmllvm::StructTypellvm::StructType::getName()


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

attach_function :get_struct_name, :LLVMGetStructName, [OpaqueType], :string

.get_switch_default_dest(switch_instr) ⇒ OpaqueBasicBlock

Obtain the default destination basic block of a switch instruction.

This only works on llvm::SwitchInst instructions.

Parameters:

Returns:

See Also:

  • llvmllvm::SwitchInstllvm::SwitchInst::getDefaultDest()


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

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [OpaqueValue], OpaqueBasicBlock

.get_target(m) ⇒ String

Obtain the target triple for a module.

Parameters:

Returns:

  • (String)

See Also:

  • Module::getTargetTriple()


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

attach_function :get_target, :LLVMGetTarget, [OpaqueModule], :string

.get_target_description(t) ⇒ String

Returns the description of a target. See llvm::Target::getDescription

Parameters:

Returns:

  • (String) 


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

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:



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

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) 


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

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) 


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

attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string

.get_target_machine_data(t) ⇒ OpaqueTargetData

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

Parameters:

Returns:



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

attach_function :get_target_machine_data, :LLVMGetTargetMachineData, [OpaqueTargetMachine], OpaqueTargetData

.get_target_machine_feature_string(t) ⇒ String

Returns the feature string used creating this target machine. See

llvm::TargetMachine::getFeatureString. The result needs to be disposed with
LLVMDisposeMessage.

Parameters:

Returns:

  • (String) 


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

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:



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

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) 


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

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) 


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

attach_function :get_target_name, :LLVMGetTargetName, [Target], :string

.get_thread_local_mode(global_var) ⇒ Symbol from _enum_thread_local_mode_

(Not documented)

Parameters:

Returns:



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

attach_function :get_thread_local_mode, :LLVMGetThreadLocalMode, [OpaqueValue], :thread_local_mode

.get_type_by_name(m, name) ⇒ OpaqueType

Obtain a Type from a module by its registered name.

Parameters:

Returns:



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

attach_function :get_type_by_name, :LLVMGetTypeByName, [OpaqueModule, :string], OpaqueType

.get_type_context(ty) ⇒ OpaqueContext

Obtain the context to which this type instance is associated.

Parameters:

Returns:

See Also:

  • llvmllvm::Typellvm::Type::getContext()


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

attach_function :get_type_context, :LLVMGetTypeContext, [OpaqueType], OpaqueContext

.get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

Obtain the enumerated type of a Type instance.

Parameters:

Returns:

See Also:

  • llvm::Type:getTypeID()


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

attach_function :get_type_kind, :LLVMGetTypeKind, [OpaqueType], :type_kind

.get_undef(ty) ⇒ OpaqueValue

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

Parameters:

Returns:

See Also:

  • llvmllvm::UndefValuellvm::UndefValue::get()


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

attach_function :get_undef, :LLVMGetUndef, [OpaqueType], OpaqueValue

.get_used_value(u) ⇒ OpaqueValue

Obtain the value this use corresponds to.

Parameters:

Returns:

See Also:

  • llvm::Use::get().


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

attach_function :get_used_value, :LLVMGetUsedValue, [OpaqueUse], OpaqueValue

.get_user(u) ⇒ OpaqueValue

Obtain the user value for a user.

The returned value corresponds to a llvm::User type.

Parameters:

Returns:

See Also:

  • llvmllvm::Usellvm::Use::getUser()


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

attach_function :get_user, :LLVMGetUser, [OpaqueUse], OpaqueValue

.get_value_name(val) ⇒ String

Obtain the string name of a value.

Parameters:

Returns:

  • (String)

See Also:

  • llvmllvm::Valuellvm::Value::getName()


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

attach_function :get_value_name, :LLVMGetValueName, [OpaqueValue], :string

.get_vector_size(vector_ty) ⇒ Integer

Obtain the number of elements in a vector type.

This only works on types that represent vectors.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::VectorTypellvm::VectorType::getNumElements()


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

attach_function :get_vector_size, :LLVMGetVectorSize, [OpaqueType], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

Returns:



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

attach_function :get_visibility, :LLVMGetVisibility, [OpaqueValue], :visibility

.get_volatile(memory_access_inst) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :get_volatile, :LLVMGetVolatile, [OpaqueValue], :int

.half_type ⇒ OpaqueType

Obtain a floating point type from the global context.

These map to the functions in this group of the same name.

Returns:



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

attach_function :half_type, :LLVMHalfType, [], OpaqueType

.half_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



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

attach_function :half_type_in_context, :LLVMHalfTypeInContext, [OpaqueContext], OpaqueType

.has_metadata(val) ⇒ Integer

Determine whether an instruction has any metadata attached.

Parameters:

Returns:

  • (Integer) 


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

attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int

.has_unnamed_addr(global) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


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

attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [OpaqueValue], :int

.initialize_all_asm_parsers ⇒ nil

(Not documented)

Returns:

  • (nil) 


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

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

.initialize_all_asm_printers ⇒ nil

(Not documented)

Returns:

  • (nil) 


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

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

.initialize_all_disassemblers ⇒ nil

(Not documented)

Returns:

  • (nil) 


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

attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void

.initialize_all_target_infos ⇒ nil

(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_cs ⇒ nil

(Not documented)

Returns:

  • (nil) 


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

attach_function :initialize_all_target_m_cs, :LLVMInitializeAllTargetMCs, [], :void

.initialize_all_targets ⇒ nil

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

Returns:

  • (nil) 


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

attach_function :initialize_core, :LLVMInitializeCore, [OpaquePassRegistry], :void

.initialize_function_pass_manager(fpm) ⇒ Integer

Initializes all of the function passes scheduled in the function pass

manager. Returns 1 if any of the passes modified the module, 0 otherwise.
@see llvm::FunctionPassManager::doInitialization

Parameters:

Returns:

  • (Integer) 


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

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [OpaquePassManager], :int

.initialize_mcjit_compiler_options(options, size_of_options) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void

.initialize_native_asm_parser ⇒ Integer

(Not documented)

Returns:

  • (Integer) 


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

attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int

.initialize_native_asm_printer ⇒ Integer

(Not documented)

Returns:

  • (Integer) 


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

attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int

.initialize_native_disassembler ⇒ Integer

(Not documented)

Returns:

  • (Integer) 


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

attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int

.initialize_native_target ⇒ Integer

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

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

Parameters:

Returns:

See Also:

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


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

attach_function :insert_basic_block, :LLVMInsertBasicBlock, [OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_basic_block_in_context(c, bb, name) ⇒ OpaqueBasicBlock

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

The function to add to is determined by the function of the passed basic block.

Parameters:

Returns:

See Also:

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


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

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [OpaqueBuilder, OpaqueValue], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :insert_into_builder_with_name, :LLVMInsertIntoBuilderWithName, [OpaqueBuilder, OpaqueValue, :string], :void

.install_fatal_error_handler(handler) ⇒ nil

Install a fatal error handler. By default, if LLVM detects a fatal error, it will call exit(1). This may not be appropriate in many contexts. For example, doing exit(1) will bypass many crash reporting/tracing system tools. This function allows you to install a callback that will be invoked prior to the call to exit(1).

Parameters:

  • handler (FFI::Pointer(FatalErrorHandler))

Returns:

  • (nil) 


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

attach_function :install_fatal_error_handler, :LLVMInstallFatalErrorHandler, [:pointer], :void

.instruction_erase_from_parent(inst) ⇒ nil

Remove and delete an instruction.

The instruction specified is removed from its containing building block and then deleted.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Instructionllvm::Instruction::eraseFromParent()


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

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [OpaqueValue], :void

.int16_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int16_type, :LLVMInt16Type, [], OpaqueType

.int16_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int16_type_in_context, :LLVMInt16TypeInContext, [OpaqueContext], OpaqueType

.int1_type ⇒ OpaqueType

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

Returns:



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

attach_function :int1_type, :LLVMInt1Type, [], OpaqueType

.int1_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



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

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [OpaqueContext], OpaqueType

.int32_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int32_type, :LLVMInt32Type, [], OpaqueType

.int32_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [OpaqueContext], OpaqueType

.int64_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int64_type, :LLVMInt64Type, [], OpaqueType

.int64_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [OpaqueContext], OpaqueType

.int8_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int8_type, :LLVMInt8Type, [], OpaqueType

.int8_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [OpaqueContext], OpaqueType

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

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(TypeRef)) 


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

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


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

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


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

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


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

attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [:pointer, OpaqueTargetData], :pointer

.int_type(num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

  • num_bits (Integer)

Returns:



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

attach_function :int_type, :LLVMIntType, [:uint], OpaqueType

.int_type_in_context(c, num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int_type_in_context, :LLVMIntTypeInContext, [OpaqueContext, :uint], OpaqueType

.is_a_addr_space_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_addr_space_cast_inst, :LLVMIsAAddrSpaceCastInst, [OpaqueValue], OpaqueValue

.is_a_alloca_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [OpaqueValue], OpaqueValue

.is_a_argument(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_argument, :LLVMIsAArgument, [OpaqueValue], OpaqueValue

.is_a_basic_block(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [OpaqueValue], OpaqueValue

.is_a_binary_operator(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [OpaqueValue], OpaqueValue

.is_a_bit_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [OpaqueValue], OpaqueValue

.is_a_block_address(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_block_address, :LLVMIsABlockAddress, [OpaqueValue], OpaqueValue

.is_a_branch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [OpaqueValue], OpaqueValue

.is_a_call_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_call_inst, :LLVMIsACallInst, [OpaqueValue], OpaqueValue

.is_a_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_cast_inst, :LLVMIsACastInst, [OpaqueValue], OpaqueValue

.is_a_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [OpaqueValue], OpaqueValue

.is_a_constant(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant, :LLVMIsAConstant, [OpaqueValue], OpaqueValue

.is_a_constant_aggregate_zero(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [OpaqueValue], OpaqueValue

.is_a_constant_array(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [OpaqueValue], OpaqueValue

.is_a_constant_data_array(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_data_array, :LLVMIsAConstantDataArray, [OpaqueValue], OpaqueValue

.is_a_constant_data_sequential(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_data_sequential, :LLVMIsAConstantDataSequential, [OpaqueValue], OpaqueValue

.is_a_constant_data_vector(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_data_vector, :LLVMIsAConstantDataVector, [OpaqueValue], OpaqueValue

.is_a_constant_expr(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [OpaqueValue], OpaqueValue

.is_a_constant_fp(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [OpaqueValue], OpaqueValue

.is_a_constant_int(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [OpaqueValue], OpaqueValue

.is_a_constant_pointer_null(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [OpaqueValue], OpaqueValue

.is_a_constant_struct(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [OpaqueValue], OpaqueValue

.is_a_constant_vector(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2060
 
# File 'lib/llvm/core_ffi.rb', line 2060

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [OpaqueValue], OpaqueValue

.is_a_dbg_declare_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2156
 
# File 'lib/llvm/core_ffi.rb', line 2156

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [OpaqueValue], OpaqueValue

.is_a_dbg_info_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2148
 
# File 'lib/llvm/core_ffi.rb', line 2148

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [OpaqueValue], OpaqueValue

.is_a_extract_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2220
 
# File 'lib/llvm/core_ffi.rb', line 2220

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [OpaqueValue], OpaqueValue

.is_a_extract_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2484
 
# File 'lib/llvm/core_ffi.rb', line 2484

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [OpaqueValue], OpaqueValue

.is_a_function(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2092
 
# File 'lib/llvm/core_ffi.rb', line 2092

attach_function :is_a_function, :LLVMIsAFunction, [OpaqueValue], OpaqueValue

.is_a_get_element_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2228
 
# File 'lib/llvm/core_ffi.rb', line 2228

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [OpaqueValue], OpaqueValue

.is_a_global_alias(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2076
 
# File 'lib/llvm/core_ffi.rb', line 2076

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [OpaqueValue], OpaqueValue

.is_a_global_object(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2084
 
# File 'lib/llvm/core_ffi.rb', line 2084

attach_function :is_a_global_object, :LLVMIsAGlobalObject, [OpaqueValue], OpaqueValue

.is_a_global_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2068
 
# File 'lib/llvm/core_ffi.rb', line 2068

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [OpaqueValue], OpaqueValue

.is_a_global_variable(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2100
 
# File 'lib/llvm/core_ffi.rb', line 2100

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [OpaqueValue], OpaqueValue

.is_a_indirect_br_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2308
 
# File 'lib/llvm/core_ffi.rb', line 2308

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [OpaqueValue], OpaqueValue

.is_a_inline_asm(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1932
 
# File 'lib/llvm/core_ffi.rb', line 1932

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [OpaqueValue], OpaqueValue

.is_a_insert_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2236
 
# File 'lib/llvm/core_ffi.rb', line 2236

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [OpaqueValue], OpaqueValue

.is_a_insert_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2244
 
# File 'lib/llvm/core_ffi.rb', line 2244

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [OpaqueValue], OpaqueValue

.is_a_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2116
 
# File 'lib/llvm/core_ffi.rb', line 2116

attach_function :is_a_instruction, :LLVMIsAInstruction, [OpaqueValue], OpaqueValue

.is_a_int_to_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2428
 
# File 'lib/llvm/core_ffi.rb', line 2428

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [OpaqueValue], OpaqueValue

.is_a_intrinsic_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2140
 
# File 'lib/llvm/core_ffi.rb', line 2140

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [OpaqueValue], OpaqueValue

.is_a_invoke_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2316
 
# File 'lib/llvm/core_ffi.rb', line 2316

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [OpaqueValue], OpaqueValue

.is_a_landing_pad_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2252
 
# File 'lib/llvm/core_ffi.rb', line 2252

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [OpaqueValue], OpaqueValue

.is_a_load_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2492
 
# File 'lib/llvm/core_ffi.rb', line 2492

attach_function :is_a_load_inst, :LLVMIsALoadInst, [OpaqueValue], OpaqueValue

.is_a_mem_cpy_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2172
 
# File 'lib/llvm/core_ffi.rb', line 2172

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [OpaqueValue], OpaqueValue

.is_a_mem_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2164
 
# File 'lib/llvm/core_ffi.rb', line 2164

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [OpaqueValue], OpaqueValue

.is_a_mem_move_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2180
 
# File 'lib/llvm/core_ffi.rb', line 2180

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [OpaqueValue], OpaqueValue

.is_a_mem_set_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2188
 
# File 'lib/llvm/core_ffi.rb', line 2188

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [OpaqueValue], OpaqueValue

.is_a_ptr_to_int_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2436
 
# File 'lib/llvm/core_ffi.rb', line 2436

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [OpaqueValue], OpaqueValue

.is_a_resume_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2348
 
# File 'lib/llvm/core_ffi.rb', line 2348

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [OpaqueValue], OpaqueValue

.is_a_return_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2324
 
# File 'lib/llvm/core_ffi.rb', line 2324

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [OpaqueValue], OpaqueValue

.is_a_select_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2268
 
# File 'lib/llvm/core_ffi.rb', line 2268

attach_function :is_a_select_inst, :LLVMIsASelectInst, [OpaqueValue], OpaqueValue

.is_a_shuffle_vector_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2276
 
# File 'lib/llvm/core_ffi.rb', line 2276

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [OpaqueValue], OpaqueValue

.is_a_store_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2284
 
# File 'lib/llvm/core_ffi.rb', line 2284

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [OpaqueValue], OpaqueValue

.is_a_switch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2332
 
# File 'lib/llvm/core_ffi.rb', line 2332

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [OpaqueValue], OpaqueValue

.is_a_terminator_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2292
 
# File 'lib/llvm/core_ffi.rb', line 2292

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [OpaqueValue], OpaqueValue

.is_a_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2460
 
# File 'lib/llvm/core_ffi.rb', line 2460

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [OpaqueValue], OpaqueValue

.is_a_unary_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2356
 
# File 'lib/llvm/core_ffi.rb', line 2356

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [OpaqueValue], OpaqueValue

.is_a_undef_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2108
 
# File 'lib/llvm/core_ffi.rb', line 2108

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [OpaqueValue], OpaqueValue

.is_a_unreachable_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2340
 
# File 'lib/llvm/core_ffi.rb', line 2340

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [OpaqueValue], OpaqueValue

.is_a_user(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1956
 
# File 'lib/llvm/core_ffi.rb', line 1956

attach_function :is_a_user, :LLVMIsAUser, [OpaqueValue], OpaqueValue

.is_af_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2204
 
# File 'lib/llvm/core_ffi.rb', line 2204

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [OpaqueValue], OpaqueValue

.is_afp_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2396
 
# File 'lib/llvm/core_ffi.rb', line 2396

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [OpaqueValue], OpaqueValue

.is_afp_to_si_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2404
 
# File 'lib/llvm/core_ffi.rb', line 2404

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [OpaqueValue], OpaqueValue

.is_afp_to_ui_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2412
 
# File 'lib/llvm/core_ffi.rb', line 2412

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [OpaqueValue], OpaqueValue

.is_afp_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2420
 
# File 'lib/llvm/core_ffi.rb', line 2420

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [OpaqueValue], OpaqueValue

.is_ai_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2212
 
# File 'lib/llvm/core_ffi.rb', line 2212

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [OpaqueValue], OpaqueValue

.is_amd_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1940
 
# File 'lib/llvm/core_ffi.rb', line 1940

attach_function :is_amd_node, :LLVMIsAMDNode, [OpaqueValue], OpaqueValue

.is_amd_string(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1948
 
# File 'lib/llvm/core_ffi.rb', line 1948

attach_function :is_amd_string, :LLVMIsAMDString, [OpaqueValue], OpaqueValue

.is_aphi_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2260
 
# File 'lib/llvm/core_ffi.rb', line 2260

attach_function :is_aphi_node, :LLVMIsAPHINode, [OpaqueValue], OpaqueValue

.is_as_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2444
 
# File 'lib/llvm/core_ffi.rb', line 2444

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [OpaqueValue], OpaqueValue

.is_asi_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2452
 
# File 'lib/llvm/core_ffi.rb', line 2452

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [OpaqueValue], OpaqueValue

.is_aui_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2468
 
# File 'lib/llvm/core_ffi.rb', line 2468

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [OpaqueValue], OpaqueValue

.is_ava_arg_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2500
 
# File 'lib/llvm/core_ffi.rb', line 2500

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [OpaqueValue], OpaqueValue

.is_az_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2476
 
# File 'lib/llvm/core_ffi.rb', line 2476

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [OpaqueValue], OpaqueValue

.is_constant(val) ⇒ Integer

Determine whether the specified constant instance is constant.

Parameters:

Returns:

  • (Integer) 


1900
 
# File 'lib/llvm/core_ffi.rb', line 1900

attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3447
 
# File 'lib/llvm/core_ffi.rb', line 3447

attach_function :is_declaration, :LLVMIsDeclaration, [OpaqueValue], :int

.is_externally_initialized(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3709
 
# File 'lib/llvm/core_ffi.rb', line 3709

attach_function :is_externally_initialized, :LLVMIsExternallyInitialized, [OpaqueValue], :int

.is_function_var_arg(function_ty) ⇒ Integer

Returns whether a function type is variadic.

Parameters:

Returns:

  • (Integer) 


1551
 
# File 'lib/llvm/core_ffi.rb', line 1551

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [OpaqueType], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3675
 
# File 'lib/llvm/core_ffi.rb', line 3675

attach_function :is_global_constant, :LLVMIsGlobalConstant, [OpaqueValue], :int

.is_multithreaded ⇒ Integer

Check whether LLVM is executing in thread-safe mode or not.

@see llvm::llvm_is_multithreaded

Returns:

  • (Integer) 


5886
 
# File 'lib/llvm/core_ffi.rb', line 5886

attach_function :is_multithreaded, :LLVMIsMultithreaded, [], :int

.is_null(val) ⇒ Integer

Determine whether a value instance is null.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Constantllvm::Constant::isNullValue()


2624
 
# File 'lib/llvm/core_ffi.rb', line 2624

attach_function :is_null, :LLVMIsNull, [OpaqueValue], :int

.is_opaque_struct(struct_ty) ⇒ Integer

Determine whether a structure is opaque.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::isOpaque()


1692
 
# File 'lib/llvm/core_ffi.rb', line 1692

attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [OpaqueType], :int

.is_packed_struct(struct_ty) ⇒ Integer

Determine whether a structure is packed.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::StructTypellvm::StructType::isPacked()


1682
 
# File 'lib/llvm/core_ffi.rb', line 1682

attach_function :is_packed_struct, :LLVMIsPackedStruct, [OpaqueType], :int

.is_tail_call(call_inst) ⇒ Integer

Obtain whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

Parameters:

Returns:

  • (Integer)

See Also:

  • llvmllvm::CallInstllvm::CallInst::isTailCall()


4478
 
# File 'lib/llvm/core_ffi.rb', line 4478

attach_function :is_tail_call, :LLVMIsTailCall, [OpaqueValue], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3658
 
# File 'lib/llvm/core_ffi.rb', line 3658

attach_function :is_thread_local, :LLVMIsThreadLocal, [OpaqueValue], :int

.is_undef(val) ⇒ Integer

Determine whether a value instance is undefined.

Parameters:

Returns:

  • (Integer) 


1908
 
# File 'lib/llvm/core_ffi.rb', line 1908

attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int

.label_type ⇒ OpaqueType

(Not documented)

Returns:



1822
 
# File 'lib/llvm/core_ffi.rb', line 1822

attach_function :label_type, :LLVMLabelType, [], OpaqueType

.label_type_in_context(c) ⇒ OpaqueType

Create a label type in a context.

Parameters:

Returns:



1799
 
# File 'lib/llvm/core_ffi.rb', line 1799

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [OpaqueContext], OpaqueType

.link_in_interpreter ⇒ nil

(Not documented)

Returns:

  • (nil) 


37
 
# File 'lib/llvm/execution_engine_ffi.rb', line 37

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

.link_in_jit ⇒ nil

@{

Returns:

  • (nil) 


23
 
# File 'lib/llvm/execution_engine_ffi.rb', line 23

attach_function :link_in_jit, :LLVMLinkInJIT, [], :void

.link_in_mcjit ⇒ nil

(Not documented)

Returns:

  • (nil) 


30
 
# File 'lib/llvm/execution_engine_ffi.rb', line 30

attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void

.link_modules(dest, src, mode, out_message) ⇒ Integer

Links the source module into the destination module, taking ownership of the source module away from the caller. Optionally returns a human-readable description of any errors that occurred in linking. OutMessage must be disposed with LLVMDisposeMessage. The return value is true if an error occurred, false otherwise.

Parameters:

  • dest (FFI::Pointer(ModuleRef))
  • src (FFI::Pointer(ModuleRef))
  • mode (Symbol from _enum_linker_mode_)
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


46
 
# File 'lib/llvm/linker_ffi.rb', line 46

attach_function :link_modules, :LLVMLinkModules, [:pointer, :pointer, :linker_mode, :pointer], :int

.load_library_permanently(filename) ⇒ Integer

This function permanently loads the dynamic library at the given path. It is safe to call this function multiple times for the same library.

Parameters:

  • filename (String)

Returns:

  • (Integer)

See Also:

  • syssys::DynamicLibrarysys::DynamicLibrary::LoadLibraryPermanently()


35
 
# File 'lib/llvm/core_ffi.rb', line 35

attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int

.md_node(vals, count) ⇒ OpaqueValue

Obtain a MDNode value from the global context.

Parameters:

  • vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:



4028
 
# File 'lib/llvm/core_ffi.rb', line 4028

attach_function :md_node, :LLVMMDNode, [:pointer, :uint], OpaqueValue

.md_node_in_context(c, vals, count) ⇒ OpaqueValue

Obtain a MDNode value from a context.

The returned value corresponds to the llvm::MDNode class.

Parameters:

  • c (OpaqueContext)
  • vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:



4019
 
# File 'lib/llvm/core_ffi.rb', line 4019

attach_function :md_node_in_context, :LLVMMDNodeInContext, [OpaqueContext, :pointer, :uint], OpaqueValue

.md_string(str, s_len) ⇒ OpaqueValue

Obtain a MDString value from the global context.

Parameters:

  • str (String)
  • s_len (Integer)

Returns:



4007
 
# File 'lib/llvm/core_ffi.rb', line 4007

attach_function :md_string, :LLVMMDString, [:string, :uint], OpaqueValue

.md_string_in_context(c, str, s_len) ⇒ OpaqueValue

Obtain a MDString value from a context.

The returned instance corresponds to the llvm::MDString class.

The instance is specified by string data of a specified length. The string content is copied, so the backing memory can be freed after this function returns.

Parameters:

Returns:



3998
 
# File 'lib/llvm/core_ffi.rb', line 3998

attach_function :md_string_in_context, :LLVMMDStringInContext, [OpaqueContext, :string, :uint], OpaqueValue

.module_create_with_name(module_id) ⇒ OpaqueModule

Create a new, empty module in the global context.

This is equivalent to calling LLVMModuleCreateWithNameInContext with LLVMGetGlobalContext() as the context parameter.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

  • module_id (String)

Returns:



1044
 
# File 'lib/llvm/core_ffi.rb', line 1044

attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], OpaqueModule

.module_create_with_name_in_context(module_id, c) ⇒ OpaqueModule

Create a new, empty module in a specific context.

Every invocation should be paired with LLVMDisposeModule() or memory will be leaked.

Parameters:

Returns:



1056
 
# File 'lib/llvm/core_ffi.rb', line 1056

attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, OpaqueContext], OpaqueModule

.move_basic_block_after(bb, move_pos) ⇒ nil

Move a basic block to after another one.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::moveAfter()


4290
 
# File 'lib/llvm/core_ffi.rb', line 4290

attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.move_basic_block_before(bb, move_pos) ⇒ nil

Move a basic block to before another one.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::moveBefore()


4279
 
# File 'lib/llvm/core_ffi.rb', line 4279

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.offset_of_element(td, struct_ty, element) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


289
 
# File 'lib/llvm/target_ffi.rb', line 289

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_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) 


34
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 34

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [:pointer, :pointer, :pointer, :pointer], :int

.pass_manager_builder_create ⇒ OpaquePassManagerBuilder

See llvm::PassManagerBuilder.

Returns:



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) 


161
 
# File 'lib/llvm/target_ffi.rb', line 161

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_size_for_as(td, as) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


170
 
# File 'lib/llvm/target_ffi.rb', line 170

attach_function :pointer_size_for_as, :LLVMPointerSizeForAS, [OpaqueTargetData, :uint], :uint

.pointer_type(element_type, address_space) ⇒ OpaqueType

Create a pointer type that points to a defined type.

The created type will exist in the context that its pointee type exists in.

Parameters:

  • element_type (OpaqueType)
  • address_space (Integer)

Returns:

See Also:

  • llvmllvm::PointerTypellvm::PointerType::get()


1744
 
# File 'lib/llvm/core_ffi.rb', line 1744

attach_function :pointer_type, :LLVMPointerType, [OpaqueType, :uint], OpaqueType

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4570
 
# File 'lib/llvm/core_ffi.rb', line 4570

attach_function :position_builder, :LLVMPositionBuilder, [OpaqueBuilder, OpaqueBasicBlock, OpaqueValue], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4588
 
# File 'lib/llvm/core_ffi.rb', line 4588

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [OpaqueBuilder, OpaqueBasicBlock], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4579
 
# File 'lib/llvm/core_ffi.rb', line 4579

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [OpaqueBuilder, OpaqueValue], :void

.ppcfp128_type ⇒ OpaqueType

(Not documented)

Returns:



1529
 
# File 'lib/llvm/core_ffi.rb', line 1529

attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], OpaqueType

.ppcfp128_type_in_context(c) ⇒ OpaqueType

Obtain a 128-bit floating point type (two 64-bits) from a context.

Parameters:

Returns:



1485
 
# File 'lib/llvm/core_ffi.rb', line 1485

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [OpaqueContext], OpaqueType

.preferred_alignment_of_global(td, global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


269
 
# File 'lib/llvm/target_ffi.rb', line 269

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, :pointer], :uint

.preferred_alignment_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


260
 
# File 'lib/llvm/target_ffi.rb', line 260

attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, :pointer], :uint

.print_module_to_file(m, filename, error_message) ⇒ Integer

Print a representation of a module to a file. The ErrorMessage needs to be disposed with LLVMDisposeMessage. Returns 0 on success, 1 otherwise.

Parameters:

  • m (OpaqueModule)
  • filename (String)
  • error_message (FFI::Pointer(**CharS))

Returns:

  • (Integer)

See Also:

  • Module::print()


1132
 
# File 'lib/llvm/core_ffi.rb', line 1132

attach_function :print_module_to_file, :LLVMPrintModuleToFile, [OpaqueModule, :string, :pointer], :int

.print_module_to_string(m) ⇒ String

Return a string representation of the module. Use LLVMDisposeMessage to free the string.

Parameters:

Returns:

  • (String)

See Also:

  • Module::print()


1143
 
# File 'lib/llvm/core_ffi.rb', line 1143

attach_function :print_module_to_string, :LLVMPrintModuleToString, [OpaqueModule], :string

.print_type_to_string(val) ⇒ String

Return a string representation of the type. Use LLVMDisposeMessage to free the string.

Parameters:

Returns:

  • (String)

See Also:

  • llvmllvm::Typellvm::Type::print()


1335
 
# File 'lib/llvm/core_ffi.rb', line 1335

attach_function :print_type_to_string, :LLVMPrintTypeToString, [OpaqueType], :string

.print_value_to_string(val) ⇒ String

Return a string representation of the value. Use LLVMDisposeMessage to free the string.

Parameters:

Returns:

  • (String)

See Also:

  • llvmllvm::Valuellvm::Value::print()


1881
 
# File 'lib/llvm/core_ffi.rb', line 1881

attach_function :print_value_to_string, :LLVMPrintValueToString, [OpaqueValue], :string

.recompile_and_relink_function(ee, fn) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void)) 


354
 
# File 'lib/llvm/execution_engine_ffi.rb', line 354

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, :pointer], :pointer

.remove_attribute(arg, pa) ⇒ nil

Remove an attribute from a function argument.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Argumentllvm::Argument::removeAttr()


3962
 
# File 'lib/llvm/core_ffi.rb', line 3962

attach_function :remove_attribute, :LLVMRemoveAttribute, [OpaqueValue, :attribute], :void

.remove_basic_block_from_parent(bb) ⇒ nil

Remove a basic block from a function.

This deletes the basic block from its containing function but keep the basic block alive.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::BasicBlockllvm::BasicBlock::removeFromParent()


4268
 
# File 'lib/llvm/core_ffi.rb', line 4268

attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [OpaqueBasicBlock], :void

.remove_function_attr(fn, pa) ⇒ nil

Remove an attribute from a function.

Parameters:

Returns:

  • (nil) 


3844
 
# File 'lib/llvm/core_ffi.rb', line 3844

attach_function :remove_function_attr, :LLVMRemoveFunctionAttr, [OpaqueValue, :attribute], :void

.remove_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4456
 
# File 'lib/llvm/core_ffi.rb', line 4456

attach_function :remove_instr_attribute, :LLVMRemoveInstrAttribute, [OpaqueValue, :uint, :attribute], :void

.remove_module(ee, m, out_mod, out_error) ⇒ Integer

(Not documented)

Parameters:

  • ee (OpaqueExecutionEngine)
  • m (FFI::Pointer(ModuleRef))
  • out_mod (FFI::Pointer(*ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


324
 
# File 'lib/llvm/execution_engine_ffi.rb', line 324

attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int

.remove_module_provider(ee, mp, out_mod, out_error) ⇒ Integer

Deprecated: Use LLVMRemoveModule instead.

Parameters:

  • ee (OpaqueExecutionEngine)
  • mp (FFI::Pointer(ModuleProviderRef))
  • out_mod (FFI::Pointer(*ModuleRef))
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


335
 
# File 'lib/llvm/execution_engine_ffi.rb', line 335

attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int

.replace_all_uses_with(old_val, new_val) ⇒ nil

Replace all uses of a value with another one.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::replaceAllUsesWith()


1892
 
# File 'lib/llvm/core_ffi.rb', line 1892

attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [OpaqueValue, OpaqueValue], :void

.reset_fatal_error_handler ⇒ nil

Reset the fatal error handler. This resets LLVM’s fatal error handling behavior to the default.

Returns:

  • (nil) 


903
 
# File 'lib/llvm/core_ffi.rb', line 903

attach_function :reset_fatal_error_handler, :LLVMResetFatalErrorHandler, [], :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:



286
 
# File 'lib/llvm/execution_engine_ffi.rb', line 286

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) 


275
 
# File 'lib/llvm/execution_engine_ffi.rb', line 275

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:

Returns:

  • (Integer) 


5841
 
# File 'lib/llvm/core_ffi.rb', line 5841

attach_function :run_function_pass_manager, :LLVMRunFunctionPassManager, [OpaquePassManager, OpaqueValue], :int

.run_pass_manager(pm, m) ⇒ Integer

Initializes, executes on the provided module, and finalizes all of the

passes scheduled in the pass manager. Returns 1 if any of the passes
modified the module, 0 otherwise.
@see llvm::PassManager::run(Module&)

Parameters:

Returns:

  • (Integer) 


5819
 
# File 'lib/llvm/core_ffi.rb', line 5819

attach_function :run_pass_manager, :LLVMRunPassManager, [OpaquePassManager, OpaqueModule], :int

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


255
 
# File 'lib/llvm/execution_engine_ffi.rb', line 255

attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void

.run_static_destructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


263
 
# File 'lib/llvm/execution_engine_ffi.rb', line 263

attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void

.set_alignment(v, bytes) ⇒ nil

Set the preferred alignment of the value.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::AllocaInstllvm::AllocaInst::setAlignment()
  • llvmllvm::LoadInstllvm::LoadInst::setAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::setAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::setAlignment()


3557
 
# File 'lib/llvm/core_ffi.rb', line 3557

attach_function :set_alignment, :LLVMSetAlignment, [OpaqueValue, :uint], :void

.set_cleanup(landing_pad, val) ⇒ nil

Set the ‘cleanup’ flag in the landingpad instruction

Parameters:

Returns:

  • (nil) 


4805
 
# File 'lib/llvm/core_ffi.rb', line 4805

attach_function :set_cleanup, :LLVMSetCleanup, [OpaqueValue, :int], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

Returns:

  • (nil) 


4640
 
# File 'lib/llvm/core_ffi.rb', line 4640

attach_function :set_current_debug_location, :LLVMSetCurrentDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_data_layout(m, triple) ⇒ nil

Set the data layout for a module.

Parameters:

Returns:

  • (nil)

See Also:

  • Module::setDataLayout()


1088
 
# File 'lib/llvm/core_ffi.rb', line 1088

attach_function :set_data_layout, :LLVMSetDataLayout, [OpaqueModule, :string], :void

.set_dll_storage_class(global, class_) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3515
 
# File 'lib/llvm/core_ffi.rb', line 3515

attach_function :set_dll_storage_class, :LLVMSetDLLStorageClass, [OpaqueValue, :dll_storage_class], :void

.set_externally_initialized(global_var, is_ext_init) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3718
 
# File 'lib/llvm/core_ffi.rb', line 3718

attach_function :set_externally_initialized, :LLVMSetExternallyInitialized, [OpaqueValue, :int], :void

.set_function_call_conv(fn, cc) ⇒ nil

Set the calling convention of a function.

Parameters:

  • Fn —

    Function to operate on

  • CC —

    LLVMCallConv to set calling convention to

  • fn (OpaqueValue)
  • cc (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::setCallingConv()


3781
 
# File 'lib/llvm/core_ffi.rb', line 3781

attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [OpaqueValue, :uint], :void

.set_gc(fn, name) ⇒ nil

Define the garbage collector to use during code generation.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Functionllvm::Function::setGC()


3803
 
# File 'lib/llvm/core_ffi.rb', line 3803

attach_function :set_gc, :LLVMSetGC, [OpaqueValue, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3684
 
# File 'lib/llvm/core_ffi.rb', line 3684

attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3650
 
# File 'lib/llvm/core_ffi.rb', line 3650

attach_function :set_initializer, :LLVMSetInitializer, [OpaqueValue, OpaqueValue], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4657
 
# File 'lib/llvm/core_ffi.rb', line 4657

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4466
 
# File 'lib/llvm/core_ffi.rb', line 4466

attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [OpaqueValue, :uint, :uint], :void

.set_instruction_call_conv(instr, cc) ⇒ nil

Set the calling convention for a call instruction.

This expects an LLVMValueRef that corresponds to a llvm::CallInst or llvm::InvokeInst.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::CallInstllvm::CallInst::setCallingConv()
  • llvmllvm::InvokeInstllvm::InvokeInst::setCallingConv()


4423
 
# File 'lib/llvm/core_ffi.rb', line 4423

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [OpaqueValue, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3464
 
# File 'lib/llvm/core_ffi.rb', line 3464

attach_function :set_linkage, :LLVMSetLinkage, [OpaqueValue, :linkage], :void

.set_metadata(val, kind_id, node) ⇒ nil

Set metadata associated with an instruction value.

Parameters:

Returns:

  • (nil) 


4338
 
# File 'lib/llvm/core_ffi.rb', line 4338

attach_function :set_metadata, :LLVMSetMetadata, [OpaqueValue, :uint, OpaqueValue], :void

.set_module_inline_asm(m, asm) ⇒ nil

Set inline assembly for a module.

Parameters:

Returns:

  • (nil)

See Also:

  • Module::setModuleInlineAsm()


1154
 
# File 'lib/llvm/core_ffi.rb', line 1154

attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [OpaqueModule, :string], :void

.set_operand(user, index, val) ⇒ nil

Set an operand at a specific index in a llvm::User value.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Userllvm::User::setOperand()


2571
 
# File 'lib/llvm/core_ffi.rb', line 2571

attach_function :set_operand, :LLVMSetOperand, [OpaqueValue, :uint, OpaqueValue], :void

.set_param_alignment(arg, align) ⇒ nil

Set the alignment for a function parameter.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Argumentllvm::Argument::addAttr()
  • llvmllvm::AttrBuilderllvm::AttrBuilder::addAlignmentAttr()


3982
 
# File 'lib/llvm/core_ffi.rb', line 3982

attach_function :set_param_alignment, :LLVMSetParamAlignment, [OpaqueValue, :uint], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3481
 
# File 'lib/llvm/core_ffi.rb', line 3481

attach_function :set_section, :LLVMSetSection, [OpaqueValue, :string], :void

.set_tail_call(call_inst, is_tail_call) ⇒ nil

Set whether a call instruction is a tail call.

This only works on llvm::CallInst instructions.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::CallInstllvm::CallInst::setTailCall()


4491
 
# File 'lib/llvm/core_ffi.rb', line 4491

attach_function :set_tail_call, :LLVMSetTailCall, [OpaqueValue, :int], :void

.set_target(m, triple) ⇒ nil

Set the target triple for a module.

Parameters:

Returns:

  • (nil)

See Also:

  • Module::setTargetTriple()


1109
 
# File 'lib/llvm/core_ffi.rb', line 1109

attach_function :set_target, :LLVMSetTarget, [OpaqueModule, :string], :void

.set_target_machine_asm_verbosity(t, verbose_asm) ⇒ nil

Set the target machine’s ASM verbosity.

Parameters:

Returns:

  • (nil) 


575
 
# File 'lib/llvm/target_ffi.rb', line 575

attach_function :set_target_machine_asm_verbosity, :LLVMSetTargetMachineAsmVerbosity, [OpaqueTargetMachine, :int], :void

.set_thread_local(global_var, is_thread_local) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3667
 
# File 'lib/llvm/core_ffi.rb', line 3667

attach_function :set_thread_local, :LLVMSetThreadLocal, [OpaqueValue, :int], :void

.set_thread_local_mode(global_var, mode) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3701
 
# File 'lib/llvm/core_ffi.rb', line 3701

attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [OpaqueValue, :thread_local_mode], :void

.set_unnamed_addr(global, has_unnamed_addr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3532
 
# File 'lib/llvm/core_ffi.rb', line 3532

attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [OpaqueValue, :int], :void

.set_value_name(val, name) ⇒ nil

Set the string name of a value.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::setName()


1860
 
# File 'lib/llvm/core_ffi.rb', line 1860

attach_function :set_value_name, :LLVMSetValueName, [OpaqueValue, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3498
 
# File 'lib/llvm/core_ffi.rb', line 3498

attach_function :set_visibility, :LLVMSetVisibility, [OpaqueValue, :visibility], :void

.set_volatile(memory_access_inst, is_volatile) ⇒ nil

(Not documented)

Parameters:

  • memory_access_inst (OpaqueValue)
  • is_volatile (Integer)

Returns:

  • (nil) 


5285
 
# File 'lib/llvm/core_ffi.rb', line 5285

attach_function :set_volatile, :LLVMSetVolatile, [OpaqueValue, :int], :void

.shutdown ⇒ nil

Deallocate and destroy all ManagedStatic variables.

@see llvm::llvm_shutdown
@see ManagedStatic

Returns:

  • (nil) 


867
 
# File 'lib/llvm/core_ffi.rb', line 867

attach_function :shutdown, :LLVMShutdown, [], :void

.size_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2866
 
# File 'lib/llvm/core_ffi.rb', line 2866

attach_function :size_of, :LLVMSizeOf, [OpaqueType], OpaqueValue

.size_of_type_in_bits(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


215
 
# File 'lib/llvm/target_ffi.rb', line 215

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, :pointer], :ulong_long

.start_multithreaded ⇒ Integer

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.  This function always returns
LLVMIsMultithreaded().

Returns:

  • (Integer) 


5870
 
# File 'lib/llvm/core_ffi.rb', line 5870

attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int

.stop_multithreaded ⇒ nil

Deprecated: Multi-threading can only be enabled/disabled with the compile

time define LLVM_ENABLE_THREADS.

Returns:

  • (nil) 


5878
 
# File 'lib/llvm/core_ffi.rb', line 5878

attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void

.store_size_of_type(td, ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


224
 
# File 'lib/llvm/target_ffi.rb', line 224

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, :pointer], :ulong_long

.struct_create_named(c, name) ⇒ OpaqueType

Create an empty structure in a context having a specified name.

Parameters:

Returns:

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1623
 
# File 'lib/llvm/core_ffi.rb', line 1623

attach_function :struct_create_named, :LLVMStructCreateNamed, [OpaqueContext, :string], OpaqueType

.struct_set_body(struct_ty, element_types, element_count, packed) ⇒ nil

Set the contents of a structure type.

Parameters:

  • struct_ty (OpaqueType)
  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

  • (nil)

See Also:

  • llvmllvm::StructTypellvm::StructType::setBody()


1646
 
# File 'lib/llvm/core_ffi.rb', line 1646

attach_function :struct_set_body, :LLVMStructSetBody, [OpaqueType, :pointer, :uint, :int], :void

.struct_type(element_types, element_count, packed) ⇒ OpaqueType

Create a new structure type in the global context.

Parameters:

  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1612
 
# File 'lib/llvm/core_ffi.rb', line 1612

attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], OpaqueType

.struct_type_in_context(c, element_types, element_count, packed) ⇒ OpaqueType

Create a new structure type in a context.

A structure is specified by a list of inner elements/types and whether these can be packed together.

Parameters:

  • c (OpaqueContext)
  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:

See Also:

  • llvmllvm::StructTypellvm::StructType::create()


1600
 
# File 'lib/llvm/core_ffi.rb', line 1600

attach_function :struct_type_in_context, :LLVMStructTypeInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueType

.target_has_asm_backend(t) ⇒ Integer

Returns if the target as an ASM backend (required for emitting output)

Parameters:

Returns:

  • (Integer) 


497
 
# File 'lib/llvm/target_ffi.rb', line 497

attach_function :target_has_asm_backend, :LLVMTargetHasAsmBackend, [Target], :int

.target_has_jit(t) ⇒ Integer

Returns if the target has a JIT

Parameters:

Returns:

  • (Integer) 


481
 
# File 'lib/llvm/target_ffi.rb', line 481

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) 


489
 
# File 'lib/llvm/target_ffi.rb', line 489

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) 


589
 
# File 'lib/llvm/target_ffi.rb', line 589

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) 


601
 
# File 'lib/llvm/target_ffi.rb', line 601

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:

Returns:

  • (Integer)

See Also:

  • llvmllvm::Typellvm::Type::isSized()


1304
 
# File 'lib/llvm/core_ffi.rb', line 1304

attach_function :type_is_sized, :LLVMTypeIsSized, [OpaqueType], :int

.type_of(val) ⇒ OpaqueType

Obtain the type of a value.

Parameters:

Returns:

See Also:

  • llvmllvm::Valuellvm::Value::getType()


1839
 
# File 'lib/llvm/core_ffi.rb', line 1839

attach_function :type_of, :LLVMTypeOf, [OpaqueValue], OpaqueType

.value_as_basic_block(val) ⇒ OpaqueBasicBlock

Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

Parameters:

Returns:



4093
 
# File 'lib/llvm/core_ffi.rb', line 4093

attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [OpaqueValue], OpaqueBasicBlock

.value_is_basic_block(val) ⇒ Integer

Determine whether an LLVMValueRef is itself a basic block.

Parameters:

Returns:

  • (Integer) 


4085
 
# File 'lib/llvm/core_ffi.rb', line 4085

attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [OpaqueValue], :int

.vector_type(element_type, element_count) ⇒ OpaqueType

Create a vector type that contains a defined type and has a specific number of elements.

The created type will exist in the context thats its element type exists in.

Parameters:

  • element_type (OpaqueType)
  • element_count (Integer)

Returns:

See Also:

  • llvmllvm::VectorTypellvm::VectorType::get()


1771
 
# File 'lib/llvm/core_ffi.rb', line 1771

attach_function :vector_type, :LLVMVectorType, [OpaqueType, :uint], OpaqueType

.verify_function(fn, action) ⇒ Integer

Verifies that a single function is valid, taking the specified action. Useful

for debugging.

Parameters:

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_type ⇒ OpaqueType

These are similar to the above functions except they operate on the global context.

Returns:



1815
 
# File 'lib/llvm/core_ffi.rb', line 1815

attach_function :void_type, :LLVMVoidType, [], OpaqueType

.void_type_in_context(c) ⇒ OpaqueType

Create a void type in a context.

Parameters:

Returns:



1791
 
# File 'lib/llvm/core_ffi.rb', line 1791

attach_function :void_type_in_context, :LLVMVoidTypeInContext, [OpaqueContext], OpaqueType

.write_bitcode_to_fd(m, fd, should_close, unbuffered) ⇒ Integer

Writes a module to an open file descriptor. Returns 0 on success.

Parameters:

  • m (FFI::Pointer(ModuleRef))
  • fd (Integer)
  • should_close (Integer)
  • unbuffered (Integer)

Returns:

  • (Integer) 


96
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 96

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) 


85
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 85

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) 


106
 
# File 'lib/llvm/core/bitcode_ffi.rb', line 106

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [:pointer, :int], :int

.x86fp80_type ⇒ OpaqueType

(Not documented)

Returns:



1515
 
# File 'lib/llvm/core_ffi.rb', line 1515

attach_function :x86fp80_type, :LLVMX86FP80Type, [], OpaqueType

.x86fp80_type_in_context(c) ⇒ OpaqueType

Obtain a 80-bit floating point type (X87) from a context.

Parameters:

Returns:



1468
 
# File 'lib/llvm/core_ffi.rb', line 1468

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [OpaqueContext], OpaqueType

.x86mmx_type ⇒ OpaqueType

(Not documented)

Returns:



1829
 
# File 'lib/llvm/core_ffi.rb', line 1829

attach_function :x86mmx_type, :LLVMX86MMXType, [], OpaqueType

.x86mmx_type_in_context(c) ⇒ OpaqueType

Create a X86 MMX type in a context.

Parameters:

Returns:



1807
 
# File 'lib/llvm/core_ffi.rb', line 1807

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [OpaqueContext], OpaqueType

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_ASMmacroMD_NODEmacroMD_STRINGmacroUSERmacroCONSTANTmacroBLOCK_ADDRESSmacroCONSTANT_AGGREGATE_ZEROmacroCONSTANT_ARRAYmacroCONSTANT_DATA_SEQUENTIALmacroCONSTANT_DATA_ARRAYmacroCONSTANT_DATA_VECTORmacroCONSTANT_EXPRmacroCONSTANT_FPmacroCONSTANT_INTmacroCONSTANT_POINTER_NULLmacroCONSTANT_STRUCTmacroCONSTANT_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_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