ruby-llvm 3.0.0.beta → 3.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/README.rdoc +6 -3
- data/ext/ruby-llvm-support/Rakefile +1 -0
- data/lib/llvm/analysis.rb +8 -18
- data/lib/llvm/analysis_ffi.rb +68 -0
- data/lib/llvm/core.rb +2 -598
- data/lib/llvm/core/bitcode.rb +12 -16
- data/lib/llvm/core/bitcode_ffi.rb +104 -0
- data/lib/llvm/core/builder.rb +85 -84
- data/lib/llvm/core/context.rb +5 -3
- data/lib/llvm/core/module.rb +24 -22
- data/lib/llvm/core/pass_manager.rb +13 -11
- data/lib/llvm/core/type.rb +56 -24
- data/lib/llvm/core/value.rb +98 -99
- data/lib/llvm/core_ffi.rb +4712 -0
- data/lib/llvm/execution_engine.rb +46 -57
- data/lib/llvm/execution_engine_ffi.rb +310 -0
- data/lib/llvm/support.rb +2 -2
- data/lib/llvm/target.rb +2 -4
- data/lib/llvm/target_ffi.rb +217 -0
- data/lib/llvm/transforms/ipo.rb +3 -8
- data/lib/llvm/transforms/ipo_ffi.rb +122 -0
- data/lib/llvm/transforms/scalar.rb +22 -46
- data/lib/llvm/transforms/scalar_ffi.rb +250 -0
- data/lib/llvm/version.rb +1 -1
- data/test/conversions_test.rb +6 -0
- data/test/equality_test.rb +2 -2
- data/test/struct_test.rb +11 -2
- metadata +97 -83
@@ -2,76 +2,46 @@ require 'llvm'
|
|
2
2
|
require 'llvm/core'
|
3
3
|
require 'llvm/target'
|
4
4
|
require 'llvm/analysis'
|
5
|
+
require 'llvm/execution_engine_ffi'
|
5
6
|
|
6
7
|
module LLVM
|
7
8
|
# @private
|
8
9
|
module C
|
9
|
-
|
10
|
-
attach_function :
|
11
|
-
attach_function :
|
12
|
-
attach_function :LLVMCreateGenericValueOfFloat, [:pointer, :double], :pointer
|
13
|
-
|
14
|
-
attach_function :LLVMGenericValueIntWidth, [:pointer], :uint
|
15
|
-
|
16
|
-
attach_function :LLVMGenericValueToInt, [:pointer, :int], :long_long
|
17
|
-
attach_function :LLVMGenericValueToPointer, [:pointer], :pointer
|
18
|
-
attach_function :LLVMGenericValueToFloat, [:pointer, :pointer], :double
|
19
|
-
attach_function :LLVMDisposeGenericValue, [:pointer], :void
|
20
|
-
|
21
|
-
# Execution engines
|
22
|
-
attach_function :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int
|
23
|
-
attach_function :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int
|
24
|
-
attach_function :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
|
25
|
-
attach_function :LLVMDisposeExecutionEngine, [:pointer], :void
|
26
|
-
|
27
|
-
attach_function :LLVMRunStaticConstructors, [:pointer], :void
|
28
|
-
attach_function :LLVMRunStaticDestructors, [:pointer], :void
|
29
|
-
|
30
|
-
attach_function :LLVMRunFunctionAsMain, [:pointer, :pointer, :uint, :pointer, :pointer], :int
|
31
|
-
attach_function :LLVMRunFunction, [:pointer, :pointer, :uint, :pointer], :pointer
|
32
|
-
|
33
|
-
attach_function :LLVMFreeMachineCodeForFunction, [:pointer, :pointer], :void
|
34
|
-
attach_function :LLVMAddModuleProvider, [:pointer, :pointer], :void
|
35
|
-
attach_function :LLVMRemoveModuleProvider, [:pointer, :pointer, :pointer, :pointer], :int
|
36
|
-
|
37
|
-
attach_function :LLVMFindFunction, [:pointer, :pointer, :pointer, :pointer], :int
|
38
|
-
|
39
|
-
attach_function :LLVMGetExecutionEngineTargetData, [:pointer], :pointer
|
40
|
-
|
41
|
-
attach_function :LLVMAddGlobalMapping, [:pointer, :pointer, :pointer], :void
|
42
|
-
|
43
|
-
attach_function :LLVMGetPointerToGlobal, [:pointer, :pointer], :pointer
|
44
|
-
|
45
|
-
attach_function :LLVMInitializeX86TargetInfo, [], :void
|
46
|
-
|
47
|
-
attach_function :LLVMInitializeX86Target, [], :void
|
48
|
-
|
49
|
-
attach_function :LLVMInitializeX86TargetMC, [], :void
|
10
|
+
attach_function :initialize_x86_target_info, :LLVMInitializeX86TargetInfo, [], :void
|
11
|
+
attach_function :initialize_x86_target, :LLVMInitializeX86Target, [], :void
|
12
|
+
attach_function :initialize_x86_target_mc, :LLVMInitializeX86TargetMC, [], :void
|
50
13
|
end
|
51
14
|
|
52
15
|
def LLVM.init_x86
|
53
|
-
LLVM::C.
|
54
|
-
LLVM::C.
|
55
|
-
LLVM::C.
|
16
|
+
LLVM::C.initialize_x86_target
|
17
|
+
LLVM::C.initialize_x86_target_info
|
18
|
+
LLVM::C.initialize_x86_target_mc
|
56
19
|
end
|
57
20
|
|
58
21
|
class JITCompiler
|
22
|
+
# Important: Call #dispose to free backend memory after use. Do not call #dispose on mod any more.
|
59
23
|
def initialize(mod, opt_level = 3)
|
60
24
|
FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |ptr|
|
61
25
|
error = FFI::MemoryPointer.new(FFI.type_size(:pointer))
|
62
|
-
status = C.
|
26
|
+
status = C.create_jit_compiler_for_module(ptr, mod, opt_level, error)
|
63
27
|
errorp = error.read_pointer
|
64
28
|
message = errorp.read_string unless errorp.null?
|
65
29
|
|
66
30
|
if status.zero?
|
67
31
|
@ptr = ptr.read_pointer
|
68
32
|
else
|
69
|
-
C.
|
33
|
+
C.dispose_message(error)
|
70
34
|
error.autorelease=false
|
71
35
|
raise RuntimeError, "Error creating JIT compiler: #{message}"
|
72
36
|
end
|
73
37
|
end
|
74
38
|
end
|
39
|
+
|
40
|
+
def dispose
|
41
|
+
return if @ptr.nil?
|
42
|
+
C.dispose_execution_engine(@ptr)
|
43
|
+
@ptr = nil
|
44
|
+
end
|
75
45
|
|
76
46
|
# @private
|
77
47
|
def to_ptr
|
@@ -80,19 +50,30 @@ module LLVM
|
|
80
50
|
|
81
51
|
# Execute the given LLVM::Function with the supplied args (as
|
82
52
|
# GenericValues).
|
53
|
+
# Important: Call #dispose on the returned GenericValue to
|
54
|
+
# free backend memory after use.
|
83
55
|
def run_function(fun, *args)
|
84
56
|
FFI::MemoryPointer.new(FFI.type_size(:pointer) * args.size) do |args_ptr|
|
57
|
+
new_values = []
|
85
58
|
args_ptr.write_array_of_pointer fun.params.zip(args).map { |p, a|
|
86
|
-
a.kind_of?(GenericValue)
|
59
|
+
if a.kind_of?(GenericValue)
|
60
|
+
a
|
61
|
+
else
|
62
|
+
value = LLVM.make_generic_value(p.type, a)
|
63
|
+
new_values << value
|
64
|
+
value
|
65
|
+
end
|
87
66
|
}
|
88
|
-
|
89
|
-
C.
|
67
|
+
result = LLVM::GenericValue.from_ptr(
|
68
|
+
C.run_function(self, fun, args.size, args_ptr))
|
69
|
+
new_values.each(&:dispose)
|
70
|
+
return result
|
90
71
|
end
|
91
72
|
end
|
92
73
|
|
93
74
|
# Obtain an FFI::Pointer to a global within the current module.
|
94
75
|
def pointer_to_global(global)
|
95
|
-
C.
|
76
|
+
C.get_pointer_to_global(self, global)
|
96
77
|
end
|
97
78
|
end
|
98
79
|
|
@@ -109,22 +90,28 @@ module LLVM
|
|
109
90
|
val.instance_variable_set(:@ptr, ptr)
|
110
91
|
val
|
111
92
|
end
|
93
|
+
|
94
|
+
def dispose
|
95
|
+
return if @ptr.nil?
|
96
|
+
C.dispose_generic_value(@ptr)
|
97
|
+
@ptr = nil
|
98
|
+
end
|
112
99
|
|
113
100
|
# Creates a Generic Value from an integer. Type is the size of integer to
|
114
101
|
# create (ex. Int32, Int8, etc.)
|
115
102
|
def self.from_i(i, options = {})
|
116
103
|
type = options.fetch(:type, LLVM::Int)
|
117
104
|
signed = options.fetch(:signed, true)
|
118
|
-
from_ptr(C.
|
105
|
+
from_ptr(C.create_generic_value_of_int(type, i, signed ? 1 : 0))
|
119
106
|
end
|
120
107
|
|
121
108
|
# Creates a Generic Value from a Float.
|
122
109
|
def self.from_f(f)
|
123
|
-
from_ptr(C.
|
110
|
+
from_ptr(C.create_generic_value_of_float(LLVM::Float, f))
|
124
111
|
end
|
125
112
|
|
126
113
|
def self.from_d(val)
|
127
|
-
from_ptr(C.
|
114
|
+
from_ptr(C.create_generic_value_of_float(LLVM::Double, val))
|
128
115
|
end
|
129
116
|
|
130
117
|
# Creates a GenericValue from a Ruby boolean.
|
@@ -134,17 +121,19 @@ module LLVM
|
|
134
121
|
|
135
122
|
# Creates a GenericValue from an FFI::Pointer pointing to some arbitrary value.
|
136
123
|
def self.from_value_ptr(ptr)
|
137
|
-
from_ptr(LLVM::C.
|
124
|
+
from_ptr(LLVM::C.create_generic_value_of_pointer(ptr))
|
138
125
|
end
|
139
126
|
|
140
127
|
# Converts a GenericValue to a Ruby Integer.
|
141
128
|
def to_i(signed = true)
|
142
|
-
C.
|
129
|
+
v = C.generic_value_to_int(self, signed ? 1 : 0)
|
130
|
+
v -= 2**64 if signed and v >= 2**63
|
131
|
+
v
|
143
132
|
end
|
144
133
|
|
145
134
|
# Converts a GenericValue to a Ruby Float.
|
146
135
|
def to_f(type = LLVM::Float.type)
|
147
|
-
C.
|
136
|
+
C.generic_value_to_float(type, self)
|
148
137
|
end
|
149
138
|
|
150
139
|
# Converts a GenericValue to a Ruby boolean.
|
@@ -153,7 +142,7 @@ module LLVM
|
|
153
142
|
end
|
154
143
|
|
155
144
|
def to_value_ptr
|
156
|
-
C.
|
145
|
+
C.generic_value_to_pointer(self)
|
157
146
|
end
|
158
147
|
end
|
159
148
|
|
@@ -0,0 +1,310 @@
|
|
1
|
+
# Generated by ffi_gen. Please do not change this file by hand.
|
2
|
+
|
3
|
+
require 'ffi'
|
4
|
+
|
5
|
+
module LLVM::C
|
6
|
+
extend FFI::Library
|
7
|
+
ffi_lib 'LLVM-3.0'
|
8
|
+
|
9
|
+
# (Not documented)
|
10
|
+
#
|
11
|
+
# @method link_in_jit()
|
12
|
+
# @return [nil]
|
13
|
+
# @scope class
|
14
|
+
attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
|
15
|
+
|
16
|
+
# (Not documented)
|
17
|
+
#
|
18
|
+
# @method link_in_interpreter()
|
19
|
+
# @return [nil]
|
20
|
+
# @scope class
|
21
|
+
attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void
|
22
|
+
|
23
|
+
# (Not documented)
|
24
|
+
#
|
25
|
+
# = Fields:
|
26
|
+
#
|
27
|
+
class OpaqueGenericValue < FFI::Struct
|
28
|
+
end
|
29
|
+
|
30
|
+
# (Not documented)
|
31
|
+
#
|
32
|
+
# = Fields:
|
33
|
+
#
|
34
|
+
class OpaqueExecutionEngine < FFI::Struct
|
35
|
+
end
|
36
|
+
|
37
|
+
# ===-- Operations on generic values --------------------------------------===
|
38
|
+
#
|
39
|
+
# @method create_generic_value_of_int(ty, n, is_signed)
|
40
|
+
# @param [FFI::Pointer(TypeRef)] ty
|
41
|
+
# @param [Integer] n
|
42
|
+
# @param [Integer] is_signed
|
43
|
+
# @return [FFI::Pointer(GenericValueRef)]
|
44
|
+
# @scope class
|
45
|
+
attach_function :create_generic_value_of_int, :LLVMCreateGenericValueOfInt, [:pointer, :ulong_long, :int], :pointer
|
46
|
+
|
47
|
+
# (Not documented)
|
48
|
+
#
|
49
|
+
# @method create_generic_value_of_pointer(p)
|
50
|
+
# @param [FFI::Pointer(*Void)] p
|
51
|
+
# @return [FFI::Pointer(GenericValueRef)]
|
52
|
+
# @scope class
|
53
|
+
attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], :pointer
|
54
|
+
|
55
|
+
# (Not documented)
|
56
|
+
#
|
57
|
+
# @method create_generic_value_of_float(ty, n)
|
58
|
+
# @param [FFI::Pointer(TypeRef)] ty
|
59
|
+
# @param [Float] n
|
60
|
+
# @return [FFI::Pointer(GenericValueRef)]
|
61
|
+
# @scope class
|
62
|
+
attach_function :create_generic_value_of_float, :LLVMCreateGenericValueOfFloat, [:pointer, :double], :pointer
|
63
|
+
|
64
|
+
# (Not documented)
|
65
|
+
#
|
66
|
+
# @method generic_value_int_width(gen_val_ref)
|
67
|
+
# @param [FFI::Pointer(GenericValueRef)] gen_val_ref
|
68
|
+
# @return [Integer]
|
69
|
+
# @scope class
|
70
|
+
attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [:pointer], :uint
|
71
|
+
|
72
|
+
# (Not documented)
|
73
|
+
#
|
74
|
+
# @method generic_value_to_int(gen_val, is_signed)
|
75
|
+
# @param [FFI::Pointer(GenericValueRef)] gen_val
|
76
|
+
# @param [Integer] is_signed
|
77
|
+
# @return [Integer]
|
78
|
+
# @scope class
|
79
|
+
attach_function :generic_value_to_int, :LLVMGenericValueToInt, [:pointer, :int], :ulong_long
|
80
|
+
|
81
|
+
# (Not documented)
|
82
|
+
#
|
83
|
+
# @method generic_value_to_pointer(gen_val)
|
84
|
+
# @param [FFI::Pointer(GenericValueRef)] gen_val
|
85
|
+
# @return [FFI::Pointer(*Void)]
|
86
|
+
# @scope class
|
87
|
+
attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [:pointer], :pointer
|
88
|
+
|
89
|
+
# (Not documented)
|
90
|
+
#
|
91
|
+
# @method generic_value_to_float(ty_ref, gen_val)
|
92
|
+
# @param [FFI::Pointer(TypeRef)] ty_ref
|
93
|
+
# @param [FFI::Pointer(GenericValueRef)] gen_val
|
94
|
+
# @return [Float]
|
95
|
+
# @scope class
|
96
|
+
attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, :pointer], :double
|
97
|
+
|
98
|
+
# (Not documented)
|
99
|
+
#
|
100
|
+
# @method dispose_generic_value(gen_val)
|
101
|
+
# @param [FFI::Pointer(GenericValueRef)] gen_val
|
102
|
+
# @return [nil]
|
103
|
+
# @scope class
|
104
|
+
attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [:pointer], :void
|
105
|
+
|
106
|
+
# ===-- Operations on execution engines -----------------------------------===
|
107
|
+
#
|
108
|
+
# @method create_execution_engine_for_module(out_ee, m, out_error)
|
109
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_ee
|
110
|
+
# @param [FFI::Pointer(ModuleRef)] m
|
111
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
112
|
+
# @return [Integer]
|
113
|
+
# @scope class
|
114
|
+
attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int
|
115
|
+
|
116
|
+
# (Not documented)
|
117
|
+
#
|
118
|
+
# @method create_interpreter_for_module(out_interp, m, out_error)
|
119
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_interp
|
120
|
+
# @param [FFI::Pointer(ModuleRef)] m
|
121
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
122
|
+
# @return [Integer]
|
123
|
+
# @scope class
|
124
|
+
attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int
|
125
|
+
|
126
|
+
# (Not documented)
|
127
|
+
#
|
128
|
+
# @method create_jit_compiler_for_module(out_jit, m, opt_level, out_error)
|
129
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_jit
|
130
|
+
# @param [FFI::Pointer(ModuleRef)] m
|
131
|
+
# @param [Integer] opt_level
|
132
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
133
|
+
# @return [Integer]
|
134
|
+
# @scope class
|
135
|
+
attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
|
136
|
+
|
137
|
+
# Deprecated: Use LLVMCreateExecutionEngineForModule instead.
|
138
|
+
#
|
139
|
+
# @method create_execution_engine(out_ee, mp, out_error)
|
140
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_ee
|
141
|
+
# @param [FFI::Pointer(ModuleProviderRef)] mp
|
142
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
143
|
+
# @return [Integer]
|
144
|
+
# @scope class
|
145
|
+
attach_function :create_execution_engine, :LLVMCreateExecutionEngine, [:pointer, :pointer, :pointer], :int
|
146
|
+
|
147
|
+
# Deprecated: Use LLVMCreateInterpreterForModule instead.
|
148
|
+
#
|
149
|
+
# @method create_interpreter(out_interp, mp, out_error)
|
150
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_interp
|
151
|
+
# @param [FFI::Pointer(ModuleProviderRef)] mp
|
152
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
153
|
+
# @return [Integer]
|
154
|
+
# @scope class
|
155
|
+
attach_function :create_interpreter, :LLVMCreateInterpreter, [:pointer, :pointer, :pointer], :int
|
156
|
+
|
157
|
+
# Deprecated: Use LLVMCreateJITCompilerForModule instead.
|
158
|
+
#
|
159
|
+
# @method create_jit_compiler(out_jit, mp, opt_level, out_error)
|
160
|
+
# @param [FFI::Pointer(*ExecutionEngineRef)] out_jit
|
161
|
+
# @param [FFI::Pointer(ModuleProviderRef)] mp
|
162
|
+
# @param [Integer] opt_level
|
163
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
164
|
+
# @return [Integer]
|
165
|
+
# @scope class
|
166
|
+
attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, :pointer, :uint, :pointer], :int
|
167
|
+
|
168
|
+
# (Not documented)
|
169
|
+
#
|
170
|
+
# @method dispose_execution_engine(ee)
|
171
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
172
|
+
# @return [nil]
|
173
|
+
# @scope class
|
174
|
+
attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [:pointer], :void
|
175
|
+
|
176
|
+
# (Not documented)
|
177
|
+
#
|
178
|
+
# @method run_static_constructors(ee)
|
179
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
180
|
+
# @return [nil]
|
181
|
+
# @scope class
|
182
|
+
attach_function :run_static_constructors, :LLVMRunStaticConstructors, [:pointer], :void
|
183
|
+
|
184
|
+
# (Not documented)
|
185
|
+
#
|
186
|
+
# @method run_static_destructors(ee)
|
187
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
188
|
+
# @return [nil]
|
189
|
+
# @scope class
|
190
|
+
attach_function :run_static_destructors, :LLVMRunStaticDestructors, [:pointer], :void
|
191
|
+
|
192
|
+
# (Not documented)
|
193
|
+
#
|
194
|
+
# @method run_function_as_main(ee, f, arg_c, arg_v, env_p)
|
195
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
196
|
+
# @param [FFI::Pointer(ValueRef)] f
|
197
|
+
# @param [Integer] arg_c
|
198
|
+
# @param [FFI::Pointer(**Char_S)] arg_v
|
199
|
+
# @param [FFI::Pointer(**Char_S)] env_p
|
200
|
+
# @return [Integer]
|
201
|
+
# @scope class
|
202
|
+
attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [:pointer, :pointer, :uint, :pointer, :pointer], :int
|
203
|
+
|
204
|
+
# (Not documented)
|
205
|
+
#
|
206
|
+
# @method run_function(ee, f, num_args, args)
|
207
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
208
|
+
# @param [FFI::Pointer(ValueRef)] f
|
209
|
+
# @param [Integer] num_args
|
210
|
+
# @param [FFI::Pointer(*GenericValueRef)] args
|
211
|
+
# @return [FFI::Pointer(GenericValueRef)]
|
212
|
+
# @scope class
|
213
|
+
attach_function :run_function, :LLVMRunFunction, [:pointer, :pointer, :uint, :pointer], :pointer
|
214
|
+
|
215
|
+
# (Not documented)
|
216
|
+
#
|
217
|
+
# @method free_machine_code_for_function(ee, f)
|
218
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
219
|
+
# @param [FFI::Pointer(ValueRef)] f
|
220
|
+
# @return [nil]
|
221
|
+
# @scope class
|
222
|
+
attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [:pointer, :pointer], :void
|
223
|
+
|
224
|
+
# (Not documented)
|
225
|
+
#
|
226
|
+
# @method add_module(ee, m)
|
227
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
228
|
+
# @param [FFI::Pointer(ModuleRef)] m
|
229
|
+
# @return [nil]
|
230
|
+
# @scope class
|
231
|
+
attach_function :add_module, :LLVMAddModule, [:pointer, :pointer], :void
|
232
|
+
|
233
|
+
# Deprecated: Use LLVMAddModule instead.
|
234
|
+
#
|
235
|
+
# @method add_module_provider(ee, mp)
|
236
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
237
|
+
# @param [FFI::Pointer(ModuleProviderRef)] mp
|
238
|
+
# @return [nil]
|
239
|
+
# @scope class
|
240
|
+
attach_function :add_module_provider, :LLVMAddModuleProvider, [:pointer, :pointer], :void
|
241
|
+
|
242
|
+
# (Not documented)
|
243
|
+
#
|
244
|
+
# @method remove_module(ee, m, out_mod, out_error)
|
245
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
246
|
+
# @param [FFI::Pointer(ModuleRef)] m
|
247
|
+
# @param [FFI::Pointer(*ModuleRef)] out_mod
|
248
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
249
|
+
# @return [Integer]
|
250
|
+
# @scope class
|
251
|
+
attach_function :remove_module, :LLVMRemoveModule, [:pointer, :pointer, :pointer, :pointer], :int
|
252
|
+
|
253
|
+
# Deprecated: Use LLVMRemoveModule instead.
|
254
|
+
#
|
255
|
+
# @method remove_module_provider(ee, mp, out_mod, out_error)
|
256
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
257
|
+
# @param [FFI::Pointer(ModuleProviderRef)] mp
|
258
|
+
# @param [FFI::Pointer(*ModuleRef)] out_mod
|
259
|
+
# @param [FFI::Pointer(**Char_S)] out_error
|
260
|
+
# @return [Integer]
|
261
|
+
# @scope class
|
262
|
+
attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [:pointer, :pointer, :pointer, :pointer], :int
|
263
|
+
|
264
|
+
# (Not documented)
|
265
|
+
#
|
266
|
+
# @method find_function(ee, name, out_fn)
|
267
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
268
|
+
# @param [String] name
|
269
|
+
# @param [FFI::Pointer(*ValueRef)] out_fn
|
270
|
+
# @return [Integer]
|
271
|
+
# @scope class
|
272
|
+
attach_function :find_function, :LLVMFindFunction, [:pointer, :string, :pointer], :int
|
273
|
+
|
274
|
+
# (Not documented)
|
275
|
+
#
|
276
|
+
# @method recompile_and_relink_function(ee, fn)
|
277
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
278
|
+
# @param [FFI::Pointer(ValueRef)] fn
|
279
|
+
# @return [FFI::Pointer(*Void)]
|
280
|
+
# @scope class
|
281
|
+
attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [:pointer, :pointer], :pointer
|
282
|
+
|
283
|
+
# (Not documented)
|
284
|
+
#
|
285
|
+
# @method get_execution_engine_target_data(ee)
|
286
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
287
|
+
# @return [FFI::Pointer(TargetDataRef)]
|
288
|
+
# @scope class
|
289
|
+
attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [:pointer], :pointer
|
290
|
+
|
291
|
+
# (Not documented)
|
292
|
+
#
|
293
|
+
# @method add_global_mapping(ee, global, addr)
|
294
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
295
|
+
# @param [FFI::Pointer(ValueRef)] global
|
296
|
+
# @param [FFI::Pointer(*Void)] addr
|
297
|
+
# @return [nil]
|
298
|
+
# @scope class
|
299
|
+
attach_function :add_global_mapping, :LLVMAddGlobalMapping, [:pointer, :pointer, :pointer], :void
|
300
|
+
|
301
|
+
# (Not documented)
|
302
|
+
#
|
303
|
+
# @method get_pointer_to_global(ee, global)
|
304
|
+
# @param [FFI::Pointer(ExecutionEngineRef)] ee
|
305
|
+
# @param [FFI::Pointer(ValueRef)] global
|
306
|
+
# @return [FFI::Pointer(*Void)]
|
307
|
+
# @scope class
|
308
|
+
attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [:pointer, :pointer], :pointer
|
309
|
+
|
310
|
+
end
|