ruby-llvm 3.4.1 → 3.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7fbf551060132cd96ad86b5c4954c20a77071b0e
-  data.tar.gz: e37b6914665099358af491974f0fab85581d4438
+  metadata.gz: b4c3ca01e2020b5ce26bdf7db68f78f33d4fefbe
+  data.tar.gz: 4580027aed01abdc1c9055dfd4d3736f1fae4606
 SHA512:
-  metadata.gz: ecbe7f6377c0cf7373ae91b32c6fb5210d19a503d1d3379b8212bd09262a3e4cfc0e2d74bbb73b27d35b084ae02ad240ca19b153700f2a1219e762605b1d6593
-  data.tar.gz: 2a3918df0a19ebc8cb7f72914d752941f459efb0cc8cef89b4ace55f09276ab30c832c3f93026ff40dfb10a9a1818828d02dd0f776f25fc28447eb8fde3481eb
+  metadata.gz: b111187af62e59fd09acd472f241f0e64913832f956f99cf2fb3faf16806f7b61957840f4fe0246181a41521c9180d0b18420356915077635fa5a9690853b81e
+  data.tar.gz: 108a673c529d5b7621c7206f169b8704473cc518fafed2e10880f2f96fbe58537e8b2f47cab56b5ac0dabf3c2ef7affa9a0166c0e2cf1511a1ba98b5f6ed824e

data/ext/ruby-llvm-support/Rakefile

@@ -32,8 +32,11 @@ def find_llvm_config
 
     begin
       actual_version = `#{llvm_config} --version`.strip
+      actual_maj, actual_min, _ = actual_version.split('.')
 
-      actual_version == LLVM_VERSION
+      required_maj, required_min = LLVM_VERSION.split('.')
+
+      actual_maj == required_maj && actual_min == required_min
     rescue Errno::ENOENT
       false
     end
@@ -41,8 +44,8 @@ def find_llvm_config
 end
 
 def find_cxx
-  check_for('C++ compiler', %W(clang++ g++), 'CXX') do |cxx|
-    system(cxx, "--version")
+  check_for('C++ compiler', %W(g++ clang++), 'CXX') do |cxx|
+    system(cxx, "--version", out: File::NULL, err: File::NULL)
     $?.success?
   end
 end
@@ -63,7 +66,7 @@ desc "Build the shared library and config module"
 task :default => [SUPPORT_LIB, CONFIG_MOD]
 
 file SUPPORT_LIB => %w(support.cpp) do |task|
-  sh "#{CXX} -shared -lLLVM-#{LLVM_VERSION} #{task.prerequisites.join(' ')} " \
+  sh "#{CXX} -shared #{task.prerequisites.join(' ')} -lLLVM-#{LLVM_VERSION} " \
      "#{invoke_llvm_config('--cxxflags --ldflags')} -o #{SUPPORT_LIB}"
 end
 

data/ext/ruby-llvm-support/support.cpp

@@ -3,20 +3,12 @@
  */
 
 #include <llvm-c/Core.h>
-#include <llvm/IR/Type.h>
-#include <llvm/IR/Module.h>
 #include <llvm/IR/GlobalValue.h>
-#include <llvm/Support/DynamicLibrary.h>
 #include <llvm/Support/TargetSelect.h>
-#include <llvm/Support/raw_ostream.h>
 
 extern "C" {
   using namespace llvm;
 
-  int LLVMLoadLibraryPermanently(const char* filename) {
-    return llvm::sys::DynamicLibrary::LoadLibraryPermanently(filename);
-  }
-
   LLVMBool LLVMHasUnnamedAddr(LLVMValueRef global) {
     return unwrap<GlobalValue>(global)->hasUnnamedAddr();
   }

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?
 
@@ -69,6 +76,158 @@ module LLVM
     def pointer_to_global(global)
       C.get_pointer_to_global(self, global)
     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 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.
+    #
+    # @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, # LLVMCodeModelDefault
+        :no_frame_pointer_elim => false,
+        :enable_fast_i_sel     => false,
+        # TODO
+        #:mcjmm                 => nil,
+      }.merge(options)
+
+      super
+    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
 
   class GenericValue

data/lib/llvm/support.rb

@@ -1,4 +1,5 @@
 require 'llvm/core_ffi'
+require 'llvm/support_ffi'
 
 module LLVM
 
@@ -16,7 +17,6 @@ module LLVM
       lib_path = File.expand_path("../../ext/ruby-llvm-support/#{lib_name}", File.dirname(__FILE__))
       ffi_lib [lib_path]
 
-      attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
       attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [OpaqueValue], :int
       attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [OpaqueValue, :int], :void
 
@@ -36,11 +36,11 @@ module LLVM
     end
   end
 
-  def load_library(libname)
-    Support::C.load_library_permanently(libname)
+  def self.load_library(libname)
+    if C.load_library_permanently(libname) != 0
+      raise "LLVM::Support.load_library failed"
+    end
 
     nil
   end
