Module: RLTK::CG::Bindings

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

Overview

This module contains FFI bindings to LLVM.

Defined Under Namespace

Classes: LibraryMismatch, OpInfo1, OpInfoSymbol1, OpaqueBasicBlock, OpaqueBuilder, OpaqueContext, OpaqueExecutionEngine, OpaqueGenericValue, OpaqueMemoryBuffer, OpaqueModule, OpaqueModuleProvider, OpaqueObjectFile, OpaquePassManager, OpaquePassRegistry, OpaqueSectionIterator, OpaqueTarget, OpaqueTargetData, OpaqueTargetLibraryInfotData, OpaqueTargetMachine, OpaqueTriple, OpaqueType, OpaqueUse, OpaqueValue, StructLayout

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
ECB_VERSION = 
0
TARGET_VERSION_MAJOR = 
3
TARGET_VERSION_MINOR = 
0

Class Method Summary collapse

Class Method Details

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

Returns:

  • (FFI::Pointer(*Void)) 


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

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


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

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

._enum_attribute_ ⇒ Symbol

(Not documented)

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

Options:

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

Returns:

  • (Symbol) 


154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
# File 'lib/rltk/cg/generated_bindings.rb', line 154

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

._enum_byte_ordering_ ⇒ Symbol

(Not documented)

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

Options:

:big_endian
:little_endian

Returns:

  • (Symbol) 


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

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

._enum_call_conv_ ⇒ Symbol

(Not documented)

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

Options:

:c
:fast
:cold
:x86_stdcall
:x86_fastcall

Returns:

  • (Symbol) 


535
536
537
538
539
540
541
 
# File 'lib/rltk/cg/generated_bindings.rb', line 535

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

._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_cmodel
:kernel
:small
:medium
:large

Returns:

  • (Symbol) 


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

enum :code_model, [
  :default_cmodel, 0,
  :kernel, 1,
  :small, 2,
  :medium, 3,
  :large, 4
]

._enum_compile_type_ ⇒ Symbol

(Not documented)

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

Options:

:asm
:object

Returns:

  • (Symbol) 


162
163
164
165
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 162

enum :compile_type, [
  :asm, 0,
  :object, 1
]

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


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

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) 


658
659
660
661
 
# File 'lib/rltk/cg/generated_bindings.rb', line 658

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)

:weak_any

< Same, but only replaced by something

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

:linker_private_weak_def_auto

< Like LinkerPrivate, but is weak.

Returns:

  • (Symbol) 


475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
 
# File 'lib/rltk/cg/generated_bindings.rb', line 475

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

._enum_opcode_ ⇒ Symbol

(Not documented)

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

Options:

:ret

Terminator Instructions

:br
:switch
:indirect_br
:invoke
:unreachable

removed 6 due to API changes

:add

Standard Binary Operators

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

Logical Operators

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

Memory Operators

:load
:store
:get_element_ptr
:trunc

Cast Operators

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

Other Operators

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

Atomic operators

:atomic_cmp_xchg
:atomic_rmw
:resume

Exception Handling Operators

:landing_pad
:unwind

Returns:

  • (Symbol) 


310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File 'lib/rltk/cg/generated_bindings.rb', line 310

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

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


626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
 
# File 'lib/rltk/cg/generated_bindings.rb', line 626

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_model_ ⇒ Symbol

(Not documented)

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

Options:

:default_rmodel
:static
:pic
:dynamic_no_pic

Returns:

  • (Symbol) 


142
143
144
145
146
147
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 142

enum :reloc_model, [
  :default_rmodel, 0,
  :static, 1,
  :pic, 2,
  :dynamic_no_pic, 3
]

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

< type with no size

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


411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/rltk/cg/generated_bindings.rb', line 411

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

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


4832
4833
4834
4835
4836
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4832

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) 


510
511
512
513
514
 
# File 'lib/rltk/cg/generated_bindings.rb', line 510

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

.abi_alignment_of_type(opaque_target_data, opaque_type) ⇒ Integer

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

See the method llvm::TargetData::getTypeABISize.

Parameters:

Returns:



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

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

.abi_size_of_type(opaque_target_data, opaque_type) ⇒ Integer

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

See the method llvm::TargetData::getTypeAllocSize.

Parameters:

Returns:



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

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

.add_aggressive_dce_pass(pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

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

Operations on aliases

Parameters:

Returns:



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

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

.add_always_inliner_pass(pm) ⇒ nil

See llvm::createAlwaysInlinerPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_argument_promotion_pass(pm) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_attribute(arg, pa) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_basic_alias_analysis_pass(pm) ⇒ nil

See llvm::createBasicAliasAnalysisPass function

Parameters:

Returns:

  • (nil) 


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

attach_function :add_basic_alias_analysis_pass, :LLVMAddBasicAliasAnalysisPass, [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.



144
145
146
 
# File 'lib/rltk/cg/bindings.rb', line 144

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) 


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

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

.add_cfg_simplification_pass(pm) ⇒ nil

See llvm::createCFGSimplificationPass function.

Parameters:

Returns:

  • (nil) 


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

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) 


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

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

.add_constant_merge_pass(pm) ⇒ nil

See llvm::createConstantMergePass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_constant_propagation_pass(pm) ⇒ nil

See llvm::createConstantPropagationPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_correlated_value_propagation_pass(pm) ⇒ nil

See llvm::createCorrelatedValuePropagationPass function

Parameters:

Returns:

  • (nil) 


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

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

.add_dead_arg_elimination_pass(pm) ⇒ nil

See llvm::createDeadArgEliminationPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_dead_store_elimination_pass(pm) ⇒ nil

See llvm::createDeadStoreEliminationPass function.

Parameters:

Returns:

  • (nil) 


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

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) 


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

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) 


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

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

.add_early_cse_pass(pm) ⇒ nil

See llvm::createEarlyCSEPass function

Parameters:

Returns:

  • (nil) 


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

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

.add_function(m, name, function_ty) ⇒ OpaqueValue

Operations on functions

Parameters:

Returns:



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

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

.add_function_attr(fn, pa) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_function_attrs_pass(pm) ⇒ nil

See llvm::createFunctionAttrsPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_function_inlining_pass(pm) ⇒ nil

See llvm::createFunctionInliningPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_global(m, ty, name) ⇒ OpaqueValue

Operations on global variables

Parameters:

Returns:



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

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

.add_global_dce_pass(pm) ⇒ nil

See llvm::createGlobalDCEPass function.

Parameters:

Returns:

  • (nil) 


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

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

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

(Not documented)

Parameters:

Returns:



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

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) 


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

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

.add_global_optimizer_pass(pm) ⇒ nil

See llvm::createGlobalOptimizerPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_gvn_pass(pm) ⇒ nil

See llvm::createGVNPass function.

Parameters:

Returns:

  • (nil) 


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

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

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

Operations on phi nodes

Parameters:

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

Returns:

  • (nil) 


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

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

.add_ind_var_simplify_pass(pm) ⇒ nil

See llvm::createIndVarSimplifyPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_instruction_combining_pass(pm) ⇒ nil

See llvm::createInstructionCombiningPass function.

Parameters:

Returns:

  • (nil) 


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

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) 


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

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

.add_ip_constant_propagation_pass(pm) ⇒ nil

See llvm::createIPConstantPropagationPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_ipsccp_pass(pm) ⇒ nil

See llvm::createIPSCCPPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_jump_threading_pass(pm) ⇒ nil

See llvm::createJumpThreadingPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_licm_pass(pm) ⇒ nil

See llvm::createLICMPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_loop_deletion_pass(pm) ⇒ nil

See llvm::createLoopDeletionPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_loop_idiom_pass(pm) ⇒ nil

See llvm::createLoopIdiomPass function

Parameters:

Returns:

  • (nil) 


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

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

.add_loop_rotate_pass(pm) ⇒ nil

See llvm::createLoopRotatePass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_loop_unroll_pass(pm) ⇒ nil

See llvm::createLoopUnrollPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_loop_unswitch_pass(pm) ⇒ nil

See llvm::createLoopUnswitchPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_lower_expect_intrinsic_pass(pm) ⇒ nil

See llvm::createLowerExpectIntrinsicPass function

Parameters:

Returns:

  • (nil) 


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

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

.add_mem_cpy_opt_pass(pm) ⇒ nil

See llvm::createMemCpyOptPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_module(ee, m) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.add_module_provider(ee, mp) ⇒ nil

Deprecated: Use LLVMAddModule instead.

Parameters:

Returns:

  • (nil) 


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

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

.add_promote_memory_to_register_pass(pm) ⇒ nil

See llvm::createPromoteMemoryToRegisterPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_prune_eh_pass(pm) ⇒ nil

