ruby-llvm 3.5.0 → 10.0.0

data/lib/llvm/execution_engine.rb

@@ -25,8 +25,8 @@ module LLVM
           @ptr = ptr.read_pointer
         else
           C.dispose_message(error)
-          error.autorelease=false
-          raise RuntimeError, "Error creating JIT compiler: #{message}"
+          error.autorelease = false
+          raise "Error creating JIT compiler: #{message}"
         end
       end
     end
@@ -63,7 +63,7 @@ module LLVM
     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|
+        args_ptr.write_array_of_pointer(fun.params.zip(args).map do |p, a|
           if a.kind_of?(GenericValue)
             a
           else
@@ -71,7 +71,7 @@ module LLVM
             new_values << value
             value
           end
-        }
+        end)
         result = LLVM::GenericValue.from_ptr(
           C.run_function(self, fun, args.size, args_ptr))
         new_values.each(&:dispose)
@@ -84,6 +84,10 @@ module LLVM
       C.get_pointer_to_global(self, global)
     end
 
+    def function_address(name)
+      C.get_function_address(self, name)
+    end
+
     # Returns a ModuleCollection of all the Modules in the engine.
     # @return [ModuleCollection]
     def modules
@@ -123,7 +127,7 @@ module LLVM
           message = errorp.read_string unless errorp.null?
 
           C.dispose_message(error)
-          error.autorelease=false
+          error.autorelease = false
 
           raise "Error removing module: #{message}"
         end
@@ -166,35 +170,6 @@ module LLVM
     end
   end
 
-  class JITCompiler < ExecutionEngine
-    # Create a JIT execution engine.
-    #
-    # @note You should call `LLVM.init_jit` before creating an execution engine.
-    #
-    # @param [LLVM::Module] mod module
-    # @param [Hash{Symbol => Object}] options options
-    # @option options [Integer] :opt_level (3) Optimization level
-    # @return [ExecutionEngine] Execution engine
-    def initialize(mod, options = {})
-      # Prior to ruby-llvm 3.4.0, signature is initialize(mod, opt_level = 3)
-      if options.kind_of?(Integer)
-        options = { :opt_level => options }
-      end
-
-      options = {
-        :opt_level => 3,
-      }.merge(options)
-
-      super
-    end
-
-    protected
-
-    def create_execution_engine_for_module(out_ee, mod, out_error, options)
-      C.create_jit_compiler_for_module(out_ee, mod, options[:opt_level], out_error)
-    end
-  end
-
   class MCJITCompiler < ExecutionEngine
     # Create a MCJIT execution engine.
     #
