Module: RLTK::CG::Bindings

Extended by:
FFI::Library
Defined in:
lib/rltk/cg/bindings.rb,
lib/rltk/cg/generated_bindings.rb

Overview

This module contains FFI bindings to LLVM.

Defined Under Namespace

Modules: TargetWrappers Classes: LibraryMismatch, MCJITCompilerOptions, OpInfo1, OpInfoSymbol1, OpaqueBasicBlock, OpaqueBuilder, OpaqueContext, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMCJITMemoryManager, OpaqueMemoryBuffer, OpaqueModule, OpaqueModuleProvider, OpaqueObjectFile, OpaquePassManager, OpaquePassManagerBuilder, OpaquePassRegistry, OpaqueRelocationIterator, OpaqueSectionIterator, OpaqueSymbolIterator, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, OpaqueType, OpaqueUse, OpaqueValue, Target

Constant Summary collapse

ARCHS =

List of architectures supported by LLVM.

[
	:Alpha,
	:ARM,
	:Blackfin,
	:CBackend,
	:CellSPU,
	:CppBackend,
	:MBlaze,
	:Mips,
	:MSP430,
	:PowerPC,
	:PTX,
	:Sparc,
	:SystemZ,
	:X86,
	:XCore
]
ASM_PARSERS =

List of assembly parsers.

[
	:ARM,
	:MBLaze,
	:X86
]
ASM_PRINTERS =

List of assembly printers.

[
	:Alpha,
	:ARM,
	:Blackfin,
	:CellSPU,
	:MBLaze,
	:Mips,
	:MSP430,
	:PowerPC,
	:PTX,
	:Sparc,
	:SystemZ,
	:X86,
	:XCore
]
DISASSEMBLER_VARIANT_KIND_NONE = 
0
DISASSEMBLER_VARIANT_KIND_ARM_HI16 = 
1
DISASSEMBLER_VARIANT_KIND_ARM_LO16 = 
2
DISASSEMBLER_REFERENCE_TYPE_IN_OUT_NONE = 
0
DISASSEMBLER_REFERENCE_TYPE_IN_BRANCH = 
1
DISASSEMBLER_REFERENCE_TYPE_IN_P_CREL_LOAD = 
2
DISASSEMBLER_REFERENCE_TYPE_OUT_SYMBOL_STUB = 
1
DISASSEMBLER_REFERENCE_TYPE_OUT_LIT_POOL_SYM_ADDR = 
2
DISASSEMBLER_REFERENCE_TYPE_OUT_LIT_POOL_CSTR_ADDR = 
3
DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_CF_STRING_REF = 
4
DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_MESSAGE = 
5
DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_MESSAGE_REF = 
6
DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_SELECTOR_REF = 
7
DISASSEMBLER_REFERENCE_TYPE_OUT_OBJC_CLASS_REF = 
8
DISASSEMBLER_OPTION_USE_MARKUP = 
1
DISASSEMBLER_OPTION_PRINT_IMM_HEX = 
2
DISASSEMBLER_OPTION_ASM_PRINTER_VARIANT = 
4
DISASSEMBLER_OPTION_SET_INSTR_COMMENTS = 
8
DISASSEMBLER_OPTION_PRINT_LATENCY = 
16

Class Method Summary collapse

Class Method Details

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


7080
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7080

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) 


7095
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7095

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) 


7106
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7106

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

._callback_op_info_callback_(pc, offset, size, tag_type, tag_buf) ⇒ FFI::Pointer(*Void)

The type for the operand information call back function. This is called to get the symbolic information for an operand of an instruction. Typically this is from the relocation information, symbol table, etc. That block of information is saved when the disassembler context is created and passed to the call back in the DisInfo parameter. The instruction containing operand is at the PC parameter. For some instruction sets, there can be more than one operand with symbolic information. To determine the symbolic operand information for each operand, the bytes for the specific operand in the instruction are specified by the Offset parameter and its byte widith is the size parameter. For instructions sets with fixed widths and one symbolic operand per instruction, the Offset parameter will be zero and Size parameter will be the instruction width. The information is returned in TagBuf and is Triple specific with its specific information defined by the value of TagType for that Triple. If symbolic information is returned the function returns 1, otherwise it returns 0.

This entry is only for documentation and no real method.

Parameters:

  • pc (Integer)
  • offset (Integer)
  • size (Integer)
  • tag_type (Integer)
  • tag_buf (FFI::Pointer(*Void))

Returns:

  • (FFI::Pointer(*Void)) 


5918
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5918

callback :op_info_callback, [:ulong, :ulong, :ulong, :int, :pointer], :pointer

._callback_symbol_lookup_callback_(reference_value, reference_type, reference_pc, reference_name) ⇒ FFI::Pointer(*Void)

The type for the symbol lookup function. This may be called by the disassembler for things like adding a comment for a PC plus a constant offset load instruction to use a symbol name instead of a load address value. It is passed the block information is saved when the disassembler context is created and the ReferenceValue to look up as a symbol. If no symbol is found for the ReferenceValue NULL is returned. The ReferenceType of the instruction is passed indirectly as is the PC of the instruction in ReferencePC. If the output reference can be determined its type is returned indirectly in ReferenceType along with ReferenceName if any, or that is set to NULL.

This entry is only for documentation and no real method.

Parameters:

  • reference_value (Integer)
  • reference_type (FFI::Pointer(*Uint64T))
  • reference_pc (Integer)
  • reference_name (FFI::Pointer(**CharS))

Returns:

  • (FFI::Pointer(*Void)) 


5990
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5990

callback :symbol_lookup_callback, [:ulong, :pointer, :ulong, :pointer], :pointer

._enum_atomic_ordering_ ⇒ Symbol

(Not documented)

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

Options:

:not_atomic
:unordered

< A load or store which is not atomic

:monotonic

< Lowest level of atomicity, guarantees

somewhat sane results, lock free.
:acquire

< guarantees that if you take all the

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

< Acquire provides a barrier of the sort

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

< Release is similar to Acquire, but with

a barrier of the sort necessary to release
a lock.

Returns:

  • (Symbol) 


756
757
758
759
760
761
762
763
 
# File 'lib/rltk/cg/generated_bindings.rb', line 756

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

._enum_atomic_rmw_bin_op_ ⇒ Symbol

(Not documented)

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

Options:

:xchg
:add

< Set the new value and return the one old

:sub

< Add a value and return the old one

:and_

< Subtract a value and return the old one

:nand

< And a value and return the old one

:or_

< Not-And a value and return the old one

:xor

< OR a value and return the old one

:max

< Xor a value and return the old one

:min

< Sets the value if it’s greater than the

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

< Sets the value if it’s Smaller than the

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

< Sets the value if it’s greater than the

original using an unsigned comparison and return
the old one

Returns:

  • (Symbol) 


802
803
804
805
806
807
808
809
810
811
812
813
814
 
# File 'lib/rltk/cg/generated_bindings.rb', line 802

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

._enum_attribute_ ⇒ Symbol

(Not documented)

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

Options:

:z_ext_attribute
:s_ext_attribute
:no_return_attribute
:in_reg_attribute
:struct_ret_attribute
:no_unwind_attribute
:no_alias_attribute
:by_val_attribute
:nest_attribute
:read_none_attribute
:read_only_attribute
:no_inline_attribute
:always_inline_attribute
:optimize_for_size_attribute
:stack_protect_attribute
:stack_protect_req_attribute
:alignment
:no_capture_attribute
:no_red_zone_attribute
:no_implicit_float_attribute
:naked_attribute
:inline_hint_attribute
:stack_alignment
:returns_twice
:uw_table

Returns:

  • (Symbol) 


184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/rltk/cg/generated_bindings.rb', line 184

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

._enum_byte_ordering_ ⇒ Symbol

(Not documented)

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

Options:

:big_endian
:little_endian

Returns:

  • (Symbol) 


6077
6078
6079
6080
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6077

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) 


571
572
573
574
575
576
577
578
579
 
# File 'lib/rltk/cg/generated_bindings.rb', line 571

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) 


6510
6511
6512
6513
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6510

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) 


6436
6437
6438
6439
6440
6441
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6436

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) 


6488
6489
6490
6491
6492
6493
6494
6495
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6488

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

._enum_int_predicate_ ⇒ Symbol

(Not documented)

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

Options:

:eq
:ne

< equal

:ugt

< not equal

:uge

< unsigned greater than

:ult

< unsigned greater or equal

:ule

< unsigned less than

:sgt

< unsigned less or equal

:sge

< signed greater than

:slt

< signed greater or equal

:sle

< signed less than

Returns:

  • (Symbol) 


610
611
612
613
614
615
616
617
618
619
620
621
 
# File 'lib/rltk/cg/generated_bindings.rb', line 610

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) 


696
697
698
699
 
# File 'lib/rltk/cg/generated_bindings.rb', line 696

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

< Function to be imported from DLL

:external_weak

< Function to be accessible from DLL

:ghost

< ExternalWeak linkage description

:common

< Obsolete

:linker_private

< Tentative definitions

:linker_private_weak

< Like Private, but linker removes.

Returns:

  • (Symbol) 


507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'lib/rltk/cg/generated_bindings.rb', line 507

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

._enum_linker_mode_ ⇒ Symbol

(Not documented)

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

Options:

:linker_destroy_source

Returns:

  • (Symbol) 


7254
7255
7256
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7254

enum :linker_mode, [
  :linker_destroy_source, 0
]

._enum_llvm_lto_status_ ⇒ Symbol

/// This should map exactly onto the C++ enumerator LTOStatus.

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

Options:

:unknown
:opt_success
:read_success
:read_failure
:write_failure
:no_target
:no_work
:module_merge_failure
:asm_failure
:null_object

// Added C-specific error codes

Returns:

  • (Symbol) 


7302
7303
7304
7305
7306
7307
7308
7309
7310
7311
7312
7313
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7302

enum :llvm_lto_status, [
  :unknown, 0,
  :opt_success, 1,
  :read_success, 2,
  :read_failure, 3,
  :write_failure, 4,
  :no_target, 5,
  :no_work, 6,
  :module_merge_failure, 7,
  :asm_failure, 8,
  :null_object, 9
]

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


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
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
 
# File 'lib/rltk/cg/generated_bindings.rb', line 339

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) 


664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
 
# File 'lib/rltk/cg/generated_bindings.rb', line 664

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) 


6460
6461
6462
6463
6464
6465
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6460

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) 


720
721
722
723
724
725
726
 
# File 'lib/rltk/cg/generated_bindings.rb', line 720

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) 


442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
 
# File 'lib/rltk/cg/generated_bindings.rb', line 442

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

._enum_verifier_failure_action_ ⇒ Symbol

