ruby-llvm 3.3.0 → 10.0.0

data/lib/llvm/execution_engine.rb

@@ -5,12 +5,19 @@ require 'llvm/analysis'
 require 'llvm/execution_engine_ffi'
 
 module LLVM
-  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)
+  # @abstract Subclass and override {#create_execution_engine_for_module}.
+  class ExecutionEngine
+    # Create a JIT execution engine for module with the given options.
+    #
+    # @note Important: Call #dispose to free backend memory after use. Do not call #dispose on mod any more.
+    #
+    # @param [LLVM::Module] mod module
+    # @param [Hash{Symbol => Object}] options options
+    # @return [ExecutionEngine] JIT execution engine
+    def initialize(mod, options)
       FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |ptr|
         error   = FFI::MemoryPointer.new(FFI.type_size(:pointer))
-        status  = C.create_jit_compiler_for_module(ptr, mod, opt_level, error)
+        status  = create_execution_engine_for_module(ptr, mod, error, options)
         errorp  = error.read_pointer
         message = errorp.read_string unless errorp.null?
 
@@ -18,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
@@ -42,6 +49,13 @@ module LLVM
       TargetDataLayout.from_ptr(C.get_execution_engine_target_data(self))
     end
 
+    # Get the associated target machine.
+    #
+    # @return [TargetMachine]
+    def target_machine
+      TargetMachine.from_ptr(C.get_execution_engine_target_machine(self))
+    end
+
     # Execute the given LLVM::Function with the supplied args (as
     # GenericValues).
     # Important: Call #dispose on the returned GenericValue to
@@ -49,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
@@ -57,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)
@@ -69,8 +83,162 @@ module LLVM
     def pointer_to_global(global)
       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
+      @modules ||= ModuleCollection.new(self)
+    end
+
+    # Returns a FunctionCollection of all the Functions in the engine.
+    # @return [FunctionCollection]
+    def functions
+      @functions ||= FunctionCollection.new(self)
+    end
+
+    class ModuleCollection
+      # @param [ExecutionEngine] engine
+      def initialize(engine)
+        @engine = engine
+      end
+
+      # @param [LLVM::Module] mod
+      # @return [ModuleCollection]
+      def add(mod)
+        tap { C.add_module(@engine, mod) }
+      end
+
+      # @param [LLVM::Module] mod
+      # @return [LLVM::Module] deleted module
+      def delete(mod)
+        error   = FFI::MemoryPointer.new(:pointer)
+        out_mod = FFI::MemoryPointer.new(:pointer)
+
+        status = C.remove_module(@engine, mod, out_mod, error)
+
+        if status.zero?
+          LLVM::Module.from_ptr(out_mod.read_pointer)
+        else
+          errorp  = error.read_pointer
+          message = errorp.read_string unless errorp.null?
+
+          C.dispose_message(error)
+          error.autorelease = false
+
+          raise "Error removing module: #{message}"
+        end
+      end
+
+      alias_method :<<, :add
+    end
+
+    class FunctionCollection
+      # @param [ExecutionEngine] engine
+      def initialize(engine)
+        @engine = engine
+      end
+
+      # @param [String, Symbol] name function name
+      # @return [Function]
+      def named(name)
+        out_fun = FFI::MemoryPointer.new(:pointer)
+
+        status = C.find_function(@engine, name.to_s, out_fun)
+        return unless status.zero?
+
+        Function.from_ptr(out_fun.read_pointer)
+      end
+
+      alias_method :[], :named
+    end
+
+    protected
+
+    # Create a JIT execution engine for module with the given options.
+    #
+    # @param [FFI::Pointer(*ExecutionEngineRef)] out_ee execution engine
+    # @param [LLVM::Module] mod module
+    # @param [FFI::Pointer(**CharS)] out_error error message
+    # @param [Hash{Symbol => Object}] options options. `:opt_level => 3` for example.
+    # @return [Integer] 0 for success, non- zero to indicate an error
+    def create_execution_engine_for_module(out_ee, mod, out_error, options)
+      raise NotImplementedError, "override in subclass"
+    end
+  end
+
+  class MCJITCompiler < ExecutionEngine
+    # Create a MCJIT execution engine.
+    #
+    # @note You should call `LLVM.init_jit(true)` before creating an execution engine.
+    # @todo Add :mcjmm option (MCJIT memory manager)
+    #
+    # @param [LLVM::Module] mod module
+    # @param [Hash{Symbol => Object}] options options
+    # @option options [Integer] :opt_level (2) Optimization level
+    # @option options [Integer] :code_model (0) Code model types
+    # @option options [Boolean] :no_frame_pointer_elim (false) Disable frame pointer elimination optimization
+    # @option options [Boolean] :enable_fast_i_sel (false) Enables fast-path instruction selection
+    # @return [ExecutionEngine] Execution engine
+    def initialize(mod, options = {})
+      options = {
+        :opt_level             => 2, # LLVMCodeGenLevelDefault
+        :code_model            => 0,
+        :no_frame_pointer_elim => false,
+        :enable_fast_i_sel     => false,
+        # TODO
+        #:mcjmm                 => nil,
+      }.merge(options)
+
+      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)
+      mcopts = LLVM::C::MCJITCompilerOptions.new
+
+      LLVM::C.initialize_mcjit_compiler_options(mcopts, mcopts.size)
+
+      mcopts[:opt_level]             = options[:opt_level]
+      mcopts[:code_model]            = options[:code_model]
+      mcopts[:no_frame_pointer_elim] = options[:no_frame_pointer_elim] ? 1 : 0
+      mcopts[:enable_fast_i_sel]     = options[:enable_fast_i_sel] ? 1 : 0
+
+      C.create_mcjit_compiler_for_module(out_ee, mod, mcopts, mcopts.size, out_error)
+    end
   end
 
+  JITCompiler = MCJITCompiler
+
   class GenericValue
     # @private
     def to_ptr

data/lib/llvm/execution_engine_ffi.rb

@@ -4,369 +4,418 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.3'
-  
+  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
-  
-  # (Not documented)
-  # 
-  # @method link_in_jit()
-  # @return [nil] 
-  # @scope class
-  attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
-  
-  # (Not documented)
-  # 
+
+  # @defgroup LLVMCExecutionEngine Execution Engine
+  # @ingroup LLVMC
+  #
+  # @{
+  #
   # @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)
   class MCJITCompilerOptions < FFI::Struct
     layout :opt_level, :uint,
            :code_model, :char,
            :no_frame_pointer_elim, :int,
-           :enable_fast_i_sel, :int
+           :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)]
+  # @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_(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_(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_(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]
+  # @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]
+  # @scope class
+  attach_function :dispose_mcjit_memory_manager, :LLVMDisposeMCJITMemoryManager, [OpaqueMCJITMemoryManager], :void
 end