ruby-llvm 2.9.1 → 2.9.3

data/lib/llvm/core/context.rb

@@ -1,27 +1,19 @@
 module LLVM  
   class Context
-    private_class_method :new
-
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
+    def initialize
+      @ptr = C.LLVMContextCreate()
     end
-    
+
     # @private
     def to_ptr
       @ptr
     end
-    
-    # Creates a new Context.
-    def self.create
-      new(C.LLVMContextCreate())
-    end
-    
+
     # Obtains a reference to the global Context.
     def self.global
       new(C.LLVMGetGlobalContext())
     end
-    
+
     # Diposes the Context.
     def dispose
       C.LLVMContextDispose(@ptr)

data/lib/llvm/core/module.rb

@@ -1,15 +1,15 @@
 module LLVM  
   class Module
-    private_class_method :new
-    
     # @private
     def self.from_ptr(ptr)
-      ptr.null? ? nil : new(ptr)
+      return if ptr.null?
+      mod = allocate
+      mod.instance_variable_set(:@ptr, ptr)
+      mod
     end
     
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
+    def initialize(name)
+      @ptr = C.LLVMModuleCreateWithName(name)
     end
     
     # @private
@@ -32,11 +32,6 @@ module LLVM
       other.instance_of?(self.class) && self == other
     end
 
-    # Creates a module with the given name.
-    def self.create(name)
-      new(C.LLVMModuleCreateWithName(name))
-    end
-    
     # Returns a TypeCollection of all the Types in the module.
     def types
       @types ||= TypeCollection.new(self)

data/lib/llvm/core/pass_manager.rb

@@ -8,6 +8,8 @@ module LLVM
       C.LLVMAddTargetData(
         C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
       @ptr = ptr
+
+      do_initialization
     end
     
     # @private
@@ -15,26 +17,34 @@ module LLVM
       @ptr
     end
     
+    # Append a pass to the pass queue.
+    # @param [Symbol]
+    # @return [LLVM::PassManager]
     def <<(name)
       send(:"#{name}!")
       self
     end
 
-    def do_initialization
-    end
-
-    def do_finalization
-    end
-
-    # Runs the passes on the given module.
+    # Run the pass queue on the given module.
+    # @param [LLVM::Module]
+    # @return [true, false] Indicates whether the module was modified.
     def run(mod)
-      C.LLVMRunPassManager(self, mod)
+      C.LLVMRunPassManager(self, mod) != 0
     end
     
     # Disposes the pass manager.
     def dispose
+      do_finalization
       C.LLVMDisposePassManager(self)
     end
+
+    protected
+
+    def do_initialization
+    end
+
+    def do_finalization
+    end
   end
 
   class FunctionPassManager < PassManager
@@ -46,6 +56,15 @@ module LLVM
       @ptr = ptr
     end
 
+    # Run the pass queue on the given function.
+    # @param [LLVM::Function]
+    # @return [true, false] indicates whether the function was modified.
+    def run(fn)
+      C.LLVMRunFunctionPassManager(self, fn) != 0
+    end
+
+    protected
+
     def do_initialization
       C.LLVMInitializeFunctionPassManager(self) != 0
     end
@@ -53,10 +72,5 @@ module LLVM
     def do_finalization
       C.LLVMFinalizeFunctionPassManager(self) != 0
     end
-
-    # Runs the passes on the given function.
-    def run(fn)
-      C.LLVMRunFunctionPassManager(self, fn)
-    end
   end
 end

data/lib/llvm/core/type.rb

@@ -1,12 +1,5 @@
 module LLVM  
   class Type
-    private_class_method :new
-    
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
-    end
-    
     # @private
     def to_ptr
       @ptr
@@ -34,11 +27,11 @@ module LLVM
 
     # Returns the size of the type.
     def size
-      Int64.from_ptr(C.LLVMSizeOf(self))
+      LLVM::Int64.from_ptr(C.LLVMSizeOf(self))
     end
     
     def align
-      Int64.from_ptr(C.LLVMAlignOf(self))
+      LLVM::Int64.from_ptr(C.LLVMAlignOf(self))
     end
 
     # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
@@ -64,8 +57,12 @@ module LLVM
       Type.pointer(self, address_space)
     end
     
+    # @private
     def self.from_ptr(ptr)
-      ptr.null? ? nil : new(ptr)
+      return if ptr.null?
+      ty = allocate
+      ty.instance_variable_set(:@ptr, ptr)
+      ty
     end
     
     # Creates an array type of Type with the given size.
@@ -89,7 +86,7 @@ module LLVM
       arg_types.map! { |ty| LLVM::Type(ty) }
       arg_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * arg_types.size)
       arg_types_ptr.write_array_of_pointer(arg_types)
-      from_ptr(C.LLVMFunctionType(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0))
+      FunctionType.from_ptr(C.LLVMFunctionType(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0))
     end
     
     # Creates a struct type with the given array of element types.
