ruby-llvm 3.0.0.beta → 3.0.0

data/lib/llvm/execution_engine.rb

@@ -2,76 +2,46 @@ require 'llvm'
 require 'llvm/core'
 require 'llvm/target'
 require 'llvm/analysis'
+require 'llvm/execution_engine_ffi'
 
 module LLVM
   # @private
   module C
-    # Generic values
-    attach_function :LLVMCreateGenericValueOfInt, [:pointer, :long_long, :int], :pointer
-    attach_function :LLVMCreateGenericValueOfPointer, [:pointer], :pointer
-    attach_function :LLVMCreateGenericValueOfFloat, [:pointer, :double], :pointer
-
-    attach_function :LLVMGenericValueIntWidth, [:pointer], :uint
-
-    attach_function :LLVMGenericValueToInt, [:pointer, :int], :long_long
-    attach_function :LLVMGenericValueToPointer, [:pointer], :pointer
-    attach_function :LLVMGenericValueToFloat, [:pointer, :pointer], :double
-    attach_function :LLVMDisposeGenericValue, [:pointer], :void
-
-    # Execution engines
-    attach_function :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int
-    attach_function :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int
-    attach_function :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
-    attach_function :LLVMDisposeExecutionEngine, [:pointer], :void
-
-    attach_function :LLVMRunStaticConstructors, [:pointer], :void
-    attach_function :LLVMRunStaticDestructors, [:pointer], :void
-
-    attach_function :LLVMRunFunctionAsMain, [:pointer, :pointer, :uint, :pointer, :pointer], :int
-    attach_function :LLVMRunFunction, [:pointer, :pointer, :uint, :pointer], :pointer
-
-    attach_function :LLVMFreeMachineCodeForFunction, [:pointer, :pointer], :void
-    attach_function :LLVMAddModuleProvider, [:pointer, :pointer], :void
-    attach_function :LLVMRemoveModuleProvider, [:pointer, :pointer, :pointer, :pointer], :int
-
-    attach_function :LLVMFindFunction, [:pointer, :pointer, :pointer, :pointer], :int
-
-    attach_function :LLVMGetExecutionEngineTargetData, [:pointer], :pointer
-
-    attach_function :LLVMAddGlobalMapping, [:pointer, :pointer, :pointer], :void
-
-    attach_function :LLVMGetPointerToGlobal, [:pointer, :pointer], :pointer
-
-    attach_function :LLVMInitializeX86TargetInfo, [], :void
-
-    attach_function :LLVMInitializeX86Target, [], :void
-
-    attach_function :LLVMInitializeX86TargetMC, [], :void
+    attach_function :initialize_x86_target_info, :LLVMInitializeX86TargetInfo, [], :void
+    attach_function :initialize_x86_target, :LLVMInitializeX86Target, [], :void
+    attach_function :initialize_x86_target_mc, :LLVMInitializeX86TargetMC, [], :void
   end
 
   def LLVM.init_x86
-    LLVM::C.LLVMInitializeX86Target
-    LLVM::C.LLVMInitializeX86TargetInfo
-    LLVM::C.LLVMInitializeX86TargetMC
+    LLVM::C.initialize_x86_target
+    LLVM::C.initialize_x86_target_info
+    LLVM::C.initialize_x86_target_mc
   end
 
   class JITCompiler
+    # Important: Call #dispose to free backend memory after use. Do not call #dispose on mod any more.
     def initialize(mod, opt_level = 3)
       FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |ptr|
         error   = FFI::MemoryPointer.new(FFI.type_size(:pointer))
-        status  = C.LLVMCreateJITCompilerForModule(ptr, mod, opt_level, error)
+        status  = C.create_jit_compiler_for_module(ptr, mod, opt_level, error)
         errorp  = error.read_pointer
         message = errorp.read_string unless errorp.null?
 
         if status.zero?
           @ptr = ptr.read_pointer
         else
-          C.LLVMDisposeMessage(error)
+          C.dispose_message(error)
           error.autorelease=false
           raise RuntimeError, "Error creating JIT compiler: #{message}"
         end
       end
     end
