waj-ruby-llvm 2.9.2

data/lib/llvm/execution_engine.rb

@@ -0,0 +1,169 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/target'
+require 'llvm/analysis'
+
+module LLVM
+  # @private
+  module C
+    # Generic values
+    attach_function :LLVMCreateGenericValueOfInt, [:pointer, :long_long, :int], :pointer
+    attach_function :LLVMCreateGenericValueOfPointer, [:pointer], :pointer
+    attach_function :LLVMCreateGenericValueOfFloat, [:pointer, :double], :pointer
+
+    attach_function :LLVMGenericValueIntWidth, [:pointer], :uint
+
+    attach_function :LLVMGenericValueToInt, [:pointer, :int], :long_long
+    attach_function :LLVMGenericValueToPointer, [:pointer], :pointer
+    attach_function :LLVMGenericValueToFloat, [:pointer, :pointer], :double
+    attach_function :LLVMDisposeGenericValue, [:pointer], :void
+
+    # Execution engines
+    attach_function :LLVMCreateExecutionEngineForModule, [:pointer, :pointer, :pointer], :int
+    attach_function :LLVMCreateInterpreterForModule, [:pointer, :pointer, :pointer], :int
+    attach_function :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
+    attach_function :LLVMDisposeExecutionEngine, [:pointer], :void
+
+    attach_function :LLVMRunStaticConstructors, [:pointer], :void
+    attach_function :LLVMRunStaticDestructors, [:pointer], :void
+
+    attach_function :LLVMRunFunctionAsMain, [:pointer, :pointer, :uint, :pointer, :pointer], :int
+    attach_function :LLVMRunFunction, [:pointer, :pointer, :uint, :pointer], :pointer
+
+    attach_function :LLVMFreeMachineCodeForFunction, [:pointer, :pointer], :void
+    attach_function :LLVMAddModuleProvider, [:pointer, :pointer], :void
+    attach_function :LLVMRemoveModuleProvider, [:pointer, :pointer, :pointer, :pointer], :int
+
+    attach_function :LLVMFindFunction, [:pointer, :pointer, :pointer, :pointer], :int
+
+    attach_function :LLVMGetExecutionEngineTargetData, [:pointer], :pointer
+
+    attach_function :LLVMAddGlobalMapping, [:pointer, :pointer, :pointer], :void
+
+    attach_function :LLVMGetPointerToGlobal, [:pointer, :pointer], :pointer
+
+    attach_function :LLVMInitializeX86TargetInfo, [], :void
+
+    attach_function :LLVMInitializeX86Target, [], :void
+  end
+
+  def LLVM.init_x86
+    LLVM::C.LLVMInitializeX86Target
+    LLVM::C.LLVMInitializeX86TargetInfo
+  end
+
+  class JITCompiler
+    def initialize(mod, opt_level = 3)
+      FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |ptr|
+        error   = FFI::MemoryPointer.new(FFI.type_size(:pointer))
+        status  = C.LLVMCreateJITCompilerForModule(ptr, mod, opt_level, error)
+        errorp  = error.read_pointer
+        message = errorp.read_string unless errorp.null?
+
+        if status.zero?
+          @ptr = ptr.read_pointer
+        else
+          C.LLVMDisposeMessage(error)
+          error.autorelease=false
+          raise RuntimeError, "Error creating JIT compiler: #{message}"
+        end
+      end
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Execute the given LLVM::Function with the supplied args (as
+    # GenericValues).
+    def run_function(fun, *args)
+      FFI::MemoryPointer.new(FFI.type_size(:pointer) * args.size) do |args_ptr|
+        args_ptr.write_array_of_pointer fun.params.zip(args).map { |p, a|
+          a.kind_of?(GenericValue) ? a : LLVM.make_generic_value(p.type, a)
+        }
+        return LLVM::GenericValue.from_ptr(
+          C.LLVMRunFunction(self, fun, args.size, args_ptr))
+      end
+    end
+
+    # Obtain an FFI::Pointer to a global within the current module.
+    def pointer_to_global(global)
+      C.LLVMGetPointerToGlobal(self, global)
+    end
+  end
+
+  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
+
+    # Creates a Generic Value from an integer. Type is the size of integer to
+    # create (ex. Int32, Int8, etc.)
+    def self.from_i(i, options = {})
+      type   = options.fetch(:type, LLVM::Int)
+      signed = options.fetch(:signed, true)
+      from_ptr(C.LLVMCreateGenericValueOfInt(type, i, signed ? 1 : 0))
+    end
+
+    # Creates a Generic Value from a Float.
+    def self.from_f(f)
+      from_ptr(C.LLVMCreateGenericValueOfFloat(LLVM::Float, f))
+    end
+
+    def self.from_d(val)
+      from_ptr(C.LLVMCreateGenericValueOfFloat(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.LLVMCreateGenericValueOfPointer(ptr))
+    end
+
+    # Converts a GenericValue to a Ruby Integer.
+    def to_i(signed = true)
+      C.LLVMGenericValueToInt(self, signed ? 1 : 0)
+    end
+
+    # Converts a GenericValue to a Ruby Float.
+    def to_f(type = LLVM::Float.type)
+      C.LLVMGenericValueToFloat(type, self)
+    end
+    
+    # Converts a GenericValue to a Ruby boolean.
+    def to_b
+      to_i(false) != 0
+    end
+    
+    def to_value_ptr
+      C.LLVMGenericValueToPointer(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/support.rb

@@ -0,0 +1,22 @@
+module LLVM
+  module Support
+    # @private
+    module C
+      extend FFI::Library
+      support_lib = File.expand_path(
+                      File.join(
+                        File.dirname(__FILE__),
+                        '../',
+                        FFI.map_library_name('RubyLLVMSupport-2.9.2')))
+      ffi_lib [support_lib]
+      attach_function :LLVMLoadLibraryPermanently, [:string], :int
+    end
+  end
+
+  def load_library(libname)
+    Support::C.LLVMLoadLibraryPermanently(libname)
+    nil
+  end
+
+  module_function :load_library
+end

data/lib/llvm/target.rb

@@ -0,0 +1,9 @@
+require 'llvm'
+require 'llvm/core'
+
+module LLVM
+  # @private
+  module C
+    attach_function :LLVMAddTargetData, [:pointer, :pointer], :void
+  end
+end

data/lib/llvm/transforms/ipo.rb

@@ -0,0 +1,23 @@
+# Interprocedural optimization (IPO)
+require 'llvm'
+require 'llvm/core'
+
+module LLVM
+  # @private
+  module C
+    attach_function :LLVMAddGlobalDCEPass, [:pointer], :void
+    attach_function :LLVMAddFunctionInliningPass, [:pointer], :void
+  end
+
+  class PassManager
+    # @LLVMpass gdce
+    def gdce!
+      C.LLVMAddGlobalDCEPass(self)
+    end
+    
+    # @LLVMpass inline
+    def inline!
+      C.LLVMAddFunctionInliningPass(self)
+    end
+  end
+end

data/lib/llvm/transforms/scalar.rb

@@ -0,0 +1,136 @@
+require 'llvm'
+require 'llvm/core'
+
+module LLVM
+  # @private
+  module C
+    attach_function :LLVMAddAggressiveDCEPass, [:pointer], :void
+    attach_function :LLVMAddCFGSimplificationPass, [:pointer], :void
+    attach_function :LLVMAddDeadStoreEliminationPass, [:pointer], :void
+    attach_function :LLVMAddGVNPass, [:pointer], :void
+    attach_function :LLVMAddIndVarSimplifyPass, [:pointer], :void
+    attach_function :LLVMAddInstructionCombiningPass, [:pointer], :void
+    attach_function :LLVMAddJumpThreadingPass, [:pointer], :void
+    attach_function :LLVMAddLICMPass, [:pointer], :void
+    attach_function :LLVMAddLoopDeletionPass, [:pointer], :void
+    attach_function :LLVMAddLoopRotatePass, [:pointer], :void
+    attach_function :LLVMAddLoopUnrollPass, [:pointer], :void
+    attach_function :LLVMAddLoopUnswitchPass, [:pointer], :void
+    attach_function :LLVMAddMemCpyOptPass, [:pointer], :void
+    attach_function :LLVMAddPromoteMemoryToRegisterPass, [:pointer], :void
+    attach_function :LLVMAddReassociatePass, [:pointer], :void
+    attach_function :LLVMAddSCCPPass, [:pointer], :void
+    attach_function :LLVMAddScalarReplAggregatesPass, [:pointer], :void
+    attach_function :LLVMAddSimplifyLibCallsPass, [:pointer], :void
+    attach_function :LLVMAddTailCallEliminationPass, [:pointer], :void
+    attach_function :LLVMAddConstantPropagationPass, [:pointer], :void
+    attach_function :LLVMAddDemoteMemoryToRegisterPass, [:pointer], :void
+  end
+  
+  class PassManager
+    # @LLVMpass adce
+    def adce!
+      C.LLVMAddAggressiveDCEPass(self)
+    end
+    
+    # @LLVMpass simplifycfg
+    def simplifycfg!
+      C.LLVMAddCFGSimplificationPass(self)
+    end
+    
+    # @LLVMpass dse
+    def dse!
+      C.LLVMAddDeadStoreEliminationPass(self)
+    end
+    
+    # @LLVMpass gvn
+    def gvn!
+      C.LLVMAddGVNPass(self)
+    end
+    
+    # @LLVMpass indvars
+    def indvars!
+      C.LLVMAddIndVarSimplifyPass(self)
+    end
+    
+    # @LLVMpass instcombine
+    def instcombine!
+      C.LLVMAddInstructionCombiningPass(self)
+    end
+    
+    # @LLVMpass jump-threading
+    def jump_threading!
+      C.LLVMAddJumpThreadingPass(self)
+    end
+    
+    # @LLVMpass licm
+    def licm!
+      C.LLVMAddLICMPass(self)
+    end
+    
+    # @LLVMpass loop-deletion
+    def loop_deletion!
+      C.LLVMAddLoopDeletionPass(self)
+    end
+    
+    # @LLVMpass loop-rotate
+    def loop_rotate!
+      C.LLVMAddLoopRotatePass(self)
+    end
+    
+    # @LLVMpass loop-unroll
+    def loop_unroll!
+      C.LLVMAddLoopUnrollPass(self)
+    end
+    
+    # @LLVMpass loop-unswitch
+    def loop_unswitch!
+      C.LLVMAddLoopUnswitchPass(self)
+    end
+    
+    # @LLVMpass memcpyopt
+    def memcpyopt!
+      C.LLVMAddMemCpyOptPass(self)
+    end
+    
+    # @LLVMpass mem2reg
+    def mem2reg!
+      C.LLVMAddPromoteMemoryToRegisterPass(self)
+    end
+    
+    # @LLVMpass reassociate
+    def reassociate!
+      C.LLVMAddReassociatePass(self)
+    end
+    
+    # @LLVMpass sccp
+    def sccp!
+      C.LLVMAddSCCPPass(self)
+    end
+    
+    # @LLVMpass scalarrepl
+    def scalarrepl!
+      C.LLVMAddScalarReplAggregatesPass(self)
+    end
+    
+    # @LLVMpass simplify-libcalls
+    def simplify_libcalls!
+      C.LLVMAddSimplifyLibCallsPass(self)
+    end
+    
+    # @LLVMpass tailcallelim
+    def tailcallelim!
+      C.LLVMAddTailCallEliminationPass(self)
+    end
+    
+    # @LLVMpass constprop
+    def constprop!
+      C.LLVMAddConstantPropagationPass(self)
+    end
+    
+    # @LLVMpass reg2mem
+    def reg2mem!
+      C.LLVMAddDemoteMemoryToRegisterPass(self)
+    end
+  end
+end

data/test/array_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class ArrayTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_constant_array_from_size
+    array = LLVM::ConstantArray.const(LLVM::Int, 2) { |i| LLVM::Int(i) }
+    assert_instance_of LLVM::ConstantArray, array
+    assert_equal 2, array.operands.size
+  end
+
+  def test_constant_array_from_array
+    array = LLVM::ConstantArray.const(LLVM::Int, [LLVM::Int(0), LLVM::Int(1)])
+    assert_instance_of LLVM::ConstantArray, array
+    assert_equal 2, array.operands.size
+  end
+
+  def test_array_values
+    assert_equal 2 + 3, run_array_values(2, 3).to_i
+  end
+
+  def run_array_values(value1, value2)
+    run_function([LLVM::Int, LLVM::Int], [value1, value2], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer = builder.alloca(LLVM::Array(LLVM::Int, 2))
+      array = builder.load(pointer)
+      array = builder.insert_value(array, arguments.first, 0)
+      array = builder.insert_value(array, arguments.last, 1)
+      builder.ret(builder.add(builder.extract_value(array, 0),
+                              builder.extract_value(array, 1)))
+    end
+  end
+
+end

data/test/basic_block_test.rb

@@ -0,0 +1,88 @@
+require "test_helper"
+
+class BasicBlockTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+    @module = LLVM::Module.new("BasicBlockTestCase")
+  end
+
+  def test_basic_block_collection
+    @module.functions.add("test_basic_block_collection", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      assert_instance_of LLVM::BasicBlock, block1
+
+      assert_equal 1, coll.size
+      assert_equal coll.first, coll.last,
+                   'Only one block exists in the function'
+      assert_equal coll.first, coll.entry,
+                   'The entry block for the function is always the first block'
+
+      block2 = coll.append
+      assert_equal 2, coll.size
+      assert_equal block1, coll.first
+      assert_equal block2, coll.last
+
+      [ coll.each.to_a, coll.to_a ].each do |blocks|
+        assert_equal 2, blocks.size
+        assert_equal block1, blocks[0]
+        assert_equal block2, blocks[1]
+      end
+    end
+  end
+
+  def test_basic_block
+    @module.functions.add("test_basic_block", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      block2 = coll.append
+
+      assert_equal fn, block1.parent
+      assert_equal fn, block2.parent
+
+      assert_equal block2, block1.next
+      assert_equal block1, block2.previous
+
+      block1.build do |builder|
+        builder.br(block2)
+      end
+
+      block2.build do |builder|
+        builder.ret_void
+      end
+
+      assert_equal block1.first_instruction,
+                   block1.last_instruction
+      assert_equal block2.first_instruction,
+                   block2.last_instruction
+    end
+  end
+
+  def test_basic_block_enumerable
+    @module.functions.add("test_basic_block_enumerable", [LLVM::Double], LLVM::Double) do |fn, arg|
+      block1 = fn.basic_blocks.append
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 0, insts.size, 'Empty basic block'
+      end
+
+      block1.build do |builder|
+        builder.ret(builder.fadd(arg, LLVM.Double(1.0)))
+      end
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 2, insts.size
+        assert_equal block1.first_instruction, insts[0]  # deprecated
+        assert_equal block1.last_instruction,  insts[1]  # deprecated
+        assert_equal block1.instructions.first, insts[0]
+        assert_equal block1.instructions.last,  insts[1]
+      end
+
+    end
+  end
+
+end
+