@@ -211,7 +186,7 @@ module LLVM
     def initialize(mod, options = {})
       options = {
         :opt_level             => 2, # LLVMCodeGenLevelDefault
-        :code_model            => 0, # LLVMCodeModelDefault
+        :code_model            => 0,
         :no_frame_pointer_elim => false,
         :enable_fast_i_sel     => false,
         # TODO
@@ -221,6 +196,31 @@ module LLVM
       super
     end
 
+    def convert_type(type)
+      case type.kind
+      when :integer
+        if type.width <= 8
+          :int8
+        else
+          "int#{type.width}".to_sym
+        end
+      else
+        type.kind
+      end
+    end
+
+    def run_function(fun, *args)
+      args2 = fun.params.map {|e| convert_type(e.type)}
+      ptr = FFI::Pointer.new(function_address(fun.name))
+      raise "Couldn't find function" if ptr.null?
+
+      return_type = convert_type(fun.function_type.return_type)
+      f = FFI::Function.new(return_type, args2, ptr)
+      ret1 = f.call(*args)
+      ret2 = LLVM.make_generic_value(fun.function_type.return_type, ret1)
+      ret2
+    end
+
     protected
 
     def create_execution_engine_for_module(out_ee, mod, out_error, options)
@@ -237,6 +237,8 @@ module LLVM
     end
   end
 
+  JITCompiler = MCJITCompiler
+
   class GenericValue
     # @private
     def to_ptr

data/lib/llvm/execution_engine_ffi.rb

@@ -4,66 +4,59 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib ["libLLVM-3.5.so.1", "LLVM-3.5"]
-  
+  ffi_lib ["libLLVM-10.so.1", "LLVM-10"]
+
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
       (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
     end
   end
-  
+
   # @defgroup LLVMCExecutionEngine Execution Engine
   # @ingroup LLVMC
-  # 
+  #
   # @{
-  # 
-  # @method link_in_jit()
-  # @return [nil] 
-  # @scope class
-  attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
-  
-  # (Not documented)
-  # 
+  #
   # @method link_in_mcjit()
-  # @return [nil] 
+  # @return [nil]
   # @scope class
   attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method link_in_interpreter()
-  # @return [nil] 
+  # @return [nil]
   # @scope class
   attach_function :link_in_interpreter, :LLVMLinkInInterpreter, [], :void
-  
+
   # (Not documented)
   class OpaqueGenericValue < FFI::Struct
     layout :dummy, :char
   end
-  
+
   # (Not documented)
   class OpaqueExecutionEngine < FFI::Struct
     layout :dummy, :char
   end
-  
+
   # (Not documented)
   class OpaqueMCJITMemoryManager < FFI::Struct
     layout :dummy, :char
   end
-  
+
   # (Not documented)
-  # 
+  #
   # = Fields:
   # :opt_level ::
-  #   (Integer) 
+  #   (Integer)
   # :code_model ::
-  #   (unknown) 
+  #   (unknown)
   # :no_frame_pointer_elim ::
-  #   (Integer) 
+  #   (Integer)
   # :enable_fast_i_sel ::
-  #   (Integer) 
+  #   (Integer)
   # :mcjmm ::
-  #   (OpaqueMCJITMemoryManager) 
+  #   (OpaqueMCJITMemoryManager)
   class MCJITCompilerOptions < FFI::Struct
     layout :opt_level, :uint,
            :code_model, :char,
@@ -71,389 +64,358 @@ module LLVM::C
            :enable_fast_i_sel, :int,
            :mcjmm, OpaqueMCJITMemoryManager
   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 [OpaqueGenericValue] 
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @param [Integer] n
+  # @param [Integer] is_signed
+  # @return [OpaqueGenericValue]
   # @scope class
   attach_function :create_generic_value_of_int, :LLVMCreateGenericValueOfInt, [:pointer, :ulong_long, :int], OpaqueGenericValue
-  
+
   # (Not documented)
-  # 
+  #
   # @method create_generic_value_of_pointer(p)
-  # @param [FFI::Pointer(*Void)] p 
-  # @return [OpaqueGenericValue] 
+  # @param [FFI::Pointer(*Void)] p
+  # @return [OpaqueGenericValue]
   # @scope class
   attach_function :create_generic_value_of_pointer, :LLVMCreateGenericValueOfPointer, [:pointer], OpaqueGenericValue
-  
+
   # (Not documented)
-  # 
+  #
   # @method create_generic_value_of_float(ty, n)
-  # @param [FFI::Pointer(TypeRef)] ty 
-  # @param [Float] n 
-  # @return [OpaqueGenericValue] 
+  # @param [FFI::Pointer(TypeRef)] ty
+  # @param [Float] n
+  # @return [OpaqueGenericValue]
   # @scope class
   attach_function :create_generic_value_of_float, :LLVMCreateGenericValueOfFloat, [:pointer, :double], OpaqueGenericValue
-  
+
   # (Not documented)
-  # 
+  #
   # @method generic_value_int_width(gen_val_ref)
-  # @param [OpaqueGenericValue] gen_val_ref 
-  # @return [Integer] 
+  # @param [OpaqueGenericValue] gen_val_ref
+  # @return [Integer]
   # @scope class
   attach_function :generic_value_int_width, :LLVMGenericValueIntWidth, [OpaqueGenericValue], :uint
-  
+
   # (Not documented)
-  # 
+  #
   # @method generic_value_to_int(gen_val, is_signed)
-  # @param [OpaqueGenericValue] gen_val 
-  # @param [Integer] is_signed 
-  # @return [Integer] 
+  # @param [OpaqueGenericValue] gen_val
+  # @param [Integer] is_signed
+  # @return [Integer]
   # @scope class
   attach_function :generic_value_to_int, :LLVMGenericValueToInt, [OpaqueGenericValue, :int], :ulong_long
-  
+
   # (Not documented)
-  # 
+  #
   # @method generic_value_to_pointer(gen_val)
-  # @param [OpaqueGenericValue] gen_val 
-  # @return [FFI::Pointer(*Void)] 
+  # @param [OpaqueGenericValue] gen_val
+  # @return [FFI::Pointer(*Void)]
   # @scope class
   attach_function :generic_value_to_pointer, :LLVMGenericValueToPointer, [OpaqueGenericValue], :pointer
-  
+
   # (Not documented)
-  # 
+  #
   # @method generic_value_to_float(ty_ref, gen_val)
-  # @param [FFI::Pointer(TypeRef)] ty_ref 
-  # @param [OpaqueGenericValue] gen_val 
-  # @return [Float] 
+  # @param [FFI::Pointer(TypeRef)] ty_ref
+  # @param [OpaqueGenericValue] gen_val
+  # @return [Float]
   # @scope class
   attach_function :generic_value_to_float, :LLVMGenericValueToFloat, [:pointer, OpaqueGenericValue], :double
-  
+
   # (Not documented)
-  # 
+  #
   # @method dispose_generic_value(gen_val)
-  # @param [OpaqueGenericValue] gen_val 
-  # @return [nil] 
+  # @param [OpaqueGenericValue] gen_val
+  # @return [nil]
   # @scope class
   attach_function :dispose_generic_value, :LLVMDisposeGenericValue, [OpaqueGenericValue], :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(**CharS)] out_error 
-  # @return [Integer] 
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_ee
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [FFI::Pointer(**CharS)] 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(**CharS)] out_error 
-  # @return [Integer] 
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_interp
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [FFI::Pointer(**CharS)] 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(**CharS)] out_error 
-  # @return [Integer] 
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [Integer] opt_level
+  # @param [FFI::Pointer(**CharS)] out_error
+  # @return [Integer]
   # @scope class
   attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