@@ -121,9 +118,23 @@ module LLVM
       C.LLVMRefineType(self, ty)
     end
   end
+
+  class IntType < Type
+    def width
+      C.LLVMGetIntTypeWidth(self)
+    end
+  end
+
+  class FunctionType < Type
+    def return_type
+      LLVM::Type.from_ptr(C.LLVMGetReturnType(self))
+    end
+  end
+
+  module_function
   
   # Creates a Type from the given object.
-  def LLVM.Type(ty)
+  def Type(ty)
     case ty
     when LLVM::Type then ty
     else ty.type
@@ -131,32 +142,32 @@ module LLVM
   end
   
   # Shortcut to Type.array.
-  def LLVM.Array(ty, sz = 0)
+  def Array(ty, sz = 0)
     LLVM::Type.array(ty, sz)
   end
   
   # Shortcut to Type.pointer.
-  def LLVM.Pointer(ty)
+  def Pointer(ty)
     LLVM::Type.pointer(ty)
   end
   
   # Shortcut to Type.vector.
-  def LLVM.Vector(ty, sz)
+  def Vector(ty, sz)
     LLVM::Type.vector(ty, sz)
   end
   
   # Shortcut to Type.function.
-  def LLVM.Function(argtypes, rettype, options = {})
+  def Function(argtypes, rettype, options = {})
     LLVM::Type.function(argtypes, rettype, options)
   end
   
   # Shortcut to Type.struct.
-  def LLVM.Struct(*elt_types)
+  def Struct(*elt_types)
     LLVM::Type.struct(elt_types, false)
   end
 
   # Shortcut to Type.void.
-  def LLVM.Void
+  def Void
     LLVM::Type.void
   end
 end

data/lib/llvm/core/value.rb

@@ -2,14 +2,10 @@ module LLVM
   class Value
     # @private
     def self.from_ptr(ptr)
-      new(ptr) unless ptr.null?
-    end
-
-    private_class_method :new
-
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
+      return if ptr.null?
+      val = allocate
+      val.instance_variable_set(:@ptr, ptr)
+      val
     end
 
     # @private
@@ -26,6 +22,10 @@ module LLVM
         false
       end
     end
+    
+    def hash
+      @ptr.address.hash
+    end
 
     # Checks if the value is equal to other.
     def eql?(other)
@@ -104,7 +104,7 @@ module LLVM
     # Build the basic block with the given builder. Creates a new one if nil. Yields the builder.
     def build(builder = nil)
       if builder.nil?
-        builder = Builder.create
+        builder = Builder.new
         islocal = true
       else
         islocal = false
@@ -401,7 +401,7 @@ module LLVM
       eval <<-KLASS
         class #{name} < ConstantInt
           def self.type
