ruby-llvm-next 10.0.0

data/lib/llvm/execution_engine.rb

@@ -0,0 +1,323 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/target'
+require 'llvm/analysis'
+require 'llvm/execution_engine_ffi'
+
+module LLVM
+  # @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  = create_execution_engine_for_module(ptr, mod, error, options)
+        errorp  = error.read_pointer
+        message = errorp.read_string unless errorp.null?
+
+        if status.zero?
+          @ptr = ptr.read_pointer
+        else
+          C.dispose_message(error)
+          error.autorelease = false
+          raise "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
+      @ptr
+    end
+
+    # Get the associated data layout.
+    #
+    # @return [TargetDataLayout]
+    def data_layout
+      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
+    # 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 do |p, a|
+          if a.kind_of?(GenericValue)
+            a
+          else
+            value = LLVM.make_generic_value(p.type, a)
+            new_values << value
+            value
+          end
+        end)
+        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.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
+      @ptr
+    end
+
+    # Casts an FFI::Pointer pointing to a GenericValue to an instance.
+    def self.from_ptr(ptr)
+      return if ptr.null?
+      val = allocate
+      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.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.create_generic_value_of_float(LLVM::Float, f))
+    end
+
+    def self.from_d(val)
+      from_ptr(C.create_generic_value_of_float(LLVM::Double, val))
+    end
+
+    # Creates a GenericValue from a Ruby boolean.
+    def self.from_b(b)
+      from_i(b ? 1 : 0, LLVM::Int1, false)
+    end
+
+    # Creates a GenericValue from an FFI::Pointer pointing to some arbitrary value.
+    def self.from_value_ptr(ptr)
+      from_ptr(LLVM::C.create_generic_value_of_pointer(ptr))
+    end
+
+    # Converts a GenericValue to a Ruby Integer.
+    def to_i(signed = true)
+      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.generic_value_to_float(type, self)
+    end
+
+    # Converts a GenericValue to a Ruby boolean.
+    def to_b
+      to_i(false) != 0
+    end
+
+    def to_value_ptr
+      C.generic_value_to_pointer(self)
+    end
+  end
+
+  # @private
+  def make_generic_value(ty, val)
+    case ty.kind
+    when :double  then GenericValue.from_d(val)
+    when :float   then GenericValue.from_f(val)
+    when :pointer then GenericValue.from_value_ptr(val)
+    when :integer then GenericValue.from_i(val, :type => ty)
+    else
+      raise "Unsupported type #{ty.kind}."
+    end
+  end
+  module_function :make_generic_value
+end

data/lib/llvm/execution_engine_ffi.rb

@@ -0,0 +1,421 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  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_mcjit()
+  # @return [nil]
+  # @scope class
+  attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void
+
+  # (Not documented)
+  #
+  # @method link_in_interpreter()
+  # @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)
+  # :code_model ::
+  #   (unknown)
+  # :no_frame_pointer_elim ::
+  #   (Integer)
+  # :enable_fast_i_sel ::
+  #   (Integer)
+  # :mcjmm ::
+  #   (OpaqueMCJITMemoryManager)
+  class MCJITCompilerOptions < FFI::Struct
+    layout :opt_level, :uint,
+           :code_model, :char,
+           :no_frame_pointer_elim, :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]
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @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)]
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @scope class
+  attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, :pointer, MCJITCompilerOptions, :ulong, :pointer], :int
+
+  # (Not documented)
+  #
+  # @method dispose_execution_engine(ee)
+  # @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]
+  # @scope class
+  attach_function :run_static_constructors, :LLVMRunStaticConstructors, [OpaqueExecutionEngine], :void
+
+  # (Not documented)
+  #
+  # @method run_static_destructors(ee)
+  # @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]
+  # @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]
+  # @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]
+  # @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]
+  # @scope class
+  attach_function :add_module, :LLVMAddModule, [OpaqueExecutionEngine, :pointer], :void
+
+  # (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]
+  # @scope class
+  attach_function :remove_module, :LLVMRemoveModule, [OpaqueExecutionEngine, :pointer, :pointer, :pointer], :int
+
+  # (Not documented)
+  #
+  # @method find_function(ee, name, out_fn)
+  # @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)]
+  # @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)]
+  # @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]
+  # @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)]
+  # @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