See llvm::createPruneEHPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_reassociate_pass(pm) ⇒ nil

See llvm::createReassociatePass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_scalar_repl_aggregates_pass(pm) ⇒ nil

See llvm::createScalarReplAggregatesPass function.

Parameters:

Returns:

  • (nil) 


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

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) 


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

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) 


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

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) 


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

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

.add_simplify_lib_calls_pass(pm) ⇒ nil

See llvm::createSimplifyLibCallsPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_strip_dead_prototypes_pass(pm) ⇒ nil

See llvm::createStripDeadPrototypesPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_strip_symbols_pass(pm) ⇒ nil

See llvm::createStripSymbolsPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_tail_call_elimination_pass(pm) ⇒ nil

See llvm::createTailCallEliminationPass function.

Parameters:

Returns:

  • (nil) 


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

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

.add_target_data(opaque_target_data, opaque_pass_manager) ⇒ 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) 


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

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

.add_target_library_info(opaque_target_library_infot_data, opaque_pass_manager) ⇒ 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) 


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

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) 


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

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

.add_verifier_pass(pm) ⇒ nil

See llvm::createVerifierPass function.

Parameters:

Returns:

  • (nil) 


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

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

.align_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.append_basic_block(fn, name) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

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

.append_basic_block_in_context(c, fn, name) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

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

.array_type(element_type, element_count) ⇒ OpaqueType

Operations on array, pointer, and vector types (sequence types)

Parameters:

Returns:



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

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

Operations on basic blocks

Parameters:

Returns:



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

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