-            Type.from_ptr(C.LLVMIntType(#{width}))
+            IntType.from_ptr(C.LLVMIntType(#{width}))
           end
         end
       KLASS
@@ -412,7 +412,8 @@ module LLVM
   end
 
   # Native integer type
-  ::LLVM::Int = const_get("Int#{NATIVE_INT_SIZE}")
+  bits = FFI.type_size(:int) * 8
+  ::LLVM::Int = const_get("Int#{bits}")
 
   # Creates a LLVM Int (subclass of ConstantInt) at the NATIVE_INT_SIZE from a integer (val).
   def LLVM.Int(val)
@@ -421,6 +422,10 @@ module LLVM
     when Integer then Int.from_i(val)
     end
   end
+  
+  # Boolean values
+  ::LLVM::TRUE = ::LLVM::Int1.from_i(-1)
+  ::LLVM::FALSE = ::LLVM::Int1.from_i(0)
 
   class ConstantReal < Constant
     # Creates a ConstantReal from a float of Type.
@@ -598,6 +603,10 @@ module LLVM
       @basic_block_collection ||= BasicBlockCollection.new(self)
     end
 
+    def type
+      FunctionType.from_ptr(C.LLVMTypeOf(self))
+    end
+
     # @private
     class BasicBlockCollection
       include Enumerable
@@ -661,6 +670,9 @@ module LLVM
 
       # Returns a Value representation of the parameter at the given index.
       def [](i)
+        sz = self.size
+        i = sz + i if i < 0
+        return unless 0 <= i && i < sz
         Value.from_ptr(C.LLVMGetParam(@fun, i))
       end
 
@@ -737,26 +749,21 @@ module LLVM
     end
   end
 
+  # @private
   class Phi < Instruction
     # Add incoming branches to a phi node by passing an alternating list of
     # resulting values and BasicBlocks. e.g.
     #   phi.add_incoming(val1, block1, val2, block2, ...)
-    def add_incoming(*incoming)
-      vals, blocks = [], []
-      incoming.each_with_index do |node, i|
-        (i % 2 == 0 ? vals : blocks) << node
-      end
-
-      unless vals.size == blocks.size
-        raise ArgumentError, "Expected vals.size and blocks.size to match"
-      end
+    def add_incoming(incoming)
+      blks = incoming.keys
+      vals = incoming.values_at(*blks)
+      size = incoming.size
 
-      size = vals.size
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |vals_ptr|
         vals_ptr.write_array_of_pointer(vals)
-        FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |blocks_ptr|
-          blocks_ptr.write_array_of_pointer(blocks)
-          C.LLVMAddIncoming(self, vals_ptr, blocks_ptr, vals.size)
+        FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |blks_ptr|
+          blks_ptr.write_array_of_pointer(blks)
+          C.LLVMAddIncoming(self, vals_ptr, blks_ptr, vals.size)
         end
       end
 
@@ -764,6 +771,7 @@ module LLVM
     end
   end
 
+  # @private
   class SwitchInst < Instruction
     # Adds a case to a switch instruction. First the value to match on, then
     # the basic block.

data/lib/llvm/core.rb

@@ -594,4 +594,5 @@ module LLVM
   require 'llvm/core/value'
   require 'llvm/core/builder'
   require 'llvm/core/pass_manager'
+  require 'llvm/core/bitcode'
 end

data/lib/llvm/execution_engine.rb

@@ -52,21 +52,8 @@ module LLVM
     LLVM::C.LLVMInitializeX86TargetInfo
   end
 
-  class ExecutionEngine
-    private_class_method :new
-
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
-    end
-
-    # @private
-    def to_ptr
-      @ptr
-    end
-
-    # Create a JIT compiler with an LLVM::Module.
-    def self.create_jit_compiler(mod, opt_level = 3)
+  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)
@@ -74,7 +61,7 @@ module LLVM
         message = errorp.read_string unless errorp.null?
 
         if status.zero?
-          return new(ptr.read_pointer)
+          @ptr = ptr.read_pointer
         else
           C.LLVMDisposeMessage(error)
           error.autorelease=false
@@ -83,11 +70,18 @@ module LLVM
       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(args.map { |arg| LLVM.GenericValue(arg).to_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
@@ -100,28 +94,34 @@ module LLVM
   end
 
   class GenericValue
-    private_class_method :new
-
-    # @private
-    def initialize(ptr)
-      @ptr = ptr
-    end
-
     # @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, type = LLVM::Int, signed = true)
-      new(C.LLVMCreateGenericValueOfInt(type, i, signed ? 1 : 0))
+    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)
-      type = LLVM::Float.type
-      new(C.LLVMCreateGenericValueOfFloat(type, 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.
@@ -129,9 +129,9 @@ module LLVM
       from_i(b ? 1 : 0, LLVM::Int1, false)
     end
 
-    # Creates a GenericValue from an FFI::Pointer.
-    def self.from_ptr(ptr)
-      new(ptr)
+    # 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.
@@ -148,17 +148,22 @@ module LLVM
     def to_b
       to_i(false) != 0
     end
+    
+    def to_value_ptr
+      C.LLVMGenericValueToPointer(self)
+    end
   end
 
-  # Creates a GenericValue from an object (GenericValue, Integer, Float, true,
-  # false).
-  def LLVM.GenericValue(val)
-    case val
-    when GenericValue then val
-    when ::Integer then GenericValue.from_i(val)
-    when ::Float then GenericValue.from_f(val)
-    when ::TrueClass then GenericValue.from_b(true)
-    when ::FalseClass then GenericValue.from_b(false)
+  # @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/transforms/ipo.rb

@@ -6,6 +6,7 @@ module LLVM
   # @private
   module C
     attach_function :LLVMAddGlobalDCEPass, [:pointer], :void
+    attach_function :LLVMAddFunctionInliningPass, [:pointer], :void
   end
 
   class PassManager
@@ -13,5 +14,10 @@ module LLVM
     def gdce!
       C.LLVMAddGlobalDCEPass(self)
     end
+    
+    # @LLVMpass inline
+    def inline!
+      C.LLVMAddFunctionInliningPass(self)
+    end
   end
 end

data/lib/llvm/version.rb

@@ -0,0 +1,4 @@
+module LLVM
+  LLVM_VERSION = "2.9"
+  RUBY_LLVM_VERSION = "2.9.3"
+end

data/lib/llvm.rb

@@ -1,18 +1,12 @@
 require 'rubygems'
 require 'ffi'
 
+require 'llvm/support'
+
 module LLVM
   # @private
   module C
     extend ::FFI::Library
-
-    # load required libraries
-    ffi_lib ['LLVM-2.9', 'libLLVM-2.9']
-  end
-  
-  NATIVE_INT_SIZE = case FFI::Platform::ARCH
-    when "x86_64" then 64
-    # PPC, other arches?
-    else 32
+    ffi_lib ['LLVM-2.9']
   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