-  
+
   # (Not documented)
-  # 
+  #
   # @method initialize_mcjit_compiler_options(options, size_of_options)
-  # @param [MCJITCompilerOptions] options 
-  # @param [Integer] size_of_options 
-  # @return [nil] 
+  # @param [MCJITCompilerOptions] options
+  # @param [Integer] size_of_options
+  # @return [nil]
   # @scope class
   attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void
-  
+
   # Create an MCJIT execution engine for a module, with the given options. It is
   # the responsibility of the caller to ensure that all fields in Options up to
   # the given SizeOfOptions are initialized. It is correct to pass a smaller
   # value of SizeOfOptions that omits some fields. The canonical way of using
   # this is:
-  # 
+  #
   # LLVMMCJITCompilerOptions options;
   # LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
   # ... fill in those options you care about
   # LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
   #                                  &error);
-  # 
+  #
   # Note that this is also correct, though possibly suboptimal:
-  # 
+  #
   # LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
-  # 
+  #
   # @method create_mcjit_compiler_for_module(out_jit, m, options, size_of_options, out_error)
-  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit 
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [MCJITCompilerOptions] options 
-  # @param [Integer] size_of_options 
-  # @param [FFI::Pointer(**CharS)] out_error 
-  # @return [Integer] 
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [MCJITCompilerOptions] options
+  # @param [Integer] size_of_options
+  # @param [FFI::Pointer(**CharS)] out_error
+  # @return [Integer]
   # @scope class
   attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, :pointer, MCJITCompilerOptions, :ulong, :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(**CharS)] 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(**CharS)] 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(**CharS)] out_error 
-  # @return [Integer] 
-  # @scope class
-  attach_function :create_jit_compiler, :LLVMCreateJITCompiler, [:pointer, :pointer, :uint, :pointer], :int
-  
-  # (Not documented)
-  # 
+
+  # (Not documented)
+  #
   # @method dispose_execution_engine(ee)
-  # @param [OpaqueExecutionEngine] ee 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @return [nil]
   # @scope class
   attach_function :dispose_execution_engine, :LLVMDisposeExecutionEngine, [OpaqueExecutionEngine], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method run_static_constructors(ee)
-  # @param [OpaqueExecutionEngine] ee 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @return [nil]
   # @scope class
   attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method run_static_destructors(ee)