.block_address(f, bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

Arithmetic

Parameters:

Returns:



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

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

.build_aggregate_ret(opaque_builder, ret_vals, n) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_alloca(opaque_builder, ty, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.build_br(opaque_builder, dest) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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:



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

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:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_f_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_features_string(attrs, num_attrs) ⇒ String

// Utility

Parameters:

  • attrs (FFI::Pointer(**CharS))
  • num_attrs (Integer)

Returns:

  • (String) 


189
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 189

attach_function :build_features_string, :LLVMBuildFeaturesString, [:pointer, :int], :string

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

(Not documented)

Parameters:

Returns:



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

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:



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

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:



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

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:



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

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:



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

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

.build_free(opaque_builder, pointer_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_global_string(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_global_string_ptr(b, str, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

Comparisons

Parameters:

Returns:



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

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:



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

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:



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

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:



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

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:



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

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:



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

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:



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

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:



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

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:



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

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

.build_is_null(opaque_builder, val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.build_load(opaque_builder, pointer_val, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_malloc(opaque_builder, ty, name) ⇒ OpaqueValue

Memory

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_neg(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_not(opaque_builder, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_nsw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_nuw_neg(b, v, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.build_phi(opaque_builder, ty, name) ⇒ OpaqueValue

Miscellaneous instructions

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.build_resume(b, exn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_ret(opaque_builder, v) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.build_ret_void(opaque_builder) ⇒ OpaqueValue

Terminators

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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:



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

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:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.build_store(opaque_builder, val, ptr) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

Casts

Parameters:

Returns:



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

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:



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

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:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.build_unreachable(opaque_builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.byte_order(opaque_target_data) ⇒ Symbol from _enum_byte_ordering_

Returns the byte order of a target, either LLVMBigEndian or

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

Parameters:

Returns:



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

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

.call_frame_alignment_of_type(opaque_target_data, opaque_type) ⇒ Integer

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

See the method llvm::TargetData::getTypeABISize.

Parameters:

Returns:



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

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

.clear_insertion_position(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.compile_module_to_file(mod, machine, pm, file_name, ctype, opt_level, no_verify) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


203
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 203

attach_function :compile_module_to_file, :LLVMCompileModuleToFile, [:pointer, OpaqueTargetMachine, :pointer, :string, :compile_type, :uint, :uint], :void

.const_a_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_all_ones(ty) ⇒ OpaqueValue

all zeroes

Parameters:

Returns:



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

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

.const_and(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_array(element_ty, constant_vals, length) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_exact_s_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_extract_element(vector_constant, index_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_extract_value(agg_constant, idx_list, num_idx) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_f_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_fp_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_fp_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_fp_to_si(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_fp_to_ui(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_fp_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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:



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

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

.const_i_cmp(predicate, lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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:



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

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:

Returns:



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

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:



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

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:

Returns:



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

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

.const_int(int_ty, n, sign_extend) ⇒ OpaqueValue

Operations on scalar constants

Parameters:

Returns:



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

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

.const_int_cast(constant_val, to_type, is_signed) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_int_get_s_ext_value(constant_val) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.const_int_get_z_ext_value(constant_val) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.const_int_of_arbitrary_precision(int_ty, num_words, words) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_int_of_string(int_ty, text, radix) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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:



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

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

.const_l_shr(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_named_struct(struct_ty, constant_vals, count) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_not(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nsw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nsw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nsw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nsw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_null(ty) ⇒ OpaqueValue

Operations on constants of any type

Parameters:

Returns:



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

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

.const_nuw_add(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nuw_mul(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nuw_neg(constant_val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_nuw_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_or(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_pointer_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_pointer_null(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_ptr_to_int(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_real(real_ty, n) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_real_of_string(real_ty, text) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_real_of_string_and_size(real_ty, text, s_len) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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:



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

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

.const_s_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_s_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_s_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_select(constant_condition, constant_if_true, constant_if_false) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_shl(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_shuffle_vector(vector_a_constant, vector_b_constant, mask_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_si_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_string(str, length, dont_null_terminate) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

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

Operations on composite constants

Parameters:

Returns:



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

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

.const_struct(constant_vals, count, packed) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

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

(Not documented)

Parameters:

Returns:



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

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

.const_sub(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_trunc(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_trunc_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_u_div(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_u_rem(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_ui_to_fp(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_vector(scalar_constant_vals, size) ⇒ OpaqueValue

(Not documented)

Parameters:

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

Returns:



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

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

.const_xor(lhs_constant, rhs_constant) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_z_ext(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.const_z_ext_or_bit_cast(constant_val, to_type) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.context_create ⇒ OpaqueContext

Create and destroy contexts.

Returns:



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

attach_function :context_create, :LLVMContextCreate, [], OpaqueContext

.context_dispose(c) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.copy_string_rep_of_target_data(opaque_target_data) ⇒ String

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

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

Parameters:

Returns:

  • (String) 


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

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

.count_basic_blocks(fn) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.count_incoming(phi_node) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.count_param_types(function_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.count_params(fn) ⇒ Integer

Operations on parameters

Parameters:

Returns:



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

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

.count_struct_element_types(struct_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.create_builder ⇒ OpaqueBuilder

(Not documented)

Returns:



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

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:



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

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.

Parameters:

Returns:

  • (FFI::Pointer(DisasmContextRef)) 


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

attach_function :create_disasm, :LLVMCreateDisasm, [: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:



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

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:



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

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

.create_function_pass_manager(mp) ⇒ OpaquePassManager

Deprecated: Use LLVMCreateFunctionPassManagerForModule instead.

Parameters:

Returns:



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

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:



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

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

.create_generic_value_of_float(ty, n) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

Returns:



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

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:



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

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:



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

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:



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

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:



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

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:

Returns:



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

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:



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

attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, OpaqueModule, :uint, :pointer], :int

.create_memory_buffer_with_contents_of_file(path, out_mem_buf, out_message) ⇒ Integer

– Memory buffers —————————————————-===

Parameters:

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

Returns:



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

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

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



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

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

.create_module_provider_for_existing_module(m) ⇒ OpaqueModuleProvider

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

Parameters:

Returns:



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

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

.create_object_file(mem_buf) ⇒ OpaqueObjectFile

(Not documented)

Parameters:

Returns:



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

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:



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

attach_function :create_pass_manager, :LLVMCreatePassManager, [], OpaquePassManager

.create_target_data(string_rep) ⇒ OpaqueTargetData

Creates target data from a target layout string.

See the constructor llvm::TargetData::TargetData.

Parameters:

  • string_rep (String)

Returns:



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

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

.create_target_machine(target, triple, mcpu, features, rmodel, cmodel) ⇒ OpaqueTargetMachine

// Target Machine

Parameters:

Returns:



246
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 246

attach_function :create_target_machine, :LLVMCreateTargetMachine, [OpaqueTarget, :string, :string, :string, :reloc_model, :code_model], OpaqueTargetMachine

.delete_basic_block(bb) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.delete_function(fn) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.delete_global(global_var) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.disasm_dispose(dc) ⇒ nil

Dispose of a disassembler context.

Parameters:

  • dc (FFI::Pointer(DisasmContextRef))

Returns:

  • (nil) 


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

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

.disasm_instruction ⇒ 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.

Returns:



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

attach_function :disasm_instruction, :LLVMDisasmInstruction, [], :int

.dispose_builder(builder) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.dispose_execution_engine(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.dispose_generic_value(gen_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.dispose_memory_buffer(mem_buf) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.dispose_message(message) ⇒ nil

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

Parameters:

  • message (String)

Returns:

  • (nil) 


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

attach_function :dispose_message, :LLVMDisposeMessage, [:string], :void

.dispose_module(m) ⇒ nil

See llvm::Module::~Module.

Parameters:

Returns:

  • (nil) 


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

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

.dispose_module_provider(m) ⇒ nil

Destroys the module M.

Parameters:

Returns:

  • (nil) 


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

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

.dispose_object_file(object_file) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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) 


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

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

.dispose_section_iterator(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.dispose_target_data(opaque_target_data) ⇒ nil

Deallocates a TargetData.

See the destructor llvm::TargetData::~TargetData.

Parameters:

Returns:

  • (nil) 


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

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

.double_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :double_type, :LLVMDoubleType, [], OpaqueType

.double_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

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

.dump_module(m) ⇒ nil

See Module::dump.

Parameters:

Returns:

  • (nil) 


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

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

.dump_value(val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

.ecb? ⇒ Boolean

Returns If the Extended C Bindings for LLVM are present.

Returns:

  • (Boolean) —

    If the Extended C Bindings for LLVM are present.



123
124
125
 
# File 'lib/rltk/cg/bindings.rb', line 123

def self.ecb?
	@ecb
end

.ecb_initialize_all_targets ⇒ nil

(Not documented)

Returns:

  • (nil) 


210
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 210

attach_function :ecb_initialize_all_targets, :LLVMECBInitializeAllTargets, [], :void

.ecb_initialize_native_target ⇒ nil

(Not documented)

Returns:

  • (nil) 


217
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 217

attach_function :ecb_initialize_native_target, :LLVMECBInitializeNativeTarget, [], :void

.ecb_version ⇒ String

(Not documented)

Returns:

  • (String) 


26
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 26

attach_function :ecb_version, :LLVMECBVersion, [], :string

.element_at_offset(opaque_target_data, struct_ty, offset) ⇒ Integer

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

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

Returns:



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

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

.finalize_function_pass_manager(fpm) ⇒ Integer

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

manager. Returns 1 if any of the passes modified the module, 0 otherwise.
See llvm::FunctionPassManager::doFinalization.

Parameters:

Returns:



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

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

.find_function(ee, name, out_fn) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.float_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :float_type, :LLVMFloatType, [], OpaqueType

.float_type_in_context(c) ⇒ OpaqueType

Operations on real types

Parameters:

Returns:



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

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

.fp128_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :fp128_type, :LLVMFP128Type, [], OpaqueType

.fp128_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

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

.free_machine_code_for_function(ee, f) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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

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

Operations on function types

Parameters:

Returns:



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

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

.generic_value_int_width(gen_val_ref) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.generic_value_to_float(ty_ref, gen_val) ⇒ Float

(Not documented)

Parameters:

Returns:



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

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

.generic_value_to_int(gen_val, is_signed) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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


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

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

.get_alignment(global) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.get_array_length(array_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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

.get_attribute(arg) ⇒ Symbol from _enum_attribute_

(Not documented)

Parameters:

Returns:



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

attach_function :get_attribute, :LLVMGetAttribute, [OpaqueValue], :attribute

.get_basic_block_parent(bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_basic_block_parent, :LLVMGetBasicBlockParent, [OpaqueBasicBlock], OpaqueValue

.get_basic_block_terminator(bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_basic_block_terminator, :LLVMGetBasicBlockTerminator, [OpaqueBasicBlock], OpaqueValue

.get_basic_blocks(fn, basic_blocks) ⇒ nil

(Not documented)

Parameters:

  • fn (OpaqueValue)
  • basic_blocks (FFI::Pointer(*BasicBlockRef))

Returns:

  • (nil) 


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

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:



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

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:



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

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:



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

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:



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

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.



132
133
134
135
136
137
 
# File 'lib/rltk/cg/bindings.rb', line 132

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_const_opcode(constant_val) ⇒ Symbol from _enum_opcode_

Constant expressions

Parameters:

Returns:



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

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

.get_current_debug_location(builder) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_current_debug_location, :LLVMGetCurrentDebugLocation, [OpaqueBuilder], OpaqueValue

.get_data_layout(m) ⇒ String

Data layout. See Module::getDataLayout.

Parameters:

Returns:

  • (String) 


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

attach_function :get_data_layout, :LLVMGetDataLayout, [OpaqueModule], :string

.get_element_type(ty) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :get_element_type, :LLVMGetElementType, [OpaqueType], OpaqueType

.get_entry_basic_block(fn) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

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

.get_execution_engine_target_data(ee) ⇒ OpaqueTargetData

(Not documented)

Parameters:

Returns:



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

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

.get_first_basic_block(fn) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_first_basic_block, :LLVMGetFirstBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_first_function(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.get_first_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_first_global, :LLVMGetFirstGlobal, [OpaqueModule], OpaqueValue

.get_first_instruction(bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_first_instruction, :LLVMGetFirstInstruction, [OpaqueBasicBlock], OpaqueValue

.get_first_param(fn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.get_first_use(val) ⇒ OpaqueUse

Operations on Uses

Parameters:

Returns:



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

attach_function :get_first_use, :LLVMGetFirstUse, [OpaqueValue], OpaqueUse

.get_function_attr(fn) ⇒ Symbol from _enum_attribute_

(Not documented)

Parameters:

Returns:



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

attach_function :get_function_attr, :LLVMGetFunctionAttr, [OpaqueValue], :attribute

.get_function_call_conv(fn) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_function_call_conv, :LLVMGetFunctionCallConv, [OpaqueValue], :uint

.get_gc(fn) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

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

.get_global_context ⇒ OpaqueContext

(Not documented)

Returns:



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

attach_function :get_global_context, :LLVMGetGlobalContext, [], OpaqueContext

.get_global_parent(global) ⇒ OpaqueModule

Operations on global variables, functions, and aliases (globals)

Parameters:

Returns:



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

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:



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

attach_function :get_global_pass_registry, :LLVMGetGlobalPassRegistry, [], OpaquePassRegistry

.get_host_triple ⇒ OpaqueTriple

// Triple

Returns:



262
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 262

attach_function :get_host_triple, :LLVMGetHostTriple, [], OpaqueTriple

.get_host_triple_string ⇒ String

(Not documented)

Returns:

  • (String) 


269
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 269

attach_function :get_host_triple_string, :LLVMGetHostTripleString, [], :string

.get_i_cmp_predicate(inst) ⇒ Symbol from _enum_int_predicate_

(Not documented)

Parameters:

Returns:



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

attach_function :get_i_cmp_predicate, :LLVMGetICmpPredicate, [OpaqueValue], :int_predicate

.get_incoming_block(phi_node, index) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_incoming_block, :LLVMGetIncomingBlock, [OpaqueValue, :uint], OpaqueBasicBlock

.get_incoming_value(phi_node, index) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.get_initializer(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

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

.get_insert_block(builder) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_insert_block, :LLVMGetInsertBlock, [OpaqueBuilder], OpaqueBasicBlock

.get_instruction_call_conv(instr) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_instruction_call_conv, :LLVMGetInstructionCallConv, [OpaqueValue], :uint

.get_instruction_opcode(inst) ⇒ Symbol from _enum_opcode_

(Not documented)

Parameters:

Returns:



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

attach_function :get_instruction_opcode, :LLVMGetInstructionOpcode, [OpaqueValue], :opcode

.get_instruction_parent(inst) ⇒ OpaqueBasicBlock

Operations on instructions

Parameters:

Returns:



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

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

.get_int_type_width(integer_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_int_type_width, :LLVMGetIntTypeWidth, [OpaqueType], :uint

.get_intrinsic_id(fn) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_intrinsic_id, :LLVMGetIntrinsicID, [OpaqueValue], :uint

.get_last_basic_block(fn) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_basic_block, :LLVMGetLastBasicBlock, [OpaqueValue], OpaqueBasicBlock

.get_last_function(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_function, :LLVMGetLastFunction, [OpaqueModule], OpaqueValue

.get_last_global(m) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_global, :LLVMGetLastGlobal, [OpaqueModule], OpaqueValue

.get_last_instruction(bb) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_instruction, :LLVMGetLastInstruction, [OpaqueBasicBlock], OpaqueValue

.get_last_param(fn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_last_param, :LLVMGetLastParam, [OpaqueValue], OpaqueValue

.get_linkage(global) ⇒ Symbol from _enum_linkage_

(Not documented)

Parameters:

Returns:



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

attach_function :get_linkage, :LLVMGetLinkage, [OpaqueValue], :linkage

.get_md_kind_id(name, s_len) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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:



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

attach_function :get_md_kind_id_in_context, :LLVMGetMDKindIDInContext, [OpaqueContext, :string, :uint], :uint

.get_md_node_num_operands(v) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_md_node_num_operands, :LLVMGetMDNodeNumOperands, [OpaqueValue], :int

.get_md_node_operand(v, i) ⇒ FFI::Pointer(*ValueRef)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*ValueRef)) 


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

attach_function :get_md_node_operand, :LLVMGetMDNodeOperand, [OpaqueValue, :uint], :pointer

.get_md_string(v, len) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_md_string, :LLVMGetMDString, [OpaqueValue, :pointer], :string

.get_metadata(val, kind_id) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_metadata, :LLVMGetMetadata, [OpaqueValue, :uint], OpaqueValue

.get_module_context(m) ⇒ OpaqueContext

See Module::getContext.

Parameters:

Returns:



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

attach_function :get_module_context, :LLVMGetModuleContext, [OpaqueModule], OpaqueContext

.get_named_function(m, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_named_function, :LLVMGetNamedFunction, [OpaqueModule, :string], OpaqueValue

.get_named_global(m, name) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_named_global, :LLVMGetNamedGlobal, [OpaqueModule, :string], OpaqueValue

.get_named_metadata_num_operands(m, name) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_named_metadata_num_operands, :LLVMGetNamedMetadataNumOperands, [OpaqueModule, :string], :uint

.get_named_metadata_operands(m, name, dest) ⇒ nil

(Not documented)

Parameters:

  • m (OpaqueModule)
  • name (String)
  • dest (FFI::Pointer(*ValueRef))

Returns:

  • (nil) 


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

attach_function :get_named_metadata_operands, :LLVMGetNamedMetadataOperands, [OpaqueModule, :string, :pointer], :void

.get_next_basic_block(bb) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_basic_block, :LLVMGetNextBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_next_function(fn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_function, :LLVMGetNextFunction, [OpaqueValue], OpaqueValue

.get_next_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_global, :LLVMGetNextGlobal, [OpaqueValue], OpaqueValue

.get_next_instruction(inst) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_instruction, :LLVMGetNextInstruction, [OpaqueValue], OpaqueValue

.get_next_param(arg) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_param, :LLVMGetNextParam, [OpaqueValue], OpaqueValue

.get_next_use(u) ⇒ OpaqueUse

(Not documented)

Parameters:

Returns:



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

attach_function :get_next_use, :LLVMGetNextUse, [OpaqueUse], OpaqueUse

.get_num_operands(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_num_operands, :LLVMGetNumOperands, [OpaqueValue], :int

.get_operand(val, index) ⇒ OpaqueValue

Operations on Users

Parameters:

Returns:



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

attach_function :get_operand, :LLVMGetOperand, [OpaqueValue, :uint], OpaqueValue

.get_param(fn, index) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_param, :LLVMGetParam, [OpaqueValue, :uint], OpaqueValue

.get_param_parent(inst) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_param_parent, :LLVMGetParamParent, [OpaqueValue], OpaqueValue

.get_param_types(function_ty, dest) ⇒ nil

(Not documented)

Parameters:

  • function_ty (OpaqueType)
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil) 


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

attach_function :get_param_types, :LLVMGetParamTypes, [OpaqueType, :pointer], :void

.get_params(fn, params) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :get_params, :LLVMGetParams, [OpaqueValue, :pointer], :void

.get_pointer_address_space(pointer_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

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


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

attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, OpaqueValue], :pointer

.get_previous_basic_block(bb) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_basic_block, :LLVMGetPreviousBasicBlock, [OpaqueBasicBlock], OpaqueBasicBlock

.get_previous_function(fn) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_function, :LLVMGetPreviousFunction, [OpaqueValue], OpaqueValue

.get_previous_global(global_var) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_global, :LLVMGetPreviousGlobal, [OpaqueValue], OpaqueValue

.get_previous_instruction(inst) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_instruction, :LLVMGetPreviousInstruction, [OpaqueValue], OpaqueValue

.get_previous_param(arg) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_previous_param, :LLVMGetPreviousParam, [OpaqueValue], OpaqueValue

.get_return_type(function_ty) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :get_return_type, :LLVMGetReturnType, [OpaqueType], OpaqueType

.get_section(global) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_section, :LLVMGetSection, [OpaqueValue], :string

.get_section_contents(si) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_section_contents, :LLVMGetSectionContents, [OpaqueSectionIterator], :string

.get_section_name(si) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_section_name, :LLVMGetSectionName, [OpaqueSectionIterator], :string

.get_section_size(si) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_section_size, :LLVMGetSectionSize, [OpaqueSectionIterator], :ulong

.get_sections(object_file) ⇒ OpaqueSectionIterator

(Not documented)

Parameters:

Returns:



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

attach_function :get_sections, :LLVMGetSections, [OpaqueObjectFile], OpaqueSectionIterator

.get_struct_element_types(struct_ty, dest) ⇒ nil

(Not documented)

Parameters:

  • struct_ty (OpaqueType)
  • dest (FFI::Pointer(*TypeRef))

Returns:

  • (nil) 


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

attach_function :get_struct_element_types, :LLVMGetStructElementTypes, [OpaqueType, :pointer], :void

.get_struct_name(ty) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_struct_name, :LLVMGetStructName, [OpaqueType], :string

.get_switch_default_dest(switch_instr) ⇒ OpaqueBasicBlock

Operations on switch instructions (only)

Parameters:

Returns:



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

attach_function :get_switch_default_dest, :LLVMGetSwitchDefaultDest, [OpaqueValue], OpaqueBasicBlock

.get_target(m) ⇒ String

Target triple. See Module::getTargetTriple.

Parameters:

Returns:

  • (String) 


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

attach_function :get_target, :LLVMGetTarget, [OpaqueModule], :string

.get_target_from_name(name) ⇒ OpaqueTarget

// Target

Parameters:

  • name (String)

Returns:



225
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 225

attach_function :get_target_from_name, :LLVMGetTargetFromName, [:string], OpaqueTarget

.get_target_from_triple(triple) ⇒ OpaqueTarget

(Not documented)

Parameters:

Returns:



233
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 233

attach_function :get_target_from_triple, :LLVMGetTargetFromTriple, [OpaqueTriple], OpaqueTarget

.get_triple_string(triple) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


277
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 277

attach_function :get_triple_string, :LLVMGetTripleString, [OpaqueTriple], :string

.get_type_by_name(m, name) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :get_type_by_name, :LLVMGetTypeByName, [OpaqueModule, :string], OpaqueType

.get_type_context(ty) ⇒ OpaqueContext

See llvm::LLVMType::getContext.

Parameters:

Returns:



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

attach_function :get_type_context, :LLVMGetTypeContext, [OpaqueType], OpaqueContext

.get_type_kind(ty) ⇒ Symbol from _enum_type_kind_

See llvm::LLVMTypeKind::getTypeID.

Parameters:

Returns:



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

attach_function :get_type_kind, :LLVMGetTypeKind, [OpaqueType], :type_kind

.get_undef(ty) ⇒ OpaqueValue

only for int/vector

Parameters:

Returns:



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

attach_function :get_undef, :LLVMGetUndef, [OpaqueType], OpaqueValue

.get_used_value(u) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_used_value, :LLVMGetUsedValue, [OpaqueUse], OpaqueValue

.get_user(u) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :get_user, :LLVMGetUser, [OpaqueUse], OpaqueValue

.get_value_name(val) ⇒ String

(Not documented)

Parameters:

Returns:

  • (String) 


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

attach_function :get_value_name, :LLVMGetValueName, [OpaqueValue], :string

.get_vector_size(vector_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :get_vector_size, :LLVMGetVectorSize, [OpaqueType], :uint

.get_visibility(global) ⇒ Symbol from _enum_visibility_

(Not documented)

Parameters:

Returns:



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

attach_function :get_visibility, :LLVMGetVisibility, [OpaqueValue], :visibility

.has_metadata(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



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

attach_function :has_metadata, :LLVMHasMetadata, [OpaqueValue], :int

.initialize_all_asm_parsers ⇒ nil

(Not documented)

Returns:

  • (nil) 


40
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 40

attach_function :initialize_all_asm_parsers, :LLVMInitializeAllAsmParsers, [], :void

.initialize_all_asm_printers ⇒ nil

(Not documented)

Returns:

  • (nil) 


47
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 47

attach_function :initialize_all_asm_printers, :LLVMInitializeAllAsmPrinters, [], :void

.initialize_all_target_infos ⇒ nil

(Not documented)

Returns:

  • (nil) 


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

attach_function :initialize_all_target_infos, :LLVMInitializeAllTargetInfos, [], :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) 


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

attach_function :initialize_all_targets, :LLVMInitializeAllTargets, [], :void

.initialize_analysis(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_analysis, :LLVMInitializeAnalysis, [OpaquePassRegistry], :void

.initialize_code_gen(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_code_gen, :LLVMInitializeCodeGen, [OpaquePassRegistry], :void

.initialize_core(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

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:



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

attach_function :initialize_function_pass_manager, :LLVMInitializeFunctionPassManager, [OpaquePassManager], :int

.initialize_inst_combine(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_inst_combine, :LLVMInitializeInstCombine, [OpaquePassRegistry], :void

.initialize_instrumentation(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_instrumentation, :LLVMInitializeInstrumentation, [OpaquePassRegistry], :void

.initialize_ipa(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_ipa, :LLVMInitializeIPA, [OpaquePassRegistry], :void

.initialize_ipo(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_ipo, :LLVMInitializeIPO, [OpaquePassRegistry], :void

.initialize_native_target ⇒ Integer

LLVMInitializeNativeTarget - The main program should call this function to

initialize the native target corresponding to the host.  This is useful 
for JIT applications to ensure that the target gets linked in correctly.

Returns:



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

attach_function :initialize_native_target, :LLVMInitializeNativeTarget, [], :int

.initialize_native_target_asm_parser ⇒ nil

(Not documented)

Returns:

  • (nil) 


54
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 54

attach_function :initialize_native_target_asm_parser, :LLVMInitializeNativeTargetAsmParser, [], :void

.initialize_native_target_asm_printer ⇒ nil

(Not documented)

Returns:

  • (nil) 


61
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 61

attach_function :initialize_native_target_asm_printer, :LLVMInitializeNativeTargetAsmPrinter, [], :void

.initialize_scalar_opts(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_scalar_opts, :LLVMInitializeScalarOpts, [OpaquePassRegistry], :void

.initialize_target(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_target, :LLVMInitializeTarget, [OpaquePassRegistry], :void

.initialize_transform_utils(r) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :initialize_transform_utils, :LLVMInitializeTransformUtils, [OpaquePassRegistry], :void

.insert_basic_block(insert_before_bb, name) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :insert_basic_block, :LLVMInsertBasicBlock, [OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_basic_block_in_context(c, bb, name) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



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

attach_function :insert_basic_block_in_context, :LLVMInsertBasicBlockInContext, [OpaqueContext, OpaqueBasicBlock, :string], OpaqueBasicBlock

.insert_into_builder(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :insert_into_builder, :LLVMInsertIntoBuilder, [OpaqueBuilder, OpaqueValue], :void

.insert_into_builder_with_name(builder, instr, name) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :insert_into_builder_with_name, :LLVMInsertIntoBuilderWithName, [OpaqueBuilder, OpaqueValue, :string], :void

.instruction_erase_from_parent(inst) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


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

attach_function :instruction_erase_from_parent, :LLVMInstructionEraseFromParent, [OpaqueValue], :void

.int16_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int16_type, :LLVMInt16Type, [], OpaqueType

.int16_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int16_type_in_context, :LLVMInt16TypeInContext, [OpaqueContext], OpaqueType

.int1_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int1_type, :LLVMInt1Type, [], OpaqueType

.int1_type_in_context(c) ⇒ OpaqueType

Operations on integer types

Parameters:

Returns:



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

attach_function :int1_type_in_context, :LLVMInt1TypeInContext, [OpaqueContext], OpaqueType

.int32_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int32_type, :LLVMInt32Type, [], OpaqueType

.int32_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int32_type_in_context, :LLVMInt32TypeInContext, [OpaqueContext], OpaqueType

.int64_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int64_type, :LLVMInt64Type, [], OpaqueType

.int64_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int64_type_in_context, :LLVMInt64TypeInContext, [OpaqueContext], OpaqueType

.int8_type ⇒ OpaqueType

(Not documented)

Returns:



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

attach_function :int8_type, :LLVMInt8Type, [], OpaqueType

.int8_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int8_type_in_context, :LLVMInt8TypeInContext, [OpaqueContext], OpaqueType

.int_ptr_type(opaque_target_data) ⇒ OpaqueType

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

See the method llvm::TargetData::getIntPtrType.

Parameters:

Returns:



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

attach_function :int_ptr_type, :LLVMIntPtrType, [OpaqueTargetData], OpaqueType

.int_type(num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int_type, :LLVMIntType, [:uint], OpaqueType

.int_type_in_context(c, num_bits) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



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

attach_function :int_type_in_context, :LLVMIntTypeInContext, [OpaqueContext, :uint], OpaqueType

.is_a_alloca_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_alloca_inst, :LLVMIsAAllocaInst, [OpaqueValue], OpaqueValue

.is_a_argument(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_argument, :LLVMIsAArgument, [OpaqueValue], OpaqueValue

.is_a_basic_block(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_basic_block, :LLVMIsABasicBlock, [OpaqueValue], OpaqueValue

.is_a_binary_operator(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_binary_operator, :LLVMIsABinaryOperator, [OpaqueValue], OpaqueValue

.is_a_bit_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_bit_cast_inst, :LLVMIsABitCastInst, [OpaqueValue], OpaqueValue

.is_a_block_address(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_block_address, :LLVMIsABlockAddress, [OpaqueValue], OpaqueValue

.is_a_branch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_branch_inst, :LLVMIsABranchInst, [OpaqueValue], OpaqueValue

.is_a_call_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_call_inst, :LLVMIsACallInst, [OpaqueValue], OpaqueValue

.is_a_cast_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_cast_inst, :LLVMIsACastInst, [OpaqueValue], OpaqueValue

.is_a_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_cmp_inst, :LLVMIsACmpInst, [OpaqueValue], OpaqueValue

.is_a_constant(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant, :LLVMIsAConstant, [OpaqueValue], OpaqueValue

.is_a_constant_aggregate_zero(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_aggregate_zero, :LLVMIsAConstantAggregateZero, [OpaqueValue], OpaqueValue

.is_a_constant_array(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_array, :LLVMIsAConstantArray, [OpaqueValue], OpaqueValue

.is_a_constant_expr(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_expr, :LLVMIsAConstantExpr, [OpaqueValue], OpaqueValue

.is_a_constant_fp(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_fp, :LLVMIsAConstantFP, [OpaqueValue], OpaqueValue

.is_a_constant_int(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_int, :LLVMIsAConstantInt, [OpaqueValue], OpaqueValue

.is_a_constant_pointer_null(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_pointer_null, :LLVMIsAConstantPointerNull, [OpaqueValue], OpaqueValue

.is_a_constant_struct(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_struct, :LLVMIsAConstantStruct, [OpaqueValue], OpaqueValue

.is_a_constant_vector(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_constant_vector, :LLVMIsAConstantVector, [OpaqueValue], OpaqueValue

.is_a_dbg_declare_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_dbg_declare_inst, :LLVMIsADbgDeclareInst, [OpaqueValue], OpaqueValue

.is_a_dbg_info_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_dbg_info_intrinsic, :LLVMIsADbgInfoIntrinsic, [OpaqueValue], OpaqueValue

.is_a_extract_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_extract_element_inst, :LLVMIsAExtractElementInst, [OpaqueValue], OpaqueValue

.is_a_extract_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_extract_value_inst, :LLVMIsAExtractValueInst, [OpaqueValue], OpaqueValue

.is_a_function(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_function, :LLVMIsAFunction, [OpaqueValue], OpaqueValue

.is_a_get_element_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_get_element_ptr_inst, :LLVMIsAGetElementPtrInst, [OpaqueValue], OpaqueValue

.is_a_global_alias(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_global_alias, :LLVMIsAGlobalAlias, [OpaqueValue], OpaqueValue

.is_a_global_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_global_value, :LLVMIsAGlobalValue, [OpaqueValue], OpaqueValue

.is_a_global_variable(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_global_variable, :LLVMIsAGlobalVariable, [OpaqueValue], OpaqueValue

.is_a_indirect_br_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_indirect_br_inst, :LLVMIsAIndirectBrInst, [OpaqueValue], OpaqueValue

.is_a_inline_asm(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_inline_asm, :LLVMIsAInlineAsm, [OpaqueValue], OpaqueValue

.is_a_insert_element_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_insert_element_inst, :LLVMIsAInsertElementInst, [OpaqueValue], OpaqueValue

.is_a_insert_value_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_insert_value_inst, :LLVMIsAInsertValueInst, [OpaqueValue], OpaqueValue

.is_a_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_instruction, :LLVMIsAInstruction, [OpaqueValue], OpaqueValue

.is_a_int_to_ptr_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_int_to_ptr_inst, :LLVMIsAIntToPtrInst, [OpaqueValue], OpaqueValue

.is_a_intrinsic_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_intrinsic_inst, :LLVMIsAIntrinsicInst, [OpaqueValue], OpaqueValue

.is_a_invoke_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_invoke_inst, :LLVMIsAInvokeInst, [OpaqueValue], OpaqueValue

.is_a_landing_pad_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_landing_pad_inst, :LLVMIsALandingPadInst, [OpaqueValue], OpaqueValue

.is_a_load_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_load_inst, :LLVMIsALoadInst, [OpaqueValue], OpaqueValue

.is_a_mem_cpy_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_mem_cpy_inst, :LLVMIsAMemCpyInst, [OpaqueValue], OpaqueValue

.is_a_mem_intrinsic(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



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

attach_function :is_a_mem_intrinsic, :LLVMIsAMemIntrinsic, [OpaqueValue], OpaqueValue

.is_a_mem_move_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1565
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1565

attach_function :is_a_mem_move_inst, :LLVMIsAMemMoveInst, [OpaqueValue], OpaqueValue

.is_a_mem_set_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1573
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1573

attach_function :is_a_mem_set_inst, :LLVMIsAMemSetInst, [OpaqueValue], OpaqueValue

.is_a_ptr_to_int_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1813
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1813

attach_function :is_a_ptr_to_int_inst, :LLVMIsAPtrToIntInst, [OpaqueValue], OpaqueValue

.is_a_resume_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1733
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1733

attach_function :is_a_resume_inst, :LLVMIsAResumeInst, [OpaqueValue], OpaqueValue

.is_a_return_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1709
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1709

attach_function :is_a_return_inst, :LLVMIsAReturnInst, [OpaqueValue], OpaqueValue

.is_a_select_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1653
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1653

attach_function :is_a_select_inst, :LLVMIsASelectInst, [OpaqueValue], OpaqueValue

.is_a_shuffle_vector_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1661
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1661

attach_function :is_a_shuffle_vector_inst, :LLVMIsAShuffleVectorInst, [OpaqueValue], OpaqueValue

.is_a_store_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1669
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1669

attach_function :is_a_store_inst, :LLVMIsAStoreInst, [OpaqueValue], OpaqueValue

.is_a_switch_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1717
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1717

attach_function :is_a_switch_inst, :LLVMIsASwitchInst, [OpaqueValue], OpaqueValue

.is_a_terminator_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1677
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1677

attach_function :is_a_terminator_inst, :LLVMIsATerminatorInst, [OpaqueValue], OpaqueValue

.is_a_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1837
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1837

attach_function :is_a_trunc_inst, :LLVMIsATruncInst, [OpaqueValue], OpaqueValue

.is_a_unary_instruction(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1741
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1741

attach_function :is_a_unary_instruction, :LLVMIsAUnaryInstruction, [OpaqueValue], OpaqueValue

.is_a_undef_value(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1477
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1477

attach_function :is_a_undef_value, :LLVMIsAUndefValue, [OpaqueValue], OpaqueValue

.is_a_unreachable_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1725
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1725

attach_function :is_a_unreachable_inst, :LLVMIsAUnreachableInst, [OpaqueValue], OpaqueValue

.is_a_user(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1357
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1357

attach_function :is_a_user, :LLVMIsAUser, [OpaqueValue], OpaqueValue

.is_aeh_exception_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1533
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1533

attach_function :is_aeh_exception_inst, :LLVMIsAEHExceptionInst, [OpaqueValue], OpaqueValue

.is_aeh_selector_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1541
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1541

attach_function :is_aeh_selector_inst, :LLVMIsAEHSelectorInst, [OpaqueValue], OpaqueValue

.is_af_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1589
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1589

attach_function :is_af_cmp_inst, :LLVMIsAFCmpInst, [OpaqueValue], OpaqueValue

.is_afp_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1773
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1773

attach_function :is_afp_ext_inst, :LLVMIsAFPExtInst, [OpaqueValue], OpaqueValue

.is_afp_to_si_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1781
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1781

attach_function :is_afp_to_si_inst, :LLVMIsAFPToSIInst, [OpaqueValue], OpaqueValue

.is_afp_to_ui_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1789
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1789

attach_function :is_afp_to_ui_inst, :LLVMIsAFPToUIInst, [OpaqueValue], OpaqueValue

.is_afp_trunc_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1797
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1797

attach_function :is_afp_trunc_inst, :LLVMIsAFPTruncInst, [OpaqueValue], OpaqueValue

.is_ai_cmp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1597
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1597

attach_function :is_ai_cmp_inst, :LLVMIsAICmpInst, [OpaqueValue], OpaqueValue

.is_amd_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1341
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1341

attach_function :is_amd_node, :LLVMIsAMDNode, [OpaqueValue], OpaqueValue

.is_amd_string(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1349
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1349

attach_function :is_amd_string, :LLVMIsAMDString, [OpaqueValue], OpaqueValue

.is_aphi_node(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1645
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1645

attach_function :is_aphi_node, :LLVMIsAPHINode, [OpaqueValue], OpaqueValue

.is_as_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1821
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1821

attach_function :is_as_ext_inst, :LLVMIsASExtInst, [OpaqueValue], OpaqueValue

.is_asi_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1829
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1829

attach_function :is_asi_to_fp_inst, :LLVMIsASIToFPInst, [OpaqueValue], OpaqueValue

.is_aui_to_fp_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1845
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1845

attach_function :is_aui_to_fp_inst, :LLVMIsAUIToFPInst, [OpaqueValue], OpaqueValue

.is_ava_arg_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1877
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1877

attach_function :is_ava_arg_inst, :LLVMIsAVAArgInst, [OpaqueValue], OpaqueValue

.is_az_ext_inst(val) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



1853
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1853

attach_function :is_az_ext_inst, :LLVMIsAZExtInst, [OpaqueValue], OpaqueValue

.is_constant(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



1968
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1968

attach_function :is_constant, :LLVMIsConstant, [OpaqueValue], :int

.is_declaration(global) ⇒ Integer

(Not documented)

Parameters:

Returns:



2820
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2820

attach_function :is_declaration, :LLVMIsDeclaration, [OpaqueValue], :int

.is_function_var_arg(function_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



1020
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1020

attach_function :is_function_var_arg, :LLVMIsFunctionVarArg, [OpaqueType], :int

.is_global_constant(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:



3000
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3000

attach_function :is_global_constant, :LLVMIsGlobalConstant, [OpaqueValue], :int

.is_null(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



1976
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1976

attach_function :is_null, :LLVMIsNull, [OpaqueValue], :int

.is_opaque_struct(struct_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



1127
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1127

attach_function :is_opaque_struct, :LLVMIsOpaqueStruct, [OpaqueType], :int

.is_packed_struct(struct_ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



1119
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1119

attach_function :is_packed_struct, :LLVMIsPackedStruct, [OpaqueType], :int

.is_section_iterator_at_end(object_file, si) ⇒ Integer

(Not documented)

Parameters:

Returns:



5764
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5764

attach_function :is_section_iterator_at_end, :LLVMIsSectionIteratorAtEnd, [OpaqueObjectFile, OpaqueSectionIterator], :int

.is_tail_call(call_inst) ⇒ Integer

Operations on call instructions (only)

Parameters:

Returns:



3536
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3536

attach_function :is_tail_call, :LLVMIsTailCall, [OpaqueValue], :int

.is_thread_local(global_var) ⇒ Integer

(Not documented)

Parameters:

Returns:



2983
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2983

attach_function :is_thread_local, :LLVMIsThreadLocal, [OpaqueValue], :int

.is_undef(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



1984
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1984

attach_function :is_undef, :LLVMIsUndef, [OpaqueValue], :int

.label_type ⇒ OpaqueType

(Not documented)

Returns:



1233
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1233

attach_function :label_type, :LLVMLabelType, [], OpaqueType

.label_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1211
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1211

attach_function :label_type_in_context, :LLVMLabelTypeInContext, [OpaqueContext], OpaqueType

.link_in_interpreter ⇒ nil

(Not documented)

Returns:

  • (nil) 


5350
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5350

attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void

.link_in_jit ⇒ nil

(Not documented)

Returns:

  • (nil) 


5343
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5343

attach_function :link_in_jit, :LLVMLinkInJIT, [], :void

.load_library_permanently(filename) ⇒ Integer

(Not documented)

Parameters:

  • filename (String)

Returns:



87
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 87

attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int

.load_module_from_ir_file(file_name, context) ⇒ FFI::Pointer(ModuleRef)

(Not documented)

Parameters:

  • file_name (String)
  • context (FFI::Pointer(ContextRef))

Returns:

  • (FFI::Pointer(ModuleRef)) 


70
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 70

attach_function :load_module_from_ir_file, :LLVMLoadModuleFromIRFile, [:string, :pointer], :pointer

.md_node(vals, count) ⇒ OpaqueValue

(Not documented)

Parameters:

  • vals (FFI::Pointer(*ValueRef))
  • count (Integer)

Returns:



2030
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2030

attach_function :md_node, :LLVMMDNode, [:pointer, :uint], OpaqueValue

.md_node_in_context(c, vals, count) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2021
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2021

attach_function :md_node_in_context, :LLVMMDNodeInContext, [OpaqueContext, :pointer, :uint], OpaqueValue

.md_string(str, s_len) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2011
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2011

attach_function :md_string, :LLVMMDString, [:string, :uint], OpaqueValue

.md_string_in_context(c, str, s_len) ⇒ OpaqueValue

Operations on metadata

Parameters:

Returns:



2002
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2002

attach_function :md_string_in_context, :LLVMMDStringInContext, [OpaqueContext, :string, :uint], OpaqueValue

.module_create_with_name(module_id) ⇒ OpaqueModule

See llvm::Module::Module.

Parameters:

  • module_id (String)

Returns:



726
 
# File 'lib/rltk/cg/generated_bindings.rb', line 726

attach_function :module_create_with_name, :LLVMModuleCreateWithName, [:string], OpaqueModule

.module_create_with_name_in_context(module_id, c) ⇒ OpaqueModule

(Not documented)

Parameters:

Returns:



735
 
# File 'lib/rltk/cg/generated_bindings.rb', line 735

attach_function :module_create_with_name_in_context, :LLVMModuleCreateWithNameInContext, [:string, OpaqueContext], OpaqueModule

.move_basic_block_after(bb, move_pos) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3417
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3417

attach_function :move_basic_block_after, :LLVMMoveBasicBlockAfter, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.move_basic_block_before(bb, move_pos) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3408
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3408

attach_function :move_basic_block_before, :LLVMMoveBasicBlockBefore, [OpaqueBasicBlock, OpaqueBasicBlock], :void

.move_to_next_section(si) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


5772
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5772

attach_function :move_to_next_section, :LLVMMoveToNextSection, [OpaqueSectionIterator], :void

.offset_of_element(opaque_target_data, struct_ty, element) ⇒ Integer

Computes the byte offset of the indexed struct element for a target.

See the method llvm::StructLayout::getElementContainingOffset.

Parameters:

Returns:



5327
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5327

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:



4885
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4885

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:



4896
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4896

attach_function :parse_bitcode_in_context, :LLVMParseBitcodeInContext, [OpaqueContext, OpaqueMemoryBuffer, :pointer, :pointer], :int

.pointer_size(opaque_target_data) ⇒ Integer

Returns the pointer size in bytes for a target.

See the method llvm::TargetData::getPointerSize.

Parameters:

Returns:



5226
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5226

attach_function :pointer_size, :LLVMPointerSize, [OpaqueTargetData], :uint

.pointer_type(element_type, address_space) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1154
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1154

attach_function :pointer_type, :LLVMPointerType, [OpaqueType, :uint], OpaqueType

.position_builder(builder, block, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3616
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3616

attach_function :position_builder, :LLVMPositionBuilder, [OpaqueBuilder, OpaqueBasicBlock, OpaqueValue], :void

.position_builder_at_end(builder, block) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3634
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3634

attach_function :position_builder_at_end, :LLVMPositionBuilderAtEnd, [OpaqueBuilder, OpaqueBasicBlock], :void

.position_builder_before(builder, instr) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3625
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3625

attach_function :position_builder_before, :LLVMPositionBuilderBefore, [OpaqueBuilder, OpaqueValue], :void

.ppcfp128_type ⇒ OpaqueType

(Not documented)

Returns:



1001
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1001

attach_function :ppcfp128_type, :LLVMPPCFP128Type, [], OpaqueType

.ppcfp128_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



966
 
# File 'lib/rltk/cg/generated_bindings.rb', line 966

attach_function :ppcfp128_type_in_context, :LLVMPPCFP128TypeInContext, [OpaqueContext], OpaqueType

.preferred_alignment_of_global(opaque_target_data, global_var) ⇒ Integer

Computes the preferred alignment of a global variable in bytes for a target.

See the method llvm::TargetData::getPreferredAlignment.

Parameters:

Returns:



5305
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5305

attach_function :preferred_alignment_of_global, :LLVMPreferredAlignmentOfGlobal, [OpaqueTargetData, OpaqueValue], :uint

.preferred_alignment_of_type(opaque_target_data, opaque_type) ⇒ Integer

Computes the preferred alignment of a type in bytes for a target.

See the method llvm::TargetData::getTypeABISize.

Parameters:

Returns:



5295
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5295

attach_function :preferred_alignment_of_type, :LLVMPreferredAlignmentOfType, [OpaqueTargetData, OpaqueType], :uint

.print_module(mod, fd) ⇒ nil

(Not documented)

Parameters:

  • mod (FFI::Pointer(ModuleRef))
  • fd (Integer)

Returns:

  • (nil) 


79
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 79

attach_function :print_module, :LLVMPrintModule, [:pointer, :int], :void

.print_value(val, fd) ⇒ nil

(Not documented)

Parameters:

  • val (FFI::Pointer(ValueRef))
  • fd (Integer)

Returns:

  • (nil) 


96
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 96

attach_function :print_value, :LLVMPrintValue, [:pointer, :int], :void

.recompile_and_relink_function(ee, fn) ⇒ FFI::Pointer(*Void)

(Not documented)

Parameters:

Returns:

  • (FFI::Pointer(*Void)) 


5606
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5606

attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, OpaqueValue], :pointer

.remove_attribute(arg, pa) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3231
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3231

attach_function :remove_attribute, :LLVMRemoveAttribute, [OpaqueValue, :attribute], :void

.remove_basic_block_from_parent(bb) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3399
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3399

attach_function :remove_basic_block_from_parent, :LLVMRemoveBasicBlockFromParent, [OpaqueBasicBlock], :void

.remove_function_attr(fn, pa) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3147
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3147

attach_function :remove_function_attr, :LLVMRemoveFunctionAttr, [OpaqueValue, :attribute], :void

.remove_instr_attribute(instr, index, attribute) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3518
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3518

attach_function :remove_instr_attribute, :LLVMRemoveInstrAttribute, [OpaqueValue, :uint, :attribute], :void

.remove_module(ee, m, out_mod, out_error) ⇒ Integer

(Not documented)

Parameters:

Returns:



5576
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5576

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:



5587
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5587

attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [OpaqueExecutionEngine, OpaqueModuleProvider, :pointer, :pointer], :int

.replace_all_uses_with(old_val, new_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1282
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1282

attach_function :replace_all_uses_with, :LLVMReplaceAllUsesWith, [OpaqueValue, OpaqueValue], :void

.run_function(ee, f, num_args, args) ⇒ OpaqueGenericValue

(Not documented)

Parameters:

Returns:



5538
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5538

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:



5527
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5527

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:



4795
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4795

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:



4773
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4773

attach_function :run_pass_manager, :LLVMRunPassManager, [OpaquePassManager, OpaqueModule], :int

.run_static_constructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


5507
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5507

attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void

.run_static_destructors(ee) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


5515
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5515

attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void

.set_alignment(global, bytes) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


2888
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2888

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) 


3851
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3851

attach_function :set_cleanup, :LLVMSetCleanup, [OpaqueValue, :int], :void

.set_current_debug_location(builder, l) ⇒ nil

Metadata

Parameters:

Returns:

  • (nil) 


3686
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3686

attach_function :set_current_debug_location, :LLVMSetCurrentDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_data_layout(m, triple) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


760
 
# File 'lib/rltk/cg/generated_bindings.rb', line 760

attach_function :set_data_layout, :LLVMSetDataLayout, [OpaqueModule, :string], :void

.set_function_call_conv(fn, cc) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3104
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3104

attach_function :set_function_call_conv, :LLVMSetFunctionCallConv, [OpaqueValue, :uint], :void

.set_gc(fn, name) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3121
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3121

attach_function :set_gc, :LLVMSetGC, [OpaqueValue, :string], :void

.set_global_constant(global_var, is_constant) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3009
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3009

attach_function :set_global_constant, :LLVMSetGlobalConstant, [OpaqueValue, :int], :void

.set_initializer(global_var, constant_val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


2975
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2975

attach_function :set_initializer, :LLVMSetInitializer, [OpaqueValue, OpaqueValue], :void

.set_inst_debug_location(builder, inst) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3703
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3703

attach_function :set_inst_debug_location, :LLVMSetInstDebugLocation, [OpaqueBuilder, OpaqueValue], :void

.set_instr_param_alignment(instr, index, align) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3528
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3528

attach_function :set_instr_param_alignment, :LLVMSetInstrParamAlignment, [OpaqueValue, :uint, :uint], :void

.set_instruction_call_conv(instr, cc) ⇒ nil

Operations on call sites

Parameters:

Returns:

  • (nil) 


3490
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3490

attach_function :set_instruction_call_conv, :LLVMSetInstructionCallConv, [OpaqueValue, :uint], :void

.set_linkage(global, linkage) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


2837
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2837

attach_function :set_linkage, :LLVMSetLinkage, [OpaqueValue, :linkage], :void

.set_metadata(val, kind_id, node) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1309
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1309

attach_function :set_metadata, :LLVMSetMetadata, [OpaqueValue, :uint, OpaqueValue], :void

.set_module_inline_asm(m, asm) ⇒ nil

See Module::setModuleInlineAsm.

Parameters:

Returns:

  • (nil) 


794
 
# File 'lib/rltk/cg/generated_bindings.rb', line 794

attach_function :set_module_inline_asm, :LLVMSetModuleInlineAsm, [OpaqueModule, :string], :void

.set_operand(user, index, val) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1928
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1928

attach_function :set_operand, :LLVMSetOperand, [OpaqueValue, :uint, OpaqueValue], :void

.set_param_alignment(arg, align) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3248
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3248

attach_function :set_param_alignment, :LLVMSetParamAlignment, [OpaqueValue, :uint], :void

.set_section(global, section) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


2854
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2854

attach_function :set_section, :LLVMSetSection, [OpaqueValue, :string], :void

.set_tail_call(call_inst, is_tail_call) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


3545
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3545

attach_function :set_tail_call, :LLVMSetTailCall, [OpaqueValue, :int], :void

.set_target(m, triple) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


777
 
# File 'lib/rltk/cg/generated_bindings.rb', line 777

attach_function :set_target, :LLVMSetTarget, [OpaqueModule, :string], :void

.set_target_machine_asm_verbosity(machine, boolean) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


255
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 255

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) 


2992
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2992

attach_function :set_thread_local, :LLVMSetThreadLocal, [OpaqueValue, :int], :void

.set_value_name(val, name) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1265
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1265

attach_function :set_value_name, :LLVMSetValueName, [OpaqueValue, :string], :void

.set_visibility(global, viz) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


2871
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2871

attach_function :set_visibility, :LLVMSetVisibility, [OpaqueValue, :visibility], :void

.size_of(ty) ⇒ OpaqueValue

(Not documented)

Parameters:

Returns:



2255
 
# File 'lib/rltk/cg/generated_bindings.rb', line 2255

attach_function :size_of, :LLVMSizeOf, [OpaqueType], OpaqueValue

.size_of_type_in_bits(opaque_target_data, opaque_type) ⇒ Integer

Computes the size of a type in bytes for a target.

See the method llvm::TargetData::getTypeSizeInBits.

Parameters:

Returns:



5245
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5245

attach_function :size_of_type_in_bits, :LLVMSizeOfTypeInBits, [OpaqueTargetData, OpaqueType], :ulong_long

.store_size_of_type(opaque_target_data, opaque_type) ⇒ Integer

Computes the storage size of a type in bytes for a target.

See the method llvm::TargetData::getTypeStoreSize.

Parameters:

Returns:



5255
 
# File 'lib/rltk/cg/generated_bindings.rb', line 5255

attach_function :store_size_of_type, :LLVMStoreSizeOfType, [OpaqueTargetData, OpaqueType], :ulong_long

.struct_create_named(c, name) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1075
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1075

attach_function :struct_create_named, :LLVMStructCreateNamed, [OpaqueContext, :string], OpaqueType

.struct_set_body(struct_ty, element_types, element_count, packed) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


1094
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1094

attach_function :struct_set_body, :LLVMStructSetBody, [OpaqueType, :pointer, :uint, :int], :void

.struct_type(element_types, element_count, packed) ⇒ OpaqueType

(Not documented)

Parameters:

  • element_types (FFI::Pointer(*TypeRef))
  • element_count (Integer)
  • packed (Integer)

Returns:



1066
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1066

attach_function :struct_type, :LLVMStructType, [:pointer, :uint, :int], OpaqueType

.struct_type_in_context(c, element_types, element_count, packed) ⇒ OpaqueType

Operations on struct types

Parameters:

Returns:



1056
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1056

attach_function :struct_type_in_context, :LLVMStructTypeInContext, [OpaqueContext, :pointer, :uint, :int], OpaqueType

.target_version ⇒ String

(Not documented)

Returns:

  • (String) 


33
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 33

attach_function :target_version, :LLVMTargetVersion, [], :string

.triple_create(string) ⇒ OpaqueTriple

(Not documented)

Parameters:

  • string (String)

Returns:



285
 
# File 'lib/rltk/cg/generated_extended_bindings.rb', line 285

attach_function :triple_create, :LLVMTripleCreate, [:string], OpaqueTriple

.type_is_sized(ty) ⇒ Integer

(Not documented)

Parameters:

Returns:



818
 
# File 'lib/rltk/cg/generated_bindings.rb', line 818

attach_function :type_is_sized, :LLVMTypeIsSized, [OpaqueType], :int

.type_of(val) ⇒ OpaqueType

Operations on all values

Parameters:

Returns:



1248
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1248

attach_function :type_of, :LLVMTypeOf, [OpaqueValue], OpaqueType

.value_as_basic_block(val) ⇒ OpaqueBasicBlock

(Not documented)

Parameters:

Returns:



3272
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3272

attach_function :value_as_basic_block, :LLVMValueAsBasicBlock, [OpaqueValue], OpaqueBasicBlock

.value_is_basic_block(val) ⇒ Integer

(Not documented)

Parameters:

Returns:



3264
 
# File 'lib/rltk/cg/generated_bindings.rb', line 3264

attach_function :value_is_basic_block, :LLVMValueIsBasicBlock, [OpaqueValue], :int

.vector_type(element_type, element_count) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1163
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1163

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:



4858
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4858

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:



4848
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4848

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) 


4867
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4867

attach_function :view_function_cfg, :LLVMViewFunctionCFG, [OpaqueValue], :void

.view_function_cfg_only(fn) ⇒ nil

(Not documented)

Parameters:

Returns:

  • (nil) 


4875
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4875

attach_function :view_function_cfg_only, :LLVMViewFunctionCFGOnly, [OpaqueValue], :void

.void_type ⇒ OpaqueType

(Not documented)

Returns:



1226
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1226

attach_function :void_type, :LLVMVoidType, [], OpaqueType

.void_type_in_context(c) ⇒ OpaqueType

Operations on other types

Parameters:

Returns:



1203
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1203

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:

Returns:



4960
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4960

attach_function :write_bitcode_to_fd, :LLVMWriteBitcodeToFD, [OpaqueModule, :int, :int, :int], :int

.write_bitcode_to_file(m, path) ⇒ Integer

(Not documented)

Parameters:

Returns:



4949
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4949

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:



4970
 
# File 'lib/rltk/cg/generated_bindings.rb', line 4970

attach_function :write_bitcode_to_file_handle, :LLVMWriteBitcodeToFileHandle, [OpaqueModule, :int], :int

.x86fp80_type ⇒ OpaqueType

(Not documented)

Returns:



987
 
# File 'lib/rltk/cg/generated_bindings.rb', line 987

attach_function :x86fp80_type, :LLVMX86FP80Type, [], OpaqueType

.x86fp80_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



950
 
# File 'lib/rltk/cg/generated_bindings.rb', line 950

attach_function :x86fp80_type_in_context, :LLVMX86FP80TypeInContext, [OpaqueContext], OpaqueType

.x86mmx_type ⇒ OpaqueType

(Not documented)

Returns:



1240
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1240

attach_function :x86mmx_type, :LLVMX86MMXType, [], OpaqueType

.x86mmx_type_in_context(c) ⇒ OpaqueType

(Not documented)

Parameters:

Returns:



1219
 
# File 'lib/rltk/cg/generated_bindings.rb', line 1219

attach_function :x86mmx_type_in_context, :LLVMX86MMXTypeInContext, [OpaqueContext], OpaqueType