+    
+    def dispose
+      return if @ptr.nil?
+      C.dispose_execution_engine(@ptr)
+      @ptr = nil
+    end
 
     # @private
     def to_ptr
@@ -80,19 +50,30 @@ module LLVM
 
     # Execute the given LLVM::Function with the supplied args (as
     # GenericValues).
+    # Important: Call #dispose on the returned GenericValue to
+    # free backend memory after use.
     def run_function(fun, *args)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * args.size) do |args_ptr|
+        new_values = []
         args_ptr.write_array_of_pointer fun.params.zip(args).map { |p, a|
-          a.kind_of?(GenericValue) ? a : LLVM.make_generic_value(p.type, a)
+          if a.kind_of?(GenericValue)
+            a
+          else
+            value = LLVM.make_generic_value(p.type, a)
+            new_values << value
+            value
+          end
         }
-        return LLVM::GenericValue.from_ptr(
-          C.LLVMRunFunction(self, fun, args.size, args_ptr))
+        result = LLVM::GenericValue.from_ptr(
+          C.run_function(self, fun, args.size, args_ptr))
+        new_values.each(&:dispose)
+        return result
       end
     end
 
     # Obtain an FFI::Pointer to a global within the current module.
     def pointer_to_global(global)
-      C.LLVMGetPointerToGlobal(self, global)
+      C.get_pointer_to_global(self, global)
     end
   end
 
@@ -109,22 +90,28 @@ module LLVM
       val.instance_variable_set(:@ptr, ptr)
       val
     end
+    
+    def dispose
+      return if @ptr.nil?
+      C.dispose_generic_value(@ptr)
+      @ptr = nil
+    end
 
     # Creates a Generic Value from an integer. Type is the size of integer to
     # create (ex. Int32, Int8, etc.)
     def self.from_i(i, options = {})
       type   = options.fetch(:type, LLVM::Int)
       signed = options.fetch(:signed, true)
-      from_ptr(C.LLVMCreateGenericValueOfInt(type, i, signed ? 1 : 0))
+      from_ptr(C.create_generic_value_of_int(type, i, signed ? 1 : 0))
     end
 
     # Creates a Generic Value from a Float.
     def self.from_f(f)
-      from_ptr(C.LLVMCreateGenericValueOfFloat(LLVM::Float, f))
+      from_ptr(C.create_generic_value_of_float(LLVM::Float, f))
     end
 
     def self.from_d(val)
-      from_ptr(C.LLVMCreateGenericValueOfFloat(LLVM::Double, val))
+      from_ptr(C.create_generic_value_of_float(LLVM::Double, val))
     end
     
     # Creates a GenericValue from a Ruby boolean.
@@ -134,17 +121,19 @@ module LLVM
 
     # Creates a GenericValue from an FFI::Pointer pointing to some arbitrary value.
     def self.from_value_ptr(ptr)
-      from_ptr(LLVM::C.LLVMCreateGenericValueOfPointer(ptr))
+      from_ptr(LLVM::C.create_generic_value_of_pointer(ptr))
     end
 
     # Converts a GenericValue to a Ruby Integer.
     def to_i(signed = true)
-      C.LLVMGenericValueToInt(self, signed ? 1 : 0)
+      v = C.generic_value_to_int(self, signed ? 1 : 0)
+      v -= 2**64 if signed and v >= 2**63
+      v
     end
 
     # Converts a GenericValue to a Ruby Float.
     def to_f(type = LLVM::Float.type)
-      C.LLVMGenericValueToFloat(type, self)
+      C.generic_value_to_float(type, self)
     end
     
     # Converts a GenericValue to a Ruby boolean.
@@ -153,7 +142,7 @@ module LLVM
     end
     
     def to_value_ptr
-      C.LLVMGenericValueToPointer(self)
+      C.generic_value_to_pointer(self)
     end
   end
 

data/lib/llvm/execution_engine_ffi.rb