-
-  module_function :load_library
 end

data/lib/llvm/support_ffi.rb

@@ -0,0 +1,23 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  ffi_lib 'LLVM-3.4'
+  
+  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 load_library_permanently(filename)
+  # @param [String] filename 
+  # @return [Integer] 
+  # @scope class
+  attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
+  
+end

data/lib/llvm/target.rb

@@ -4,8 +4,8 @@ require 'llvm/target_ffi'
 
 module LLVM
   # A shorthand for {LLVM::Target.init_native}
-  def self.init_jit
-    LLVM::Target.init_native
+  def self.init_jit(*args)
+    LLVM::Target.init_native(*args)
   end
 
   # @deprecated Use LLVM.init_jit or LLVM::Target.init('X86').

data/lib/llvm/version.rb

@@ -1,4 +1,4 @@
 module LLVM
   LLVM_VERSION = "3.4"
-  RUBY_LLVM_VERSION = "3.4.1"
+  RUBY_LLVM_VERSION = "3.4.2"
 end

data/test/mcjit_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class MCJITTestCase < Minitest::Test
+  def setup
+    LLVM.init_jit(true)
+  end
+
+  def create_square_function_module
+    LLVM::Module.new('square').tap do |mod|
+      mod.functions.add(:square, [LLVM::Int], LLVM::Int) do |fun, x|
+        fun.basic_blocks.append.build do |builder|
+          n = builder.mul(x, x)
+          builder.ret(n)
+        end
+      end
+
+      mod.verify!
+    end
+  end
+
+  def test_simple_function
+    mod = create_square_function_module
+
+    engine = LLVM::MCJITCompiler.new(mod, :opt_level => 0)
+
+    result = engine.run_function(mod.functions['square'], 5)
+    assert_equal 25, result.to_i
+  end
+
+  def test_functions_named
+    mod = LLVM::Module.new('foo').tap do |mod|
+      mod.functions.add(:foo, [], LLVM::Int)
+      mod.verify!
+    end
+
+    engine = LLVM::MCJITCompiler.new(mod, :opt_level => 0)
+
+    ['foo', :foo].each do |name|
+      engine.functions[name].tap do |fun|
+        assert fun, "function named #{name.inspect}"
+        assert_equal 'foo', fun.name
+      end
+    end
+  end
+
+  def test_add_module
+    main_mod = LLVM::Module.new('main')
+
+    main_mod.functions.add(:square, [LLVM::Int], LLVM::Int) do |square|
+      main_mod.functions.add(:call_square, [], LLVM::Int) do |call_square|
+        call_square.basic_blocks.append.build do |builder|
+          n = builder.call(square, LLVM::Int(5))
+          builder.ret(n)
+        end
+      end
+    end
+
+    main_mod.verify!
+
+    engine = LLVM::MCJITCompiler.new(main_mod, :opt_level => 0)
+    engine.modules << create_square_function_module
+
+    result = engine.run_function(main_mod.functions['call_square'])
+    assert_equal 25, result.to_i
+  end
+
+  def test_remove_module
+    mod1 = LLVM::Module.new('foo')
+    mod2 = LLVM::Module.new('bar')
+
+    foo = mod1.functions.add(:foo, [], LLVM::Int)
+    bar = mod2.functions.add(:bar, [], LLVM::Int)
+
+    engine = LLVM::MCJITCompiler.new(mod1, :opt_level => 0)
+
+    (engine.modules << mod2).tap do |ret|
+      assert_equal engine.modules, ret, '#<< returns self'
+    end
+
+    assert engine.functions[:bar]
+    engine.modules.delete(mod2).tap do |ret|
+      assert_instance_of LLVM::Module, ret, '#delete returns module'
+      assert_equal mod2, ret
+    end
+    assert_nil engine.functions[:bar]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-llvm
 version: !ruby/object:Gem::Version
-  version: 3.4.1
+  version: 3.4.2
 platform: ruby
 authors:
 - Jeremy Voorhis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -127,6 +127,7 @@ files:
 - lib/llvm/linker.rb
 - lib/llvm/linker_ffi.rb
 - lib/llvm/support.rb
+- lib/llvm/support_ffi.rb
 - lib/llvm/target.rb
 - lib/llvm/target_ffi.rb
 - lib/llvm/transforms/builder.rb
@@ -153,6 +154,7 @@ files:
 - test/instruction_test.rb
 - test/ipo_test.rb
 - test/linker_test.rb
+- test/mcjit_test.rb
 - test/memory_access_test.rb
 - test/module_test.rb
 - test/parameter_collection_test.rb
@@ -183,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: LLVM bindings for Ruby
@@ -209,6 +211,7 @@ test_files:
 - test/struct_test.rb
 - test/parameter_collection_test.rb
 - test/call_test.rb
+- test/mcjit_test.rb
 - test/vector_test.rb
 - test/target_test.rb
 - test/array_test.rb