-  # @param [OpaqueExecutionEngine] ee 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @return [nil]
   # @scope class
   attach_function :run_static_destructors, :LLVMRunStaticDestructors, [OpaqueExecutionEngine], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method run_function_as_main(ee, f, arg_c, arg_v, env_p)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] f 
-  # @param [Integer] arg_c 
-  # @param [FFI::Pointer(**CharS)] arg_v 
-  # @param [FFI::Pointer(**CharS)] env_p 
-  # @return [Integer] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] f
+  # @param [Integer] arg_c
+  # @param [FFI::Pointer(**CharS)] arg_v
+  # @param [FFI::Pointer(**CharS)] env_p
+  # @return [Integer]
   # @scope class
   attach_function :run_function_as_main, :LLVMRunFunctionAsMain, [OpaqueExecutionEngine, :pointer, :uint, :pointer, :pointer], :int
-  
+
   # (Not documented)
-  # 
+  #
   # @method run_function(ee, f, num_args, args)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] f 
-  # @param [Integer] num_args 
-  # @param [FFI::Pointer(*GenericValueRef)] args 
-  # @return [OpaqueGenericValue] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] f
+  # @param [Integer] num_args
+  # @param [FFI::Pointer(*GenericValueRef)] args
+  # @return [OpaqueGenericValue]
   # @scope class
   attach_function :run_function, :LLVMRunFunction, [OpaqueExecutionEngine, :pointer, :uint, :pointer], OpaqueGenericValue
-  
+
   # (Not documented)
-  # 
+  #
   # @method free_machine_code_for_function(ee, f)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] f 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] f
+  # @return [nil]
   # @scope class
   attach_function :free_machine_code_for_function, :LLVMFreeMachineCodeForFunction, [OpaqueExecutionEngine, :pointer], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method add_module(ee, m)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @return [nil]
   # @scope class
   attach_function :add_module, :LLVMAddModule, [OpaqueExecutionEngine, :pointer], :void
-  
-  # Deprecated: Use LLVMAddModule instead.
-  # 
-  # @method add_module_provider(ee, mp)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ModuleProviderRef)] mp 
-  # @return [nil] 
-  # @scope class
-  attach_function :add_module_provider, :LLVMAddModuleProvider, [OpaqueExecutionEngine, :pointer], :void
-  
-  # (Not documented)
-  # 
+
+  # (Not documented)
+  #
   # @method remove_module(ee, m, out_mod, out_error)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ModuleRef)] m 
-  # @param [FFI::Pointer(*ModuleRef)] out_mod 
-  # @param [FFI::Pointer(**CharS)] out_error 
-  # @return [Integer] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ModuleRef)] m
+  # @param [FFI::Pointer(*ModuleRef)] out_mod
+  # @param [FFI::Pointer(**CharS)] out_error
+  # @return [Integer]
   # @scope class
   attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int
-  
-  # Deprecated: Use LLVMRemoveModule instead.
-  # 
-  # @method remove_module_provider(ee, mp, out_mod, out_error)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ModuleProviderRef)] mp 
-  # @param [FFI::Pointer(*ModuleRef)] out_mod 
-  # @param [FFI::Pointer(**CharS)] out_error 
-  # @return [Integer] 
-  # @scope class
-  attach_function :remove_module_provider, :LLVMRemoveModuleProvider, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int
-  
-  # (Not documented)
-  # 
+
+  # (Not documented)
+  #
   # @method find_function(ee, name, out_fn)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [String] name 
-  # @param [FFI::Pointer(*ValueRef)] out_fn 
-  # @return [Integer] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [String] name
+  # @param [FFI::Pointer(*ValueRef)] out_fn
+  # @return [Integer]
   # @scope class
   attach_function :find_function, :LLVMFindFunction, [OpaqueExecutionEngine, :string, :pointer], :int
-  
+
   # (Not documented)
-  # 
+  #
   # @method recompile_and_relink_function(ee, fn)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] fn 
-  # @return [FFI::Pointer(*Void)] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] fn
+  # @return [FFI::Pointer(*Void)]
   # @scope class
   attach_function :recompile_and_relink_function, :LLVMRecompileAndRelinkFunction, [OpaqueExecutionEngine, :pointer], :pointer
-  
+
   # (Not documented)
-  # 
+  #
   # @method get_execution_engine_target_data(ee)