@@ -0,0 +1,310 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  ffi_lib 'LLVM-3.0'
+
+  # (Not documented)
+  # 
+  # @method link_in_jit()
+  # @return [nil] 
+  # @scope class
+  attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
+
+  # (Not documented)
+  # 
+  # @method link_in_interpreter()
+  # @return [nil] 
+  # @scope class
+  attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void
+
+  # (Not documented)
+  # 
+  # = Fields:
+  #
+  class OpaqueGenericValue < FFI::Struct
+  end
+
+  # (Not documented)
+  # 
+  # = Fields:
+  #
+  class OpaqueExecutionEngine < FFI::Struct
+  end
+
+  # ===-- Operations on generic values --------------------------------------===
+  # 
+  # @method create_generic_value_of_int(ty, n, is_signed)
+  # @param [FFI::Pointer(TypeRef)] ty 
+  # @param [Integer] n 
+  # @param [Integer] is_signed 
+  # @return [FFI::Pointer(GenericValueRef)] 
+  # @scope class
+  attach_function :create_generic_value_of_int, :LLVMCreateGenericValueOfInt, [:pointer, :ulong_long, :int], :pointer
+
+  # (Not documented)
+  # 
+  # @method create_generic_value_of_pointer(p)
+  # @param [FFI::Pointer(*Void)] p 
+  # @return [FFI::Pointer(GenericValueRef)] 
+  # @scope class
+  attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], :pointer
+
+  # (Not documented)
+  # 
+  # @method create_generic_value_of_float(ty, n)
+  # @param [FFI::Pointer(TypeRef)] ty 
+  # @param [Float] n 
+  # @return [FFI::Pointer(GenericValueRef)] 
+  # @scope class
+  attach_function :create_generic_value_of_float, :LLVMCreateGenericValueOfFloat, [:pointer, :double], :pointer
+
+  # (Not documented)
+  # 
+  # @method generic_value_int_width(gen_val_ref)
+  # @param [FFI::Pointer(GenericValueRef)] gen_val_ref 
+  # @return [Integer] 
+  # @scope class
+  attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [:pointer], :uint
+
+  # (Not documented)
+  # 
+  # @method generic_value_to_int(gen_val, is_signed)
+  # @param [FFI::Pointer(GenericValueRef)] gen_val 
+  # @param [Integer] is_signed 
+  # @return [Integer] 
+  # @scope class
+  attach_function :generic_value_to_int, :LLVMGenericValueToInt, [:pointer, :int], :ulong_long
+
+  # (Not documented)
+  # 
+  # @method generic_value_to_pointer(gen_val)
+  # @param [FFI::Pointer(GenericValueRef)] gen_val 
+  # @return [FFI::Pointer(*Void)] 
+  # @scope class
+  attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [:pointer], :pointer
+
+  # (Not documented)
+  # 
+  # @method generic_value_to_float(ty_ref, gen_val)
+  # @param [FFI::Pointer(TypeRef)] ty_ref 
+  # @param [FFI::Pointer(GenericValueRef)] gen_val 
+  # @return [Float] 
+  # @scope class
+  attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, :pointer], :double
+
+  # (Not documented)
+  # 
+  # @method dispose_generic_value(gen_val)
+  # @param [FFI::Pointer(GenericValueRef)] gen_val 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [:pointer], :void
+
+  # ===-- Operations on execution engines -----------------------------------===
+  # 
+  # @method create_execution_engine_for_module(out_ee, m, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_ee 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_execution_engine_for_module, :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method create_interpreter_for_module(out_interp, m, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_interp 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_interpreter_for_module, :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method create_jit_compiler_for_module(out_jit, m, opt_level, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [Integer] opt_level 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
+
+  # Deprecated: Use LLVMCreateExecutionEngineForModule instead.
+  # 
+  # @method create_execution_engine(out_ee, mp, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_ee 
+  # @param [FFI::Pointer(ModuleProviderRef)] mp 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_execution_engine, :LLVMCreateExecutionEngine, [:pointer, :pointer, :pointer], :int
+
+  # Deprecated: Use LLVMCreateInterpreterForModule instead.
+  # 
+  # @method create_interpreter(out_interp, mp, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_interp 
+  # @param [FFI::Pointer(ModuleProviderRef)] mp 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_interpreter, :LLVMCreateInterpreter, [:pointer, :pointer, :pointer], :int
+
+  # Deprecated: Use LLVMCreateJITCompilerForModule instead.
+  # 
+  # @method create_jit_compiler(out_jit, mp, opt_level, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit 
+  # @param [FFI::Pointer(ModuleProviderRef)] mp 
+  # @param [Integer] opt_level 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, :pointer, :uint, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method dispose_execution_engine(ee)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @return [nil] 
+  # @scope class
+  attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [:pointer], :void
+
+  # (Not documented)
+  # 
+  # @method run_static_constructors(ee)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @return [nil] 
+  # @scope class
+  attach_function :run_static_constructors, :LLVMRunStaticConstructors, [:pointer], :void
+
+  # (Not documented)
+  # 
+  # @method run_static_destructors(ee)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @return [nil] 
+  # @scope class
+  attach_function :run_static_destructors, :LLVMRunStaticDestructors, [:pointer], :void
+
+  # (Not documented)
+  # 
+  # @method run_function_as_main(ee, f, arg_c, arg_v, env_p)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] f 
+  # @param [Integer] arg_c 
+  # @param [FFI::Pointer(**Char_S)] arg_v 
+  # @param [FFI::Pointer(**Char_S)] env_p 
+  # @return [Integer] 
+  # @scope class
+  attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [:pointer, :pointer, :uint, :pointer, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method run_function(ee, f, num_args, args)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] f 
+  # @param [Integer] num_args 
+  # @param [FFI::Pointer(*GenericValueRef)] args 
+  # @return [FFI::Pointer(GenericValueRef)] 
+  # @scope class
+  attach_function :run_function, :LLVMRunFunction, [:pointer, :pointer, :uint, :pointer], :pointer
+
+  # (Not documented)
+  # 
+  # @method free_machine_code_for_function(ee, f)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] f 
+  # @return [nil] 
+  # @scope class
+  attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [:pointer, :pointer], :void
+
+  # (Not documented)
+  # 
+  # @method add_module(ee, m)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_module, :LLVMAddModule, [:pointer, :pointer], :void
+
+  # Deprecated: Use LLVMAddModule instead.
+  # 
+  # @method add_module_provider(ee, mp)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ModuleProviderRef)] mp 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_module_provider, :LLVMAddModuleProvider, [:pointer, :pointer], :void
+
+  # (Not documented)
+  # 
+  # @method remove_module(ee, m, out_mod, out_error)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [FFI::Pointer(*ModuleRef)] out_mod 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :remove_module, :LLVMRemoveModule, [:pointer, :pointer, :pointer, :pointer], :int
+
+  # Deprecated: Use LLVMRemoveModule instead.
+  # 
+  # @method remove_module_provider(ee, mp, out_mod, out_error)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ModuleProviderRef)] mp 
+  # @param [FFI::Pointer(*ModuleRef)] out_mod 
+  # @param [FFI::Pointer(**Char_S)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [:pointer, :pointer, :pointer, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method find_function(ee, name, out_fn)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [String] name 
+  # @param [FFI::Pointer(*ValueRef)] out_fn 
+  # @return [Integer] 
+  # @scope class
+  attach_function :find_function, :LLVMFindFunction, [:pointer, :string, :pointer], :int
+
+  # (Not documented)
+  # 
+  # @method recompile_and_relink_function(ee, fn)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] fn 
+  # @return [FFI::Pointer(*Void)] 
+  # @scope class
+  attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [:pointer, :pointer], :pointer
+
+  # (Not documented)
+  # 
+  # @method get_execution_engine_target_data(ee)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @return [FFI::Pointer(TargetDataRef)] 
+  # @scope class
+  attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [:pointer], :pointer
+
+  # (Not documented)
+  # 
+  # @method add_global_mapping(ee, global, addr)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] global 
+  # @param [FFI::Pointer(*Void)] addr 
+  # @return [nil] 
+  # @scope class
+  attach_function :add_global_mapping, :LLVMAddGlobalMapping, [:pointer, :pointer, :pointer], :void
+
+  # (Not documented)
+  # 
+  # @method get_pointer_to_global(ee, global)
+  # @param [FFI::Pointer(ExecutionEngineRef)] ee 
+  # @param [FFI::Pointer(ValueRef)] global 
+  # @return [FFI::Pointer(*Void)] 
+  # @scope class
+  attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [:pointer, :pointer], :pointer
+
+end