(Not documented)

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

Options:

:abort_process
:print_message

verifier will print to stderr and abort()

:return_status

verifier will print to stderr and return 1

Returns:

  • (Symbol) 


5752
5753
5754
5755
5756
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5752

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) 


542
543
544
545
546
 
# File 'lib/rltk/cg/generated_bindings.rb', line 542

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

.abi_alignment_of_type(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeABISize.

Parameters:

Returns:

  • (Integer) 


6331
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6331

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

.abi_size_of_type(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeAllocSize.

Parameters:

Returns:

  • (Integer) 


6321
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6321

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

.add_aggressive_dce_pass(pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7843
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7843

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

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

This group contains function that operate on global alias values.

@{

Parameters:

Returns:

See Also:

  • llvmllvm::GlobalAlias


3592
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3592

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

.add_always_inliner_pass(pm) ⇒ nil

See llvm::createAlwaysInlinerPass function.

Parameters:

Returns:

  • (nil) 


7667
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7667

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

.add_argument_promotion_pass(pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7627
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7627

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

.add_attribute(arg, pa) ⇒ nil

Add an attribute to a function argument.

Parameters:

Returns:

  • (nil)

See Also:

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


3808
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3808

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

.add_basic_alias_analysis_pass(pm) ⇒ nil

See llvm::createBasicAliasAnalysisPass function

Parameters:

Returns:

  • (nil) 


8092
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8092

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

.add_bb_vectorize_pass(pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


8100
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8100

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

.add_binding(func, args, returns) ⇒ Object

A wrapper class for FFI::Library.attach_function

Parameters:

  • func (Symbol) —

    Function name.

  • args (Array<Object>) —

    Argument types for FFI::Library.attach_function.

  • returns (Object) —

    Return type for FFI::Library.attach_function.



129
130
131
 
# File 'lib/rltk/cg/bindings.rb', line 129

def self.add_binding(func, args, returns)
	attach_function(get_bname(func.to_s[4..-1]), func, args, returns)
end

.add_case(switch, on_val, dest) ⇒ nil

Add a case to the switch instruction

Parameters:

Returns:

  • (nil) 


4635
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4635

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

.add_cfg_simplification_pass(pm) ⇒ nil

See llvm::createCFGSimplificationPass function.

Parameters:

Returns:

  • (nil) 


7851
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7851

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

.add_clause(landing_pad, clause_val) ⇒ nil

Add a catch or filter clause to the landingpad instruction

Parameters:

Returns:

  • (nil) 


4653
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4653

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

.add_constant_merge_pass(pm) ⇒ nil

See llvm::createConstantMergePass function.

Parameters:

Returns:

  • (nil) 


7635
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7635

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

.add_constant_propagation_pass(pm) ⇒ nil

See llvm::createConstantPropagationPass function.

Parameters:

Returns:

  • (nil) 


8036
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8036

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

.add_correlated_value_propagation_pass(pm) ⇒ nil

See llvm::createCorrelatedValuePropagationPass function

Parameters:

Returns:

  • (nil) 


8060
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8060

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

.add_dead_arg_elimination_pass(pm) ⇒ nil

See llvm::createDeadArgEliminationPass function.

Parameters:

Returns:

  • (nil) 


7643
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7643

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

.add_dead_store_elimination_pass(pm) ⇒ nil

See llvm::createDeadStoreEliminationPass function.

Parameters:

Returns:

  • (nil) 


7859
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7859

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

.add_demote_memory_to_register_pass(pm) ⇒ nil

See llvm::demotePromoteMemoryToRegisterPass function.

Parameters:

Returns:

  • (nil) 


8044
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8044

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

.add_destination(indirect_br, dest) ⇒ nil

Add a destination to the indirectbr instruction

Parameters:

Returns:

  • (nil) 


4644
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4644

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

.add_early_cse_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

Returns:

  • (nil) 


8068
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8068

attach_function :add_early_cse_pass, :LLVMAddEarlyCSEPass, [OpaquePassManager], :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()


1120
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1120

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


3671
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3671

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

.add_function_attrs_pass(pm) ⇒ nil

See llvm::createFunctionAttrsPass function.

Parameters:

Returns:

  • (nil) 


7651
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7651

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

.add_function_inlining_pass(pm) ⇒ nil

See llvm::createFunctionInliningPass function.

Parameters:

Returns:

  • (nil) 


7659
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7659

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

.add_global(m, ty, name) ⇒ OpaqueValue

This group contains functions that operate on global variable values.

@{

Parameters:

Returns:

See Also:

  • llvmllvm::GlobalVariable


3430
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3430

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

.add_global_dce_pass(pm) ⇒ nil

See llvm::createGlobalDCEPass function.

Parameters:

Returns:

  • (nil) 


7675
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7675

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

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

(Not documented)

Parameters:

Returns:



3441
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3441

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) 


7057
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7057

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

.add_global_optimizer_pass(pm) ⇒ nil

See llvm::createGlobalOptimizerPass function.

Parameters:

Returns:

  • (nil) 


7683
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7683

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

.add_gvn_pass(pm) ⇒ nil

See llvm::createGVNPass function.

Parameters:

Returns:

  • (nil) 


7867
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7867

attach_function :add_gvn_pass, :LLVMAddGVNPass, [OpaquePassManager], :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) 


4371
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4371

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

.add_ind_var_simplify_pass(pm) ⇒ nil

See llvm::createIndVarSimplifyPass function.

Parameters:

Returns:

  • (nil) 


7875
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7875

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

.add_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4303
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4303

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

.add_instruction_combining_pass(pm) ⇒ nil

See llvm::createInstructionCombiningPass function.

Parameters:

Returns:

  • (nil) 


7883
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7883

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

.add_internalize_pass(opaque_pass_manager, all_but_main) ⇒ nil

See llvm::createInternalizePass function.

Parameters:

Returns:

  • (nil) 


7716
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7716

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

.add_ip_constant_propagation_pass(pm) ⇒ nil

See llvm::createIPConstantPropagationPass function.

Parameters:

Returns:

  • (nil) 


7691
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7691

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

.add_ipsccp_pass(pm) ⇒ nil

See llvm::createIPSCCPPass function.

Parameters:

Returns:

  • (nil) 


7707
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7707

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

.add_jump_threading_pass(pm) ⇒ nil

See llvm::createJumpThreadingPass function.

Parameters:

Returns:

  • (nil) 


7891
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7891

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

.add_licm_pass(pm) ⇒ nil

See llvm::createLICMPass function.

Parameters:

Returns:

  • (nil) 


7899
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7899

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

.add_loop_deletion_pass(pm) ⇒ nil

See llvm::createLoopDeletionPass function.

Parameters:

Returns:

  • (nil) 


7907
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7907

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

.add_loop_idiom_pass(pm) ⇒ nil

See llvm::createLoopIdiomPass function

Parameters:

Returns:

  • (nil) 


7915
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7915

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

.add_loop_reroll_pass(pm) ⇒ nil

See llvm::createLoopRerollPass function.

Parameters:

Returns:

  • (nil) 


7931
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7931

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

.add_loop_rotate_pass(pm) ⇒ nil

See llvm::createLoopRotatePass function.

Parameters:

Returns:

  • (nil) 


7923
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7923

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

.add_loop_unroll_pass(pm) ⇒ nil

See llvm::createLoopUnrollPass function.

Parameters:

Returns:

  • (nil) 


7939
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7939

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

.add_loop_unswitch_pass(pm) ⇒ nil

See llvm::createLoopUnswitchPass function.

Parameters:

Returns:

  • (nil) 


7947
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7947

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

.add_loop_vectorize_pass(pm) ⇒ nil

See llvm::createLoopVectorizePass function.

Parameters:

Returns:

  • (nil) 


8108
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8108

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

.add_lower_expect_intrinsic_pass(pm) ⇒ nil

See llvm::createLowerExpectIntrinsicPass function

Parameters:

Returns:

  • (nil) 


8076
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8076

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

.add_mem_cpy_opt_pass(pm) ⇒ nil

See llvm::createMemCpyOptPass function.

Parameters:

Returns:

  • (nil) 


7955
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7955

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

.add_module(ee, m) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6989
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6989

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

.add_module_provider(ee, mp) ⇒ nil

Deprecated: Use LLVMAddModule instead.

Parameters:

Returns:

  • (nil) 


6998
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6998

attach_function :add_module_provider, :LLVMAddModuleProvider, [OpaqueExecutionEngine, OpaqueModuleProvider], :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()


1108
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1108

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

.add_partially_inline_lib_calls_pass(pm) ⇒ nil

See llvm::createPartiallyInlineLibCallsPass function.

Parameters:

Returns:

  • (nil) 


7963
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7963

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

.add_promote_memory_to_register_pass(pm) ⇒ nil

See llvm::createPromoteMemoryToRegisterPass function.

Parameters:

Returns:

  • (nil) 


7971
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7971

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

.add_prune_eh_pass(pm) ⇒ nil

See llvm::createPruneEHPass function.

Parameters:

Returns:

  • (nil) 


7699
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7699

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

.add_reassociate_pass(pm) ⇒ nil

See llvm::createReassociatePass function.

Parameters:

Returns:

  • (nil) 


7979
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7979

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

.add_scalar_repl_aggregates_pass(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

Returns:

  • (nil) 


7995
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7995

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

.add_scalar_repl_aggregates_pass_ssa(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

Returns:

  • (nil) 


8003
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8003

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

.add_scalar_repl_aggregates_pass_with_threshold(pm, threshold) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

Returns:

  • (nil) 


8012
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8012

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

.add_sccp_pass(pm) ⇒ nil

See llvm::createSCCPPass function.

Parameters:

Returns:

  • (nil) 


7987
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7987

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

.add_simplify_lib_calls_pass(pm) ⇒ nil

See llvm::createSimplifyLibCallsPass function.

Parameters:

Returns:

  • (nil) 


8020
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8020

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

.add_slp_vectorize_pass(pm) ⇒ nil

See llvm::createSLPVectorizerPass function.

Parameters:

Returns:

  • (nil) 


8116
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8116

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

.add_strip_dead_prototypes_pass(pm) ⇒ nil

See llvm::createStripDeadPrototypesPass function.

Parameters:

Returns:

  • (nil) 


7724
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7724

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

.add_strip_symbols_pass(pm) ⇒ nil

See llvm::createStripSymbolsPass function.

Parameters:

Returns:

  • (nil) 


7732
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7732

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

.add_tail_call_elimination_pass(pm) ⇒ nil

See llvm::createTailCallEliminationPass function.

Parameters:

Returns:

  • (nil) 


8028
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8028

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

.add_target_data(td, pm) ⇒ nil

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

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

Parameters:

Returns:

  • (nil) 


6198
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6198

attach_function :add_target_data, :LLVMAddTargetData, [OpaqueTargetData, OpaquePassManager], :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()


3682
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3682

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

.add_target_library_info(tli, pm) ⇒ nil

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

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

Parameters:

Returns:

  • (nil) 


6209
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6209

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

.add_type_based_alias_analysis_pass(pm) ⇒ nil

See llvm::createTypeBasedAliasAnalysisPass function

Parameters:

Returns:

  • (nil) 


8084
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8084

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

.add_verifier_pass(pm) ⇒ nil

See llvm::createVerifierPass function.

Parameters:

Returns:

  • (nil) 


8052
 
# File 'lib/rltk/cg/generated_bindings.rb', line 8052

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

.align_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2751
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2751

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


4073
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4073

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


4061
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4061

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


1611
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1611

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

.attach_function(name, *_) ⇒ Object 



9
10
11
12
13
 
# File 'lib/rltk/cg/generated_bindings.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:



3934
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3934

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

.block_address(f, bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3317
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3317

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

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

(Not documented)

Parameters:

Returns:



4904
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4904

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

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

Arithmetic

Parameters:

Returns:



4673
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4673

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:



5285
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5285

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:



4541
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4541

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

.build_alloca(opaque_builder, ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5030
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5030

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

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

(Not documented)

Parameters:

Returns:



4915
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4915

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

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

(Not documented)

Parameters:

Returns:



5041
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5041

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

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

(Not documented)

Parameters:

Returns:



5020
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5020

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:



5534
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5534

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:



4949
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4949

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:



5274
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5274

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

.build_br(opaque_builder, dest) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4550
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4550

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

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

(Not documented)

Parameters:

Returns:



5409
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5409

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

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

(Not documented)

Parameters:

Returns:



5330
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5330

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

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

(Not documented)

Parameters:

Returns:



4561
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4561

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:



4827
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4827

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:



5443
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5443

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:



5478
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5478

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

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

(Not documented)

Parameters:

Returns:



4706
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4706

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:



5387
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5387

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:



4838
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4838

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

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

(Not documented)

Parameters:

Returns:



4794
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4794

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

.build_f_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4989
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4989

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

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

(Not documented)

Parameters:

Returns:



4871
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4871

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

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

(Not documented)

Parameters:

Returns:



4750
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4750

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

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

(Not documented)

Parameters:

Returns:



5363
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5363

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:



5241
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5241

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:



5197
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5197

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:



5186
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5186

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:



5230
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5230

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

.build_free(opaque_builder, pointer_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5050
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5050

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

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

(Not documented)

Parameters:

Returns:



5082
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5082

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

.build_global_string(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5115
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5115

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

.build_global_string_ptr(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5125
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5125

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

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

Comparisons

Parameters:

Returns:



5375
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5375

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:



5094
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5094

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:



4582
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4582

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:



5455
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5455

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:



5490
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5490

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:



5352
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5352

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:



5263
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5263

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:



4596
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4596

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:



5510
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5510

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

.build_is_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5500
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5500

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

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

(Not documented)

Parameters:

Returns:



4893
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4893

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:



4608
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4608

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

.build_load(opaque_builder, pointer_val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5060
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5060

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

.build_malloc(opaque_builder, ty, name) ⇒ OpaqueValue

Memory

Parameters:

Returns:



5009
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5009

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

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

(Not documented)

Parameters:

Returns:



4761
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4761

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

.build_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4959
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4959

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

.build_not(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4999
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4999

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

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

(Not documented)

Parameters:

Returns:



4684
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4684

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

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

(Not documented)

Parameters:

Returns:



4772
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4772

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

.build_nsw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4969
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4969

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

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

(Not documented)

Parameters:

Returns:



4728
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4728

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

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

(Not documented)

Parameters:

Returns:



4695
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4695

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

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

(Not documented)

Parameters:

Returns:



4783
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4783

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

.build_nuw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4979
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4979

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

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

(Not documented)

Parameters:

Returns:



4739
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4739

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

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

(Not documented)

Parameters:

Returns:



4926
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4926

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

.build_phi(opaque_builder, ty, name) ⇒ OpaqueValue

Miscellaneous instructions

Parameters:

Returns:



5397
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5397

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

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

(Not documented)

Parameters:

Returns:



5341
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5341

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

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

(Not documented)

Parameters:

Returns:



5521
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5521

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:



5252
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5252

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

.build_resume(b, exn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4617
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4617

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

.build_ret(opaque_builder, v) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4531
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4531

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

.build_ret_void(opaque_builder) ⇒ OpaqueValue

Terminators

Parameters:

Returns:



4522
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4522

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

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

(Not documented)

Parameters:

Returns:



4816
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4816

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:



5175
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5175

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:



5307
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5307

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:



4860
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4860

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

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

(Not documented)

Parameters:

Returns:



5421
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5421

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

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

(Not documented)

Parameters:

Returns:



4882
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4882

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

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

(Not documented)

Parameters:

Returns:



5467
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5467

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:



5219
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5219

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

.build_store(opaque_builder, val, ptr) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



5070
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5070

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

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

(Not documented)

Parameters:

Returns:



5105
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5105

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

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

(Not documented)

Parameters:

Returns:



4717
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4717

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

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

(Not documented)

Parameters:

Returns:



4572
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4572

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

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

Casts

Parameters:

Returns:



5153
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5153

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:



5318
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5318

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:



4805
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4805

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

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

(Not documented)

Parameters:

Returns:



4849
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4849

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:



5208
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5208

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

.build_unreachable(opaque_builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4625
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4625

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

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

(Not documented)

Parameters:

Returns:



5432
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5432

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

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

(Not documented)

Parameters:

Returns:



4937
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4937

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

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

(Not documented)

Parameters:

Returns:



5164
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5164

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:



5296
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5296

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

.byte_order(td) ⇒ Symbol from _enum_byte_ordering_

Returns the byte order of a target, either LLVMBigEndian or

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

Parameters:

Returns:



6229
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6229

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

.call_frame_alignment_of_type(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeABISize.

Parameters:

Returns:

  • (Integer) 


6341
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6341

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

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4461
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4461

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

.const_a_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3044
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3044

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

.const_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2808
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2808

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

.const_addr_space_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3181
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3181

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


2497
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2497

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

.const_and(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2979
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2979

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


2706
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2706

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

.const_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3172
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3172

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

.const_exact_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2934
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2934

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

.const_extract_element(vector_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3255
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3255

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:



3285
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3285

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

.const_f_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2835
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2835

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

.const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3017
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3017

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

.const_f_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2943
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2943

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

.const_f_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2907
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2907

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

.const_f_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2791
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2791

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

.const_f_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2970
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2970

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

.const_f_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2871
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2871

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

.const_fp_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3236
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3236

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

.const_fp_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3109
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3109

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

.const_fp_to_si(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3145
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3145

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

.const_fp_to_ui(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3136
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3136

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

.const_fp_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3100
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3100

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:



3054
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3054

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

.const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3007
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3007

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:



3064
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3064

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:



3308
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3308

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:



3265
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3265

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:



3296
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3296

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


2544
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2544

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

.const_int_cast(constant_val, to_type, is_signed) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3227
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3227

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


2637
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2637

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


2627
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2627

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

Returns:

See Also:

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


2556
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2556

attach_function :const_int_of_arbitrary_precision, :LLVMConstIntOfArbitraryPrecision, [OpaqueType, :uint, :char], 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()


2572
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2572

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


2586
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2586

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:



3163
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3163

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

.const_l_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3035
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3035

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

.const_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2880
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2880

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


2718
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2718

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

.const_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2767
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2767

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

.const_not(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2799
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2799

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

.const_nsw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2817
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2817

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

.const_nsw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2889
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2889

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

.const_nsw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2775
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2775

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

.const_nsw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2853
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2853

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


2484
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2484

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

.const_nuw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2826
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2826

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

.const_nuw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2898
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2898

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

.const_nuw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2783
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2783

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

.const_nuw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2862
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2862

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

.const_or(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2988
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2988

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

.const_pointer_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3217
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3217

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:



2526
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2526

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

.const_ptr_to_int(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3154
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3154

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:



2595
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2595

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:



2607
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2607

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:



2617
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2617

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:



2925
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2925

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

.const_s_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3082
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3082

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

.const_s_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3199
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3199

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

.const_s_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2961
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2961

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

.const_select(constant_condition, constant_if_true, constant_if_false) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3246
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3246

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

.const_shl(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3026
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3026

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

.const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3275
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3275

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

.const_si_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3127
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3127

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


2666
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2666

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


2650
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2650

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


2694
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2694

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


2679
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2679

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

.const_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2844
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2844

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

.const_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3073
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3073

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

.const_trunc_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3208
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3208

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

.const_u_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2916
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2916

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

.const_u_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2952
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2952

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

.const_ui_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3118
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3118

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


2729
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2729

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

.const_xor(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2997
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2997

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

.const_z_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3091
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3091

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

.const_z_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3190
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3190

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:



886
 
# File 'lib/rltk/cg/generated_bindings.rb', line 886

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) 


904
 
# File 'lib/rltk/cg/generated_bindings.rb', line 904

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

.copy_string_rep_of_target_data(td) ⇒ String

Converts target data to a target layout string. The string must be disposed

with LLVMDisposeMessage.
See the constructor llvm::DataLayout::DataLayout.

Parameters:

Returns:

  • (String) 


6219
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6219

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) 


3985
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3985

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) 


4379
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4379

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

.count_param_types(function_ty) ⇒ Integer

Obtain the number of parameters this function accepts.

Parameters:

Returns:

  • (Integer) 


1460
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1460

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


3711
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3711

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


1549
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1549

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

.create_builder ⇒ OpaqueBuilder

(Not documented)

Returns:



4417
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4417

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:



4410
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4410

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

.create_disasm(triple_name, dis_info, tag_type, get_op_info, symbol_look_up) ⇒ FFI::Pointer(DisasmContextRef)

Create a disassembler for the TripleName. Symbolic disassembly is supported by passing a block of information in the DisInfo parameter and specifying the TagType and callback functions as described above. These can all be passed as NULL. If successful, this returns a disassembler context. If not, it returns NULL. This function is equivalent to calling LLVMCreateDisasmCPU() with an empty CPU name.

Parameters:

Returns:

  • (FFI::Pointer(DisasmContextRef)) 


6007
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6007

attach_function :create_disasm, :LLVMCreateDisasm, [:string, :pointer, :int, :op_info_callback, :symbol_lookup_callback], :pointer

.create_disasm_cpu(triple, cpu, dis_info, tag_type, get_op_info, symbol_look_up) ⇒ FFI::Pointer(DisasmContextRef)

Create a disassembler for the TripleName and a specific CPU. Symbolic disassembly is supported by passing a block of information in the DisInfo parameter and specifying the TagType and callback functions as described above. These can all be passed * as NULL. If successful, this returns a disassembler context. If not, it returns NULL.

Parameters:

Returns:

  • (FFI::Pointer(DisasmContextRef)) 


6024
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6024

attach_function :create_disasm_cpu, :LLVMCreateDisasmCPU, [:string, :string, :pointer, :int, :op_info_callback, :symbol_lookup_callback], :pointer

.create_execution_engine(out_ee, mp, out_error) ⇒ Integer

Deprecated: Use LLVMCreateExecutionEngineForModule instead.

Parameters:

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

Returns:

  • (Integer) 


6903
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6903

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

.create_execution_engine_for_module(out_ee, m, out_error) ⇒ Integer

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

Parameters:

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

Returns:

  • (Integer) 


6837
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6837

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

.create_function_pass_manager(mp) ⇒ OpaquePassManager

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

Returns:



5653
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5653

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:



5645
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5645

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

.create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

Returns:



6785
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6785

attach_function :create_generic_value_of_float, :LLVMCreateGenericValueOfFloat, [OpaqueType, :double], OpaqueGenericValue

.create_generic_value_of_int(ty, n, is_signed) ⇒ OpaqueGenericValue

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

Parameters:

Returns:



6768
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6768

attach_function :create_generic_value_of_int, :LLVMCreateGenericValueOfInt, [OpaqueType, :ulong_long, :int], OpaqueGenericValue

.create_generic_value_of_pointer(p) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

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

Returns:



6776
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6776

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 (OpaqueModuleProvider)
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


6913
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6913

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

.create_interpreter_for_module(out_interp, m, out_error) ⇒ Integer

(Not documented)

Parameters:

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

Returns:

  • (Integer) 


6847
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6847

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

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

Deprecated: Use LLVMCreateJITCompilerForModule instead.

Parameters:

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

Returns:

  • (Integer) 


6924
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6924

attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, OpaqueModuleProvider, :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 (OpaqueModule)
  • opt_level (Integer)
  • out_error (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


6858
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6858

attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, OpaqueModule, :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:

Returns:

  • (Integer) 


6893
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6893

attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, OpaqueModule, 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) 


5563
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5563

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:



5583
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5583

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:



5593
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5593

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) 


5572
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5572

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

.create_message(message) ⇒ String

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

Parameters:

  • message (String)

Returns:

  • (String) 


839
 
# File 'lib/rltk/cg/generated_bindings.rb', line 839

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:



5543
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5543

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

.create_object_file(mem_buf) ⇒ OpaqueObjectFile

// ObjectFile creation

Parameters:

Returns:



7374
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7374

attach_function :create_object_file, :LLVMCreateObjectFile, [OpaqueMemoryBuffer], OpaqueObjectFile

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



5634
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5634

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:



7126
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7126

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

Creates target data from a target layout string.

See the constructor llvm::DataLayout::DataLayout.

Parameters:

  • string_rep (String)

Returns:



6187
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6187

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:



6603
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6603

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


4112
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4112

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


3602
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3602

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

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3490
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3490

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

.disasm_dispose(dc) ⇒ nil

Dispose of a disassembler context.

Parameters:

  • dc (FFI::Pointer(DisasmContextRef))

Returns:

  • (nil) 


6042
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6042

attach_function :disasm_dispose, :LLVMDisasmDispose, [:pointer], :void

.disasm_instruction(dc, bytes, bytes_size, pc, out_string, out_string_size) ⇒ Integer

Disassemble a single instruction using the disassembler context specified in the parameter DC. The bytes of the instruction are specified in the parameter Bytes, and contains at least BytesSize number of bytes. The instruction is at the address specified by the PC parameter. If a valid instruction can be disassembled, its string is returned indirectly in OutString whose size is specified in the parameter OutStringSize. This function returns the number of bytes in the instruction or zero if there was no valid instruction.

Parameters:

  • dc (FFI::Pointer(DisasmContextRef))
  • bytes (FFI::Pointer(*Uint8T))
  • bytes_size (Integer)
  • pc (Integer)
  • out_string (String)
  • out_string_size (Integer)

Returns:

  • (Integer) 


6062
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6062

attach_function :disasm_instruction, :LLVMDisasmInstruction, [:pointer, :pointer, :ulong, :ulong, :string, :ulong], :ulong

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4488
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4488

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

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6932
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6932

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

.dispose_generic_value(gen_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6827
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6827

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

.dispose_mcjit_memory_manager(mm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7134
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7134

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

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


5617
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5617

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

.dispose_message(message) ⇒ nil

(Not documented)

Parameters:

  • message (String)

Returns:

  • (nil) 


847
 
# File 'lib/rltk/cg/generated_bindings.rb', line 847

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) 


960
 
# File 'lib/rltk/cg/generated_bindings.rb', line 960

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

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

Returns:

  • (nil) 


5551
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5551

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

.dispose_object_file(object_file) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7382
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7382

attach_function :dispose_object_file, :LLVMDisposeObjectFile, [OpaqueObjectFile], :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) 


5707
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5707

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

.dispose_relocation_iterator(ri) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7514
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7514

attach_function :dispose_relocation_iterator, :LLVMDisposeRelocationIterator, [OpaqueRelocationIterator], :void

.dispose_section_iterator(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7398
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7398

attach_function :dispose_section_iterator, :LLVMDisposeSectionIterator, [OpaqueSectionIterator], :void

.dispose_symbol_iterator(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7440
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7440

attach_function :dispose_symbol_iterator, :LLVMDisposeSymbolIterator, [OpaqueSymbolIterator], :void

.dispose_target_data(td) ⇒ nil

Deallocates a TargetData.

See the destructor llvm::DataLayout::~DataLayout.

Parameters:

Returns:

  • (nil) 


6392
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6392

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

.dispose_target_machine(t) ⇒ nil

Dispose the LLVMTargetMachineRef instance generated by

LLVMCreateTargetMachine.

Parameters:

Returns:

  • (nil) 


6612
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6612

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

.double_type ⇒ OpaqueType

(Not documented)

Returns:



1401
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1401

attach_function :double_type, :LLVMDoubleType, [], OpaqueType

.double_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



1353
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1353

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


1012
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1012

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


1217
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1217

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


1763
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1763

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

.element_at_offset(td, struct_ty, offset) ⇒ Integer

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

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

Returns:

  • (Integer) 


6372
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6372

attach_function :element_at_offset, :LLVMElementAtOffset, [OpaqueTargetData, OpaqueType, :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) 


876
 
# File 'lib/rltk/cg/generated_bindings.rb', line 876

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) 


5697
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5697

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

.find_function(ee, name, out_fn) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7030
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7030

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

.float_type ⇒ OpaqueType

(Not documented)

Returns:



1394
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1394

attach_function :float_type, :LLVMFloatType, [], OpaqueType

.float_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



1345
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1345

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

.fp128_type ⇒ OpaqueType

(Not documented)

Returns:



1415
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1415

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:



1370
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1370

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

.free_machine_code_for_function(ee, f) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6980
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6980

attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, OpaqueValue], :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:



1436
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1436

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

.generic_value_int_width(gen_val_ref) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


6793
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6793

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

.generic_value_to_float(ty_ref, gen_val) ⇒ Float

(Not documented)

Parameters:

Returns:



6819
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6819

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

.generic_value_to_int(gen_val, is_signed) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


6802
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6802

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


6810
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6810

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::LoadInstllvm::LoadInst::getAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::getAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::getAlignment()


3402
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3402

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


1623
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1623

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

.get_attribute(arg) ⇒ Symbol from _enum_attribute_

Get an attribute from a function argument.

Parameters:

Returns:



3827
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3827

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


3960
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3960

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


3975
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3975

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) 


3999
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3999

attach_function :get_basic_blocks, :LLVMGetBasicBlocks, [OpaqueValue, :pointer], :void

.get_bitcode_module(mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (OpaqueMemoryBuffer)
  • out_m (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


5839
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5839

attach_function :get_bitcode_module, :LLVMGetBitcodeModule, [OpaqueMemoryBuffer, :pointer, :pointer], :int

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

Reads a module from the specified path, returning via the OutMP parameter

a module provider which performs lazy deserialization. Returns 0 on success.
Optionally returns a human-readable error message via OutMessage.

Parameters:

Returns:

  • (Integer) 


5829
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5829

attach_function :get_bitcode_module_in_context, :LLVMGetBitcodeModuleInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int

.get_bitcode_module_provider(mem_buf, out_mp, out_message) ⇒ Integer

Deprecated: Use LLVMGetBitcodeModule instead.

Parameters:

  • mem_buf (OpaqueMemoryBuffer)
  • out_mp (FFI::Pointer(*ModuleProviderRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


5860
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5860

attach_function :get_bitcode_module_provider, :LLVMGetBitcodeModuleProvider, [OpaqueMemoryBuffer, :pointer, :pointer], :int

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

Deprecated: Use LLVMGetBitcodeModuleInContext instead.

Parameters:

Returns:

  • (Integer) 


5850
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5850

attach_function :get_bitcode_module_provider_in_context, :LLVMGetBitcodeModuleProviderInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int

.get_bname(name) ⇒ Symbol

Converts a CamelCase string into an underscored string.

Parameters:

  • name (#to_s) —

    CamelCase string.

Returns:

  • (Symbol) —

    Underscored string.



117
118
119
120
121
122
 
# File 'lib/rltk/cg/bindings.rb', line 117

def self.get_bname(name)
	name.to_s.
		gsub(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2').
		gsub(/([a-z\d])([A-Z])/,'\1_\2').
		downcase.to_sym
end

.get_buffer_size(mem_buf) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


5609
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5609

attach_function :get_buffer_size, :LLVMGetBufferSize, [OpaqueMemoryBuffer], :ulong

.get_buffer_start(mem_buf) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


5601
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5601

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.


2743
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2743

attach_function :get_const_opcode, :LLVMGetConstOpcode, [OpaqueValue], :opcode

.get_current_debug_location(builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



4505
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4505

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


970
 
# File 'lib/rltk/cg/generated_bindings.rb', line 970

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) 


6701
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6701

attach_function :get_default_target_triple, :LLVMGetDefaultTargetTriple, [], :string

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


1597
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1597

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


4049
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4049

attach_function :get_entry_basic_block, :LLVMGetEntryBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_execution_engine_target_data(ee) ⇒ OpaqueTargetData

(Not documented)

Parameters:

Returns:



7047
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7047

attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [OpaqueExecutionEngine], OpaqueTargetData

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


4012
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4012

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


1143
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1143

attach_function :get_first_function, :LLVMGetFirstFunction, [OpaqueModule], OpaqueValue

.get_first_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3458
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3458

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:



4158
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4158

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


3765
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3765

attach_function :get_first_param, :LLVMGetFirstParam, [OpaqueValue], OpaqueValue

.get_first_target ⇒ Target

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

Returns:



6520
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6520

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


2408
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2408

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


3692
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3692

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


3624
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3624

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


3649
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3649

attach_function :get_gc, :LLVMGetGC, [OpaqueValue], :string

.get_global_context ⇒ OpaqueContext

Obtain the global context instance.

Returns:



893
 
# File 'lib/rltk/cg/generated_bindings.rb', line 893

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


3332
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3332

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:



5625
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5625

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


4265
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4265

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:



4397
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4397

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:



4388
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4388

attach_function :get_incoming_value, :LLVMGetIncomingValue, [OpaqueValue, :uint], OpaqueValue

.get_initializer(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3498
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3498

attach_function :get_initializer, :LLVMGetInitializer, [OpaqueValue], OpaqueValue

.get_insert_block(builder) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



4453
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4453

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


4293
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4293

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


4252
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4252

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


4205
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4205

attach_function :get_instruction_parent, :LLVMGetInstructionParent, [OpaqueValue], OpaqueBasicBlock

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


1329
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1329

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


3612
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3612

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


4022
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4022

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


1153
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1153

attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue

.get_last_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3466
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3466

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:



4168
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4168

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


3775
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3775

attach_function :get_last_param, :LLVMGetLastParam, [OpaqueValue], OpaqueValue

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

Returns:



3348
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3348

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) 


923
 
# File 'lib/rltk/cg/generated_bindings.rb', line 923

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) 


914
 
# File 'lib/rltk/cg/generated_bindings.rb', line 914

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) 


3909
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3909

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) 


3926
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3926

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) 


3898
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3898

attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string

.get_metadata(val, kind_id) ⇒ OpaqueValue

Return metadata associated with an instruction value.

Parameters:

Returns:



4185
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4185

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


1057
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1057

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


1133
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1133

attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue

.get_named_global(m, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3450
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3450

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


1077
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1077

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


1095
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1095

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ OpaqueBasicBlock

Advance a basic block iterator.

Parameters:

Returns:



4030
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4030

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:



1164
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1164

attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue

.get_next_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3474
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3474

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:



4218
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4218

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:



3787
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3787

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:



6528
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6528

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:



2419
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2419

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


2474
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2474

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


2452
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2452

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


3741
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3741

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:



3755
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3755

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) 


1477
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1477

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


3728
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3728

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


1649
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1649

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


7066
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7066

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, OpaqueValue], :pointer

.get_previous_basic_block(bb) ⇒ OpaqueBasicBlock

Go backwards in a basic block iterator.

Parameters:

Returns:



4038
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4038

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:



1175
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1175

attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue

.get_previous_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



3482
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3482

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:



4229
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4229

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:



3797
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3797

attach_function :get_previous_param, :LLVMGetPreviousParam, [OpaqueValue], OpaqueValue

.get_relocation_address(ri) ⇒ Integer

// RelocationRef accessors

Parameters:

Returns:

  • (Integer) 


7571
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7571

attach_function :get_relocation_address, :LLVMGetRelocationAddress, [OpaqueRelocationIterator], :ulong

.get_relocation_offset(ri) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7579
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7579

attach_function :get_relocation_offset, :LLVMGetRelocationOffset, [OpaqueRelocationIterator], :ulong

.get_relocation_symbol(ri) ⇒ OpaqueSymbolIterator

(Not documented)

Parameters:

Returns:



7587
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7587

attach_function :get_relocation_symbol, :LLVMGetRelocationSymbol, [OpaqueRelocationIterator], OpaqueSymbolIterator

.get_relocation_type(ri) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7595
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7595

attach_function :get_relocation_type, :LLVMGetRelocationType, [OpaqueRelocationIterator], :ulong

.get_relocation_type_name(ri) ⇒ String

// following functions.

Parameters:

Returns:

  • (String) 


7603
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7603

attach_function :get_relocation_type_name, :LLVMGetRelocationTypeName, [OpaqueRelocationIterator], :string

.get_relocation_value_string(ri) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


7611
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7611

attach_function :get_relocation_value_string, :LLVMGetRelocationValueString, [OpaqueRelocationIterator], :string

.get_relocations(section) ⇒ OpaqueRelocationIterator

// Section Relocation iterators

Parameters:

Returns:



7506
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7506

attach_function :get_relocations, :LLVMGetRelocations, [OpaqueSectionIterator], OpaqueRelocationIterator

.get_return_type(function_ty) ⇒ OpaqueType

Obtain the Type this function Type returns.

Parameters:

Returns:



1452
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1452

attach_function :get_return_type, :LLVMGetReturnType, [OpaqueType], OpaqueType

.get_section(global) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


3365
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3365

attach_function :get_section, :LLVMGetSection, [OpaqueValue], :string

.get_section_address(si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7489
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7489

attach_function :get_section_address, :LLVMGetSectionAddress, [OpaqueSectionIterator], :ulong

.get_section_contains_symbol(si, sym) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7498
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7498

attach_function :get_section_contains_symbol, :LLVMGetSectionContainsSymbol, [OpaqueSectionIterator, OpaqueSymbolIterator], :int

.get_section_contents(si) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


7481
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7481

attach_function :get_section_contents, :LLVMGetSectionContents, [OpaqueSectionIterator], :string

.get_section_name(si) ⇒ String

// SectionRef accessors

Parameters:

Returns:

  • (String) 


7465
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7465

attach_function :get_section_name, :LLVMGetSectionName, [OpaqueSectionIterator], :string

.get_section_size(si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7473
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7473

attach_function :get_section_size, :LLVMGetSectionSize, [OpaqueSectionIterator], :ulong

.get_sections(object_file) ⇒ OpaqueSectionIterator

// ObjectFile Section iterators

Parameters:

Returns:



7390
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7390

attach_function :get_sections, :LLVMGetSections, [OpaqueObjectFile], OpaqueSectionIterator

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


1565
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1565

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


1526
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1526

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


4360
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4360

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [OpaqueValue], OpaqueBasicBlock

.get_symbol_address(si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7547
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7547

attach_function :get_symbol_address, :LLVMGetSymbolAddress, [OpaqueSymbolIterator], :ulong

.get_symbol_file_offset(si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7555
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7555

attach_function :get_symbol_file_offset, :LLVMGetSymbolFileOffset, [OpaqueSymbolIterator], :ulong

.get_symbol_name(si) ⇒ String

// SymbolRef accessors

Parameters:

Returns:

  • (String) 


7539
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7539

attach_function :get_symbol_name, :LLVMGetSymbolName, [OpaqueSymbolIterator], :string

.get_symbol_size(si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7563
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7563

attach_function :get_symbol_size, :LLVMGetSymbolSize, [OpaqueSymbolIterator], :ulong

.get_symbols(object_file) ⇒ OpaqueSymbolIterator

// ObjectFile Symbol iterators

Parameters:

Returns:



7432
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7432

attach_function :get_symbols, :LLVMGetSymbols, [OpaqueObjectFile], OpaqueSymbolIterator

.get_target(m) ⇒ String

Obtain the target triple for a module.

Parameters:

Returns:

  • (String)

See Also:

  • Module::getTargetTriple()


991
 
# File 'lib/rltk/cg/generated_bindings.rb', line 991

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) 


6565
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6565

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:



6537
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6537

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) 


6549
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6549

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) 


6640
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6640

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:



6658
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6658

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) 


6650
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6650

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:



6620
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6620

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) 


6630
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6630

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) 


6557
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6557

attach_function :get_target_name, :LLVMGetTargetName, [Target], :string

.get_thread_local_mode(global_var) ⇒ Symbol from _enum_thread_local_mode_

(Not documented)

Parameters:

Returns:



3549
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3549

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:



1066
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1066

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


1207
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1207

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


1185
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1185

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


2507
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2507

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


2441
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2441

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


2431
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2431

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


1742
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1742

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


1676
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1676

attach_function :get_vector_size, :LLVMGetVectorSize, [OpaqueType], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

Returns:



3382
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3382

attach_function :get_visibility, :LLVMGetVisibility, [OpaqueValue], :visibility

.get_volatile(memory_access_inst) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


5133
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5133

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:



1387
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1387

attach_function :half_type, :LLVMHalfType, [], OpaqueType

.half_type_in_context(c) ⇒ OpaqueType

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

Parameters:

Returns:



1337
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1337

attach_function :half_type_in_context, :LLVMHalfTypeInContext, [OpaqueContext], OpaqueType

.has_metadata(val) ⇒ Integer

Determine whether an instruction has any metadata attached.

Parameters:

Returns:

  • (Integer) 


4176
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4176

attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int

.initialize_all_asm_parsers ⇒ nil

LLVMInitializeAllAsmParsers - The main program should call this function if

it wants all asm parsers that LLVM is configured to support, to make them
available via the TargetRegistry.

Returns:

  • (nil) 


6133
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6133

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

.initialize_all_asm_printers ⇒ nil

LLVMInitializeAllAsmPrinters - The main program should call this function if

it wants all asm printers that LLVM is configured to support, to make them
available via the TargetRegistry.

Returns:

  • (nil) 


6124
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6124

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

.initialize_all_disassemblers ⇒ nil

LLVMInitializeAllDisassemblers - The main program should call this function

if it wants all disassemblers that LLVM is configured to support, to make
them available via the TargetRegistry.

Returns:

  • (nil) 


6142
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6142

attach_function :initialize_all_disassemblers, :LLVMInitializeAllDisassemblers, [], :void

.initialize_all_target_infos ⇒ nil

(Not documented)

Returns:

  • (nil) 


6097
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6097

attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :void

.initialize_all_target_m_cs ⇒ nil

LLVMInitializeAllTargetMCs - The main program should call this function if

it wants access to all available target MC that LLVM is configured to
support.

Returns:

  • (nil) 


6115
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6115

attach_function :initialize_all_target_mcs, :LLVMInitializeAllTargetMCs, [], :void

.initialize_all_targets ⇒ nil

LLVMInitializeAllTargets - The main program should call this function if it

wants to link in all available targets that LLVM is configured to
support.

Returns:

  • (nil) 


6106
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6106

attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void

.initialize_analysis(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7206
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7206

attach_function :initialize_analysis, :LLVMInitializeAnalysis, [OpaquePassRegistry], :void

.initialize_code_gen(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7222
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7222

attach_function :initialize_code_gen, :LLVMInitializeCodeGen, [OpaquePassRegistry], :void

.initialize_core(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


822
 
# File 'lib/rltk/cg/generated_bindings.rb', line 822

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) 


5675
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5675

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [OpaquePassManager], :int

.initialize_inst_combine(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7182
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7182

attach_function :initialize_inst_combine, :LLVMInitializeInstCombine, [OpaquePassRegistry], :void

.initialize_instrumentation(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7198
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7198

attach_function :initialize_instrumentation, :LLVMInitializeInstrumentation, [OpaquePassRegistry], :void

.initialize_ipa(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7214
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7214

attach_function :initialize_ipa, :LLVMInitializeIPA, [OpaquePassRegistry], :void

.initialize_ipo(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7190
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7190

attach_function :initialize_ipo, :LLVMInitializeIPO, [OpaquePassRegistry], :void

.initialize_mcjit_compiler_options(options, size_of_options) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6867
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6867

attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void

.initialize_native_asm_parser ⇒ Integer

LLVMInitializeNativeTargetAsmParser - The main program should call this

function to initialize the parser for the native target corresponding to the
host.

Returns:

  • (Integer) 


6160
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6160

attach_function :initialize_native_asm_parser, :LLVMInitializeNativeAsmParser, [], :int

.initialize_native_asm_printer ⇒ Integer

LLVMInitializeNativeTargetAsmPrinter - The main program should call this

function to initialize the printer for the native target corresponding to
the host.

Returns:

  • (Integer) 


6169
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6169

attach_function :initialize_native_asm_printer, :LLVMInitializeNativeAsmPrinter, [], :int

.initialize_native_disassembler ⇒ Integer

LLVMInitializeNativeTargetDisassembler - The main program should call this

function to initialize the disassembler for the native target corresponding
to the host.

Returns:

  • (Integer) 


6178
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6178

attach_function :initialize_native_disassembler, :LLVMInitializeNativeDisassembler, [], :int

.initialize_native_target ⇒ Integer

LLVMInitializeNativeTarget - The main program should call this function to

initialize the native target corresponding to the host.  This is useful
for JIT applications to ensure that the target gets linked in correctly.

Returns:

  • (Integer) 


6151
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6151

attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int

.initialize_obj_carc_opts(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7166
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7166

attach_function :initialize_objc_arc_opts, :LLVMInitializeObjCARCOpts, [OpaquePassRegistry], :void

.initialize_scalar_opts(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7158
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7158

attach_function :initialize_scalar_opts, :LLVMInitializeScalarOpts, [OpaquePassRegistry], :void

.initialize_target(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7230
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7230

attach_function :initialize_target, :LLVMInitializeTarget, [OpaquePassRegistry], :void

.initialize_transform_utils(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7150
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7150

attach_function :initialize_transform_utils, :LLVMInitializeTransformUtils, [OpaquePassRegistry], :void

.initialize_vectorization(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7174
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7174

attach_function :initialize_vectorization, :LLVMInitializeVectorization, [OpaquePassRegistry], :void

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


4099
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4099

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


4088
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4088

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4470
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4470

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [OpaqueBuilder, OpaqueValue], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4480
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4480

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) 


859
 
# File 'lib/rltk/cg/generated_bindings.rb', line 859

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


4242
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4242

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [OpaqueValue], :void

.int16_type ⇒ OpaqueType

(Not documented)

Returns:



1299
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1299

attach_function :int16_type, :LLVMInt16Type, [], OpaqueType

.int16_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1252
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1252

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:



1285
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1285

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:



1236
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1236

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [OpaqueContext], OpaqueType

.int32_type ⇒ OpaqueType

(Not documented)

Returns:



1306
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1306

attach_function :int32_type, :LLVMInt32Type, [], OpaqueType

.int32_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1260
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1260

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [OpaqueContext], OpaqueType

.int64_type ⇒ OpaqueType

(Not documented)

Returns:



1313
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1313

attach_function :int64_type, :LLVMInt64Type, [], OpaqueType

.int64_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1268
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1268

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [OpaqueContext], OpaqueType

.int8_type ⇒ OpaqueType

(Not documented)

Returns:



1292
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1292

attach_function :int8_type, :LLVMInt8Type, [], OpaqueType

.int8_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1244
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1244

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [OpaqueContext], OpaqueType

.int_ptr_type(td) ⇒ OpaqueType

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

See the method llvm::DataLayout::getIntPtrType.

Parameters:

Returns:



6258
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6258

attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], OpaqueType

.int_ptr_type_for_as(td, as) ⇒ OpaqueType

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

This version allows the address space to be specified.
See the method llvm::DataLayout::getIntPtrType.

Parameters:

Returns:



6269
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6269

attach_function :int_ptr_type_for_as, :LLVMIntPtrTypeForAS, [OpaqueTargetData, :uint], OpaqueType

.int_ptr_type_for_as_in_context(c, td, as) ⇒ OpaqueType

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

This version allows the address space to be specified.
See the method llvm::DataLayout::getIntPtrType.

Parameters:

Returns:



6291
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6291

attach_function :int_ptr_type_for_as_in_context, :LLVMIntPtrTypeForASInContext, [OpaqueContext, OpaqueTargetData, :uint], OpaqueType

.int_ptr_type_in_context(c, td) ⇒ OpaqueType

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

See the method llvm::DataLayout::getIntPtrType.

Parameters:

Returns:



6279
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6279

attach_function :int_ptr_type_in_context, :LLVMIntPtrTypeInContext, [OpaqueContext, OpaqueTargetData], OpaqueType

.int_type(num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

  • num_bits (Integer)

Returns:



1321
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1321

attach_function :int_type, :LLVMIntType, [:uint], OpaqueType

.int_type_in_context(c, num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1277
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1277

attach_function :int_type_in_context, :LLVMIntTypeInContext, [OpaqueContext, :uint], OpaqueType

.is_a_addr_space_cast_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2273
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2273

attach_function :is_a_addr_space_cast_inst, :LLVMIsAAddrSpaceCastInst, [OpaqueValue], OpaqueValue

.is_a_alloca_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2257
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2257

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [OpaqueValue], OpaqueValue

.is_a_argument(val) ⇒ OpaqueValue

Convert value instances between types.

Internally, an LLVMValueRef is “pinned” to a specific type. This series of functions allows you to cast an instance to a specific type.

If the cast is not valid for the specified type, NULL is returned.

Parameters:

Returns:

See Also:

  • llvmllvm::dyn_cast_or_null<>


1817
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1817

attach_function :is_a_argument, :LLVMIsAArgument, [OpaqueValue], OpaqueValue

.is_a_basic_block(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1825
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1825

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [OpaqueValue], OpaqueValue

.is_a_binary_operator(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2017
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2017

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [OpaqueValue], OpaqueValue

.is_a_bit_cast_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2281
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2281

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [OpaqueValue], OpaqueValue

.is_a_block_address(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1873
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1873

attach_function :is_a_block_address, :LLVMIsABlockAddress, [OpaqueValue], OpaqueValue

.is_a_branch_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2193
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2193

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [OpaqueValue], OpaqueValue

.is_a_call_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2025
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2025

attach_function :is_a_call_inst, :LLVMIsACallInst, [OpaqueValue], OpaqueValue

.is_a_cast_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2265
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2265

attach_function :is_a_cast_inst, :LLVMIsACastInst, [OpaqueValue], OpaqueValue

.is_a_cmp_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2089
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2089

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [OpaqueValue], OpaqueValue

.is_a_constant(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1865
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1865

attach_function :is_a_constant, :LLVMIsAConstant, [OpaqueValue], OpaqueValue

.is_a_constant_aggregate_zero(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1881
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1881

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [OpaqueValue], OpaqueValue

.is_a_constant_array(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1889
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1889

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [OpaqueValue], OpaqueValue

.is_a_constant_data_array(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1905
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1905

attach_function :is_a_constant_data_array, :LLVMIsAConstantDataArray, [OpaqueValue], OpaqueValue

.is_a_constant_data_sequential(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1897
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1897

attach_function :is_a_constant_data_sequential, :LLVMIsAConstantDataSequential, [OpaqueValue], OpaqueValue

.is_a_constant_data_vector(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1913
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1913

attach_function :is_a_constant_data_vector, :LLVMIsAConstantDataVector, [OpaqueValue], OpaqueValue

.is_a_constant_expr(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1921
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1921

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [OpaqueValue], OpaqueValue

.is_a_constant_fp(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1929
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1929

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [OpaqueValue], OpaqueValue

.is_a_constant_int(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1937
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1937

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [OpaqueValue], OpaqueValue

.is_a_constant_pointer_null(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1945
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1945

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [OpaqueValue], OpaqueValue

.is_a_constant_struct(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1953
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1953

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [OpaqueValue], OpaqueValue

.is_a_constant_vector(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1961
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1961

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [OpaqueValue], OpaqueValue

.is_a_dbg_declare_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2049
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2049

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [OpaqueValue], OpaqueValue

.is_a_dbg_info_intrinsic(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2041
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2041

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [OpaqueValue], OpaqueValue

.is_a_extract_element_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2113
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2113

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [OpaqueValue], OpaqueValue

.is_a_extract_value_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2377
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2377

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [OpaqueValue], OpaqueValue

.is_a_function(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1977
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1977

attach_function :is_a_function, :LLVMIsAFunction, [OpaqueValue], OpaqueValue

.is_a_get_element_ptr_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2121
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2121

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [OpaqueValue], OpaqueValue

.is_a_global_alias(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1985
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1985

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [OpaqueValue], OpaqueValue

.is_a_global_value(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1969
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1969

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [OpaqueValue], OpaqueValue

.is_a_global_variable(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1993
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1993

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [OpaqueValue], OpaqueValue

.is_a_indirect_br_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2201
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2201

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [OpaqueValue], OpaqueValue

.is_a_inline_asm(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1833
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1833

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [OpaqueValue], OpaqueValue

.is_a_insert_element_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2129
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2129

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [OpaqueValue], OpaqueValue

.is_a_insert_value_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2137
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2137

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [OpaqueValue], OpaqueValue

.is_a_instruction(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2009
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2009

attach_function :is_a_instruction, :LLVMIsAInstruction, [OpaqueValue], OpaqueValue

.is_a_int_to_ptr_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2321
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2321

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [OpaqueValue], OpaqueValue

.is_a_intrinsic_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2033
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2033

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [OpaqueValue], OpaqueValue

.is_a_invoke_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2209
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2209

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [OpaqueValue], OpaqueValue

.is_a_landing_pad_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2145
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2145

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [OpaqueValue], OpaqueValue

.is_a_load_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2385
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2385

attach_function :is_a_load_inst, :LLVMIsALoadInst, [OpaqueValue], OpaqueValue

.is_a_mem_cpy_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2065
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2065

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [OpaqueValue], OpaqueValue

.is_a_mem_intrinsic(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2057
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2057

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [OpaqueValue], OpaqueValue

.is_a_mem_move_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2073
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2073

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [OpaqueValue], OpaqueValue

.is_a_mem_set_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2081
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2081

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [OpaqueValue], OpaqueValue

.is_a_ptr_to_int_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2329
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2329

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [OpaqueValue], OpaqueValue

.is_a_resume_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2241
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2241

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [OpaqueValue], OpaqueValue

.is_a_return_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2217
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2217

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [OpaqueValue], OpaqueValue

.is_a_select_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2161
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2161

attach_function :is_a_select_inst, :LLVMIsASelectInst, [OpaqueValue], OpaqueValue

.is_a_shuffle_vector_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2169
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2169

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [OpaqueValue], OpaqueValue

.is_a_store_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2177
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2177

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [OpaqueValue], OpaqueValue

.is_a_switch_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2225
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2225

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [OpaqueValue], OpaqueValue

.is_a_terminator_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2185
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2185

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [OpaqueValue], OpaqueValue

.is_a_trunc_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2353
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2353

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [OpaqueValue], OpaqueValue

.is_a_unary_instruction(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2249
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2249

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [OpaqueValue], OpaqueValue

.is_a_undef_value(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2001
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2001

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [OpaqueValue], OpaqueValue

.is_a_unreachable_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2233
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2233

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [OpaqueValue], OpaqueValue

.is_a_user(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1857
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1857

attach_function :is_a_user, :LLVMIsAUser, [OpaqueValue], OpaqueValue

.is_af_cmp_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2097
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2097

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [OpaqueValue], OpaqueValue

.is_afp_ext_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2289
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2289

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [OpaqueValue], OpaqueValue

.is_afp_to_si_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2297
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2297

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [OpaqueValue], OpaqueValue

.is_afp_to_ui_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2305
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2305

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [OpaqueValue], OpaqueValue

.is_afp_trunc_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2313
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2313

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [OpaqueValue], OpaqueValue

.is_ai_cmp_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2105
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2105

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [OpaqueValue], OpaqueValue

.is_amd_node(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1841
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1841

attach_function :is_amd_node, :LLVMIsAMDNode, [OpaqueValue], OpaqueValue

.is_amd_string(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



1849
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1849

attach_function :is_amd_string, :LLVMIsAMDString, [OpaqueValue], OpaqueValue

.is_aphi_node(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2153
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2153

attach_function :is_aphi_node, :LLVMIsAPHINode, [OpaqueValue], OpaqueValue

.is_as_ext_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2337
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2337

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [OpaqueValue], OpaqueValue

.is_asi_to_fp_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2345
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2345

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [OpaqueValue], OpaqueValue

.is_aui_to_fp_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2361
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2361

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [OpaqueValue], OpaqueValue

.is_ava_arg_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2393
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2393

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [OpaqueValue], OpaqueValue

.is_az_ext_inst(val) ⇒ OpaqueValue

@}

Parameters:

Returns:



2369
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2369

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [OpaqueValue], OpaqueValue

.is_constant(val) ⇒ Integer

Determine whether the specified constant instance is constant.

Parameters:

Returns:

  • (Integer) 


1793
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1793

attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3340
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3340

attach_function :is_declaration, :LLVMIsDeclaration, [OpaqueValue], :int

.is_externally_initialized(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3566
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3566

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) 


1444
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1444

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [OpaqueType], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3532
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3532

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) 


5735
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5735

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


2517
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2517

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


1585
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1585

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


1575
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1575

attach_function :is_packed_struct, :LLVMIsPackedStruct, [OpaqueType], :int

.is_relocation_iterator_at_end(section, ri) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7523
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7523

attach_function :is_relocation_iterator_at_end, :LLVMIsRelocationIteratorAtEnd, [OpaqueSectionIterator, OpaqueRelocationIterator], :int

.is_section_iterator_at_end(object_file, si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7407
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7407

attach_function :is_section_iterator_at_end, :LLVMIsSectionIteratorAtEnd, [OpaqueObjectFile, OpaqueSectionIterator], :int

.is_symbol_iterator_at_end(object_file, si) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7449
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7449

attach_function :is_symbol_iterator_at_end, :LLVMIsSymbolIteratorAtEnd, [OpaqueObjectFile, OpaqueSymbolIterator], :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()


4335
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4335

attach_function :is_tail_call, :LLVMIsTailCall, [OpaqueValue], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


3515
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3515

attach_function :is_thread_local, :LLVMIsThreadLocal, [OpaqueValue], :int

.is_undef(val) ⇒ Integer

Determine whether a value instance is undefined.

Parameters:

Returns:

  • (Integer) 


1801
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1801

attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int

.label_type ⇒ OpaqueType

(Not documented)

Returns:



1715
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1715

attach_function :label_type, :LLVMLabelType, [], OpaqueType

.label_type_in_context(c) ⇒ OpaqueType

Create a label type in a context.

Parameters:

Returns:



1692
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1692

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [OpaqueContext], OpaqueType

.link_in_interpreter ⇒ nil

(Not documented)

Returns:

  • (nil) 


6722
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6722

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

.link_in_jit ⇒ nil

(Not documented)

Returns:

  • (nil) 


6708
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6708

attach_function :link_in_jit, :LLVMLinkInJIT, [], :void

.link_in_mcjit ⇒ nil

(Not documented)

Returns:

  • (nil) 


6715
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6715

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:

Returns:

  • (Integer) 


7271
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7271

attach_function :link_modules, :LLVMLinkModules, [OpaqueModule, OpaqueModule, :linker_mode, :pointer], :int

.llvm_create_optimizer ⇒ FFI::Pointer(LlvmLtoT)

/// extern “C” helps, because dlopen() interface uses name to find the symbol.

Returns:

  • (FFI::Pointer(LlvmLtoT)) 


7320
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7320

attach_function :llvm_create_optimizer, :llvm_create_optimizer, [], :pointer

.llvm_destroy_optimizer(lto) ⇒ nil

(Not documented)

Parameters:

  • lto (FFI::Pointer(LlvmLtoT))

Returns:

  • (nil) 


7328
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7328

attach_function :llvm_destroy_optimizer, :llvm_destroy_optimizer, [:pointer], :void

.llvm_optimize_modules(lto, output_filename) ⇒ Symbol from _enum_llvm_lto_status_

(Not documented)

Parameters:

  • lto (FFI::Pointer(LlvmLtoT))
  • output_filename (String)

Returns:



7346
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7346

attach_function :llvm_optimize_modules, :llvm_optimize_modules, [:pointer, :string], :llvm_lto_status

.llvm_read_object_file(lto, input_filename) ⇒ Symbol from _enum_llvm_lto_status_

(Not documented)

Parameters:

  • lto (FFI::Pointer(LlvmLtoT))
  • input_filename (String)

Returns:



7337
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7337

attach_function :llvm_read_object_file, :llvm_read_object_file, [:pointer, :string], :llvm_lto_status

.load_library_permanently(filename) ⇒ Integer

(Not documented)

Parameters:

  • filename (String)

Returns:

  • (Integer) 


7619
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7619

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:



3885
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3885

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:



3876
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3876

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:



3864
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3864

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:



3855
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3855

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:



937
 
# File 'lib/rltk/cg/generated_bindings.rb', line 937

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:



949
 
# File 'lib/rltk/cg/generated_bindings.rb', line 949

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


4147
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4147

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


4136
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4136

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.move_to_containing_section(sect, sym) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7424
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7424

attach_function :move_to_containing_section, :LLVMMoveToContainingSection, [OpaqueSectionIterator, OpaqueSymbolIterator], :void

.move_to_next_relocation(ri) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7531
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7531

attach_function :move_to_next_relocation, :LLVMMoveToNextRelocation, [OpaqueRelocationIterator], :void

.move_to_next_section(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7415
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7415

attach_function :move_to_next_section, :LLVMMoveToNextSection, [OpaqueSectionIterator], :void

.move_to_next_symbol(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7457
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7457

attach_function :move_to_next_symbol, :LLVMMoveToNextSymbol, [OpaqueSymbolIterator], :void

.offset_of_element(td, struct_ty, element) ⇒ Integer

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

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

Returns:

  • (Integer) 


6383
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6383

attach_function :offset_of_element, :LLVMOffsetOfElement, [OpaqueTargetData, OpaqueType, :uint], :ulong_long

.parse_bitcode(mem_buf, out_module, out_message) ⇒ Integer

(Not documented)

Parameters:

  • mem_buf (OpaqueMemoryBuffer)
  • out_module (FFI::Pointer(*ModuleRef))
  • out_message (FFI::Pointer(**CharS))

Returns:

  • (Integer) 


5805
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5805

attach_function :parse_bitcode, :LLVMParseBitcode, [OpaqueMemoryBuffer, :pointer, :pointer], :int

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

(Not documented)

Parameters:

Returns:

  • (Integer) 


5816
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5816

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int

.parse_ir_in_context(context_ref, mem_buf, out_m, out_message) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


7241
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7241

attach_function :parse_ir_in_context, :LLVMParseIRInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int

.pass_manager_builder_create ⇒ OpaquePassManagerBuilder

See llvm::PassManagerBuilder.

Returns:



7744
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7744

attach_function :pass_manager_builder_create, :LLVMPassManagerBuilderCreate, [], OpaquePassManagerBuilder

.pass_manager_builder_dispose(pmb) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


7752
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7752

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) 


7815
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7815

attach_function :pass_manager_builder_populate_function_pass_manager, :LLVMPassManagerBuilderPopulateFunctionPassManager, [OpaquePassManagerBuilder, OpaquePassManager], :void

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

See llvm::PassManagerBuilder::populateLTOPassManager.

Parameters:

Returns:

  • (nil) 


7835
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7835

attach_function :pass_manager_builder_populate_lto_pass_manager, :LLVMPassManagerBuilderPopulateLTOPassManager, [OpaquePassManagerBuilder, OpaquePassManager, :int, :int], :void

.pass_manager_builder_populate_module_pass_manager(pmb, pm) ⇒ nil

See llvm::PassManagerBuilder::populateModulePassManager.

Parameters:

Returns:

  • (nil) 


7824
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7824

attach_function :pass_manager_builder_populate_module_pass_manager, :LLVMPassManagerBuilderPopulateModulePassManager, [OpaquePassManagerBuilder, OpaquePassManager], :void

.pass_manager_builder_set_disable_simplify_lib_calls(pmb, value) ⇒ nil

See llvm::PassManagerBuilder::DisableSimplifyLibCalls

Parameters:

Returns:

  • (nil) 


7797
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7797

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) 


7779
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7779

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) 


7788
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7788

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) 


7761
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7761

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) 


7770
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7770

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) 


7806
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7806

attach_function :pass_manager_builder_use_inliner_with_threshold, :LLVMPassManagerBuilderUseInlinerWithThreshold, [OpaquePassManagerBuilder, :uint], :void

.pointer_size(td) ⇒ Integer

Returns the pointer size in bytes for a target.

See the method llvm::DataLayout::getPointerSize.

Parameters:

Returns:

  • (Integer) 


6238
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6238

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_size_for_as(td, as) ⇒ Integer

Returns the pointer size in bytes for a target for a specified

address space.
See the method llvm::DataLayout::getPointerSize.

Parameters:

Returns:

  • (Integer) 


6249
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6249

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


1637
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1637

attach_function :pointer_type, :LLVMPointerType, [OpaqueType, :uint], OpaqueType

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4427
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4427

attach_function :position_builder, :LLVMPositionBuilder, [OpaqueBuilder, OpaqueBasicBlock, OpaqueValue], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4445
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4445

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [OpaqueBuilder, OpaqueBasicBlock], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4436
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4436

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [OpaqueBuilder, OpaqueValue], :void

.ppcfp128_type ⇒ OpaqueType

(Not documented)

Returns:



1422
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1422

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:



1378
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1378

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [OpaqueContext], OpaqueType

.preferred_alignment_of_global(td, global_var) ⇒ Integer

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

See the method llvm::DataLayout::getPreferredAlignment.

Parameters:

Returns:

  • (Integer) 


6361
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6361

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, OpaqueValue], :uint

.preferred_alignment_of_type(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeABISize.

Parameters:

Returns:

  • (Integer) 


6351
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6351

attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, OpaqueType], :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()


1025
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1025

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


1036
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1036

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


1228
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1228

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


1774
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1774

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


7039
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7039

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, OpaqueValue], :pointer

.remove_attribute(arg, pa) ⇒ nil

Remove an attribute from a function argument.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Argumentllvm::Argument::removeAttr()


3819
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3819

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


4125
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4125

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) 


3701
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3701

attach_function :remove_function_attr, :LLVMRemoveFunctionAttr, [OpaqueValue, :attribute], :void

.remove_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4313
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4313

attach_function :remove_instr_attribute, :LLVMRemoveInstrAttribute, [OpaqueValue, :uint, :attribute], :void

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

(Not documented)

Parameters:

Returns:

  • (Integer) 


7009
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7009

attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, OpaqueModule, :pointer, :pointer], :int

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

Deprecated: Use LLVMRemoveModule instead.

Parameters:

Returns:

  • (Integer) 


7020
 
# File 'lib/rltk/cg/generated_bindings.rb', line 7020

attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [OpaqueExecutionEngine, OpaqueModuleProvider, :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()


1785
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1785

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) 


867
 
# File 'lib/rltk/cg/generated_bindings.rb', line 867

attach_function :reset_fatal_error_handler, :LLVMResetFatalErrorHandler, [], :void

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

(Not documented)

Parameters:

Returns:



6971
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6971

attach_function :run_function, :LLVMRunFunction, [OpaqueExecutionEngine, OpaqueValue, :uint, :pointer], OpaqueGenericValue

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

(Not documented)

Parameters:

Returns:

  • (Integer) 


6960
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6960

attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [OpaqueExecutionEngine, OpaqueValue, :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) 


5687
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5687

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) 


5665
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5665

attach_function :run_pass_manager, :LLVMRunPassManager, [OpaquePassManager, OpaqueModule], :int

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6940
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6940

attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void

.run_static_destructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


6948
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6948

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::LoadInstllvm::LoadInst::setAlignment()
  • llvmllvm::StoreInstllvm::StoreInst::setAlignment()
  • llvmllvm::GlobalValuellvm::GlobalValue::setAlignment()


3414
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3414

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) 


4662
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4662

attach_function :set_cleanup, :LLVMSetCleanup, [OpaqueValue, :int], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

Returns:

  • (nil) 


4497
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4497

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


981
 
# File 'lib/rltk/cg/generated_bindings.rb', line 981

attach_function :set_data_layout, :LLVMSetDataLayout, [OpaqueModule, :string], :void

.set_disasm_options(dc, options) ⇒ Integer

Set the disassembler’s options. Returns 1 if it can set the Options and 0 otherwise.

Parameters:

  • dc (FFI::Pointer(DisasmContextRef))
  • options (Integer)

Returns:

  • (Integer) 


6034
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6034

attach_function :set_disasm_options, :LLVMSetDisasmOptions, [:pointer, :ulong], :int

.set_externally_initialized(global_var, is_ext_init) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3575
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3575

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


3638
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3638

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


3660
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3660

attach_function :set_gc, :LLVMSetGC, [OpaqueValue, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3541
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3541

attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3507
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3507

attach_function :set_initializer, :LLVMSetInitializer, [OpaqueValue, OpaqueValue], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4514
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4514

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4323
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4323

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


4280
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4280

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [OpaqueValue, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3357
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3357

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) 


4195
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4195

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


1047
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1047

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


2464
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2464

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


3839
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3839

attach_function :set_param_alignment, :LLVMSetParamAlignment, [OpaqueValue, :uint], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3374
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3374

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


4348
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4348

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


1002
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1002

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) 


6667
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6667

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) 


3524
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3524

attach_function :set_thread_local, :LLVMSetThreadLocal, [OpaqueValue, :int], :void

.set_thread_local_mode(global_var, mode) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3558
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3558

attach_function :set_thread_local_mode, :LLVMSetThreadLocalMode, [OpaqueValue, :thread_local_mode], :void

.set_value_name(val, name) ⇒ nil

Set the string name of a value.

Parameters:

Returns:

  • (nil)

See Also:

  • llvmllvm::Valuellvm::Value::setName()


1753
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1753

attach_function :set_value_name, :LLVMSetValueName, [OpaqueValue, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3391
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3391

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) 


5142
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5142

attach_function :set_volatile, :LLVMSetVolatile, [OpaqueValue, :int], :void

.shutdown ⇒ nil

Deallocate and destroy all ManagedStatic variables.

@see llvm::llvm_shutdown
@see ManagedStatic

Returns:

  • (nil) 


831
 
# File 'lib/rltk/cg/generated_bindings.rb', line 831

attach_function :shutdown, :LLVMShutdown, [], :void

.size_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2759
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2759

attach_function :size_of, :LLVMSizeOf, [OpaqueType], OpaqueValue

.size_of_type_in_bits(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeSizeInBits.

Parameters:

Returns:

  • (Integer) 


6301
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6301

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, OpaqueType], :ulong_long

.start_multithreaded ⇒ Integer

Allocate and initialize structures needed to make LLVM safe for

multithreading. The return value indicates whether multithreaded
initialization succeeded. Must be executed in isolation from all
other LLVM api calls.
@see llvm::llvm_start_multithreaded

Returns:

  • (Integer) 


5718
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5718

attach_function :start_multithreaded, :LLVMStartMultithreaded, [], :int

.stop_multithreaded ⇒ nil

Deallocate structures necessary to make LLVM safe for multithreading.

Must be executed in isolation from all other LLVM api calls.
@see llvm::llvm_stop_multithreaded

Returns:

  • (nil) 


5727
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5727

attach_function :stop_multithreaded, :LLVMStopMultithreaded, [], :void

.store_size_of_type(td, ty) ⇒ Integer

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

See the method llvm::DataLayout::getTypeStoreSize.

Parameters:

Returns:

  • (Integer) 


6311
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6311

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, OpaqueType], :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()


1516
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1516

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


1539
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1539

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


1505
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1505

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


1493
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1493

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) 


6589
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6589

attach_function :target_has_asm_backend, :LLVMTargetHasAsmBackend, [Target], :int

.target_has_jit(t) ⇒ Integer

Returns if the target has a JIT

Parameters:

Returns:

  • (Integer) 


6573
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6573

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) 


6581
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6581

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) 


6681
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6681

attach_function :target_machine_emit_to_file, :LLVMTargetMachineEmitToFile, [OpaqueTargetMachine, OpaqueModule, :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) 


6693
 
# File 'lib/rltk/cg/generated_bindings.rb', line 6693

attach_function :target_machine_emit_to_memory_buffer, :LLVMTargetMachineEmitToMemoryBuffer, [OpaqueTargetMachine, OpaqueModule, :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()


1197
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1197

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


1732
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1732

attach_function :type_of, :LLVMTypeOf, [OpaqueValue], OpaqueType

.value_as_basic_block(val) ⇒ OpaqueBasicBlock

Convert an LLVMValueRef to an LLVMBasicBlockRef instance.

Parameters:

Returns:



3950
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3950

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) 


3942
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3942

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


1664
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1664

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) 


5778
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5778

attach_function :verify_function, :LLVMVerifyFunction, [OpaqueValue, :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) 


5768
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5768

attach_function :verify_module, :LLVMVerifyModule, [OpaqueModule, :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:

Returns:

  • (nil) 


5787
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5787

attach_function :view_function_cfg, :LLVMViewFunctionCFG, [OpaqueValue], :void

.view_function_cfg_only(fn) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


5795
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5795

attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [OpaqueValue], :void

.void_type ⇒ OpaqueType

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

Returns:



1708
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1708

attach_function :void_type, :LLVMVoidType, [], OpaqueType

.void_type_in_context(c) ⇒ OpaqueType

Create a void type in a context.

Parameters:

Returns:



1684
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1684

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 (OpaqueModule)
  • fd (Integer)
  • should_close (Integer)
  • unbuffered (Integer)

Returns:

  • (Integer) 


5880
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5880

attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [OpaqueModule, :int, :int, :int], :int

.write_bitcode_to_file(m, path) ⇒ Integer

(Not documented)

Parameters:

Returns:

  • (Integer) 


5869
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5869

attach_function :write_bitcode_to_file, :LLVMWriteBitcodeToFile, [OpaqueModule, :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:

Returns:

  • (Integer) 


5890
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5890

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [OpaqueModule, :int], :int

.x86fp80_type ⇒ OpaqueType

(Not documented)

Returns:



1408
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1408

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:



1361
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1361

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [OpaqueContext], OpaqueType

.x86mmx_type ⇒ OpaqueType

(Not documented)

Returns:



1722
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1722

attach_function :x86mmx_type, :LLVMX86MMXType, [], OpaqueType

.x86mmx_type_in_context(c) ⇒ OpaqueType

Create a X86 MMX type in a context.

Parameters:

Returns:



1700
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1700

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [OpaqueContext], OpaqueType