-  # @param [OpaqueExecutionEngine] ee 
-  # @return [FFI::Pointer(TargetDataRef)] 
+  # @param [OpaqueExecutionEngine] ee
+  # @return [FFI::Pointer(TargetDataRef)]
   # @scope class
   attach_function :get_execution_engine_target_data, :LLVMGetExecutionEngineTargetData, [OpaqueExecutionEngine], :pointer
-  
+
   # (Not documented)
-  # 
+  #
   # @method get_execution_engine_target_machine(ee)
-  # @param [OpaqueExecutionEngine] ee 
-  # @return [FFI::Pointer(TargetMachineRef)] 
+  # @param [OpaqueExecutionEngine] ee
+  # @return [FFI::Pointer(TargetMachineRef)]
   # @scope class
   attach_function :get_execution_engine_target_machine, :LLVMGetExecutionEngineTargetMachine, [OpaqueExecutionEngine], :pointer
-  
+
   # (Not documented)
-  # 
+  #
   # @method add_global_mapping(ee, global, addr)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] global 
-  # @param [FFI::Pointer(*Void)] addr 
-  # @return [nil] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] global
+  # @param [FFI::Pointer(*Void)] addr
+  # @return [nil]
   # @scope class
   attach_function :add_global_mapping, :LLVMAddGlobalMapping, [OpaqueExecutionEngine, :pointer, :pointer], :void
-  
+
   # (Not documented)
-  # 
+  #
   # @method get_pointer_to_global(ee, global)
-  # @param [OpaqueExecutionEngine] ee 
-  # @param [FFI::Pointer(ValueRef)] global 
-  # @return [FFI::Pointer(*Void)] 
+  # @param [OpaqueExecutionEngine] ee
+  # @param [FFI::Pointer(ValueRef)] global
+  # @return [FFI::Pointer(*Void)]
   # @scope class
   attach_function :get_pointer_to_global, :LLVMGetPointerToGlobal, [OpaqueExecutionEngine, :pointer], :pointer
-  
+
+  # (Not documented)
+  #
+  # @method get_global_value_address(ee, name)
+  # @param [OpaqueExecutionEngine] ee
+  # @param [String] name
+  # @return [Integer]
+  # @scope class
+  attach_function :get_global_value_address, :LLVMGetGlobalValueAddress, [OpaqueExecutionEngine, :string], :ulong
+
+  # (Not documented)
+  #
+  # @method get_function_address(ee, name)
+  # @param [OpaqueExecutionEngine] ee
+  # @param [String] name
+  # @return [Integer]
+  # @scope class
+  attach_function :get_function_address, :LLVMGetFunctionAddress, [OpaqueExecutionEngine, :string], :ulong
+
   # ===-- Operations on memory managers -------------------------------------===
-  # 
+  #
   # <em>This entry is only for documentation and no real method.</em>
-  # 
-  # @method _callback_memory_manager_allocate_code_section_callback_(opaque, size, alignment, section_id, section_name)
-  # @param [FFI::Pointer(*Void)] opaque 
-  # @param [Integer] size 
-  # @param [Integer] alignment 
-  # @param [Integer] section_id 
-  # @param [String] section_name 
-  # @return [Integer] 
-  # @scope class
-  callback :memory_manager_allocate_code_section_callback, [:pointer, :ulong, :uint, :uint, :string], :uchar
-  
-  # (Not documented)
-  # 
+  #
+  # @method _callback_memory_manager_allocate_code_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name)
+  # @param [Integer] uint8_t
+  # @param [FFI::Pointer(*Void)] opaque
+  # @param [Integer] size
+  # @param [Integer] alignment
+  # @param [Integer] section_id
+  # @param [String] section_name
+  # @return [Integer]
+  # @scope class
+  callback :memory_manager_allocate_code_section_callback, [:uchar, :pointer, :ulong, :uint, :uint, :string], :uchar
+
+  # (Not documented)
+  #
   # <em>This entry is only for documentation and no real method.</em>
-  # 
-  # @method _callback_memory_manager_allocate_data_section_callback_(opaque, size, alignment, section_id, section_name, is_read_only)
-  # @param [FFI::Pointer(*Void)] opaque 
-  # @param [Integer] size 
-  # @param [Integer] alignment 
-  # @param [Integer] section_id 
-  # @param [String] section_name 
-  # @param [Integer] is_read_only 
-  # @return [Integer] 
-  # @scope class
-  callback :memory_manager_allocate_data_section_callback, [:pointer, :ulong, :uint, :uint, :string, :int], :uchar
-  
-  # (Not documented)
-  # 
+  #
+  # @method _callback_memory_manager_allocate_data_section_callback_(uint8_t, opaque, size, alignment, section_id, section_name, is_read_only)
+  # @param [Integer] uint8_t
+  # @param [FFI::Pointer(*Void)] opaque
+  # @param [Integer] size
+  # @param [Integer] alignment
+  # @param [Integer] section_id
+  # @param [String] section_name
+  # @param [Integer] is_read_only
+  # @return [Integer]
+  # @scope class
+  callback :memory_manager_allocate_data_section_callback, [:uchar, :pointer, :ulong, :uint, :uint, :string, :int], :uchar
+
+  # (Not documented)
+  #
   # <em>This entry is only for documentation and no real method.</em>
-  # 
-  # @method _callback_memory_manager_finalize_memory_callback_(opaque, err_msg)
-  # @param [FFI::Pointer(*Void)] opaque 
-  # @param [FFI::Pointer(**CharS)] err_msg 
-  # @return [Integer] 
-  # @scope class
-  callback :memory_manager_finalize_memory_callback, [:pointer, :pointer], :int
-  
+  #
+  # @method _callback_memory_manager_finalize_memory_callback_(bool, opaque, err_msg)
+  # @param [Integer] bool
+  # @param [FFI::Pointer(*Void)] opaque
+  # @param [FFI::Pointer(**CharS)] err_msg
+  # @return [Integer]
+  # @scope class
+  callback :memory_manager_finalize_memory_callback, [:int, :pointer, :pointer], :int
+
   # Create a simple custom MCJIT memory manager. This memory manager can
   # intercept allocations in a module-oblivious way. This will return NULL
   # if any of the passed functions are NULL.
-  # 
+  #
   # @param Opaque An opaque client object to pass back to the callbacks.
   # @param AllocateCodeSection Allocate a block of memory for executable code.
   # @param AllocateDataSection Allocate a block of memory for data.
   # @param FinalizeMemory Set page permissions and flush cache. Return 0 on
   #   success, 1 on error.
-  # 
+  #
   # @method create_simple_mcjit_memory_manager(opaque, allocate_code_section, allocate_data_section, finalize_memory, destroy)
-  # @param [FFI::Pointer(*Void)] opaque 
-  # @param [Proc(_callback_memory_manager_allocate_code_section_callback_)] allocate_code_section 
-  # @param [Proc(_callback_memory_manager_allocate_data_section_callback_)] allocate_data_section 
-  # @param [Proc(_callback_memory_manager_finalize_memory_callback_)] finalize_memory 
-  # @param [FFI::Pointer(MemoryManagerDestroyCallback)] destroy 
-  # @return [OpaqueMCJITMemoryManager] 
+  # @param [FFI::Pointer(*Void)] opaque
+  # @param [Proc(_callback_memory_manager_allocate_code_section_callback_)] allocate_code_section
+  # @param [Proc(_callback_memory_manager_allocate_data_section_callback_)] allocate_data_section
+  # @param [Proc(_callback_memory_manager_finalize_memory_callback_)] finalize_memory
+  # @param [FFI::Pointer(MemoryManagerDestroyCallback)] destroy
+  # @return [OpaqueMCJITMemoryManager]
   # @scope class
   attach_function :create_simple_mcjit_memory_manager, :LLVMCreateSimpleMCJITMemoryManager, [:pointer, :memory_manager_allocate_code_section_callback, :memory_manager_allocate_data_section_callback, :memory_manager_finalize_memory_callback, :pointer], OpaqueMCJITMemoryManager
-  
+
   # (Not documented)
-  # 
+  #
   # @method dispose_mcjit_memory_manager(mm)
-  # @param [OpaqueMCJITMemoryManager] mm 
-  # @return [nil] 
+  # @param [OpaqueMCJITMemoryManager] mm
+  # @return [nil]
   # @scope class
   attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void
-  
 end