ruby-llvm 2.7.0 → 2.9.0

data/lib/llvm/core/context.rb

@@ -1,9 +1,7 @@
 module LLVM  
   class Context
-    class << self
-      private :new
-    end
-    
+    private_class_method :new
+
     def initialize(ptr) # :nodoc:
       @ptr = ptr
     end

data/lib/llvm/core/module.rb

@@ -1,8 +1,6 @@
 module LLVM  
   class Module
-    class << self
-      private :new
-    end
+    private_class_method :new
     
     def self.from_ptr(ptr)
       ptr.null? ? nil : new(ptr)
@@ -16,6 +14,19 @@ module LLVM
       @ptr
     end
     
+    def ==(other)
+      case other
+      when LLVM::Module
+        @ptr == other.to_ptr
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      other.instance_of?(self.class) && self == other
+    end
+
     def self.create(name)
       new(C.LLVMModuleCreateWithName(name))
     end

data/lib/llvm/core/pass_manager.rb

@@ -1,7 +1,6 @@
 module LLVM
   # The PassManager runs a queue of passes on a module. See
   # http://llvm.org/docs/Passes.html for the list of available passes.
-  # Currently, only scalar transformation passes are supported.
   class PassManager
     def initialize(execution_engine)
       ptr = C.LLVMCreatePassManager()
@@ -18,7 +17,13 @@ module LLVM
       send(:"#{name}!")
       self
     end
-    
+
+    def do_initialization
+    end
+
+    def do_finalization
+    end
+
     def run(mod)
       C.LLVMRunPassManager(self, mod)
     end
@@ -27,4 +32,25 @@ module LLVM
       C.LLVMDisposePassManager(self)
     end
   end
+
+  class FunctionPassManager < PassManager
+    def initialize(execution_engine, mod)
+      ptr = C.LLVMCreateFunctionPassManagerForModule(mod)
+      C.LLVMAddTargetData(
+        C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
+      @ptr = ptr
+    end
+
+    def do_initialization
+      C.LLVMInitializeFunctionPassManager(self) != 0
+    end
+
+    def do_finalization
+      C.LLVMFinalizeFunctionPassManager(self) != 0
+    end
+
+    def run(fn)
+      C.LLVMRunFunctionPassManager(self, fn)
+    end
+  end
 end

data/lib/llvm/core/type.rb

@@ -1,8 +1,6 @@
 module LLVM  
   class Type
-    class << self
-      private :new
-    end
+    private_class_method :new
     
     def initialize(ptr) # :nodoc:
       @ptr = ptr
@@ -22,6 +20,14 @@ module LLVM
       end
     end
 
+    def eql?(other)
+      other.instance_of?(self.class) && self == other
+    end
+
+    def kind
+        C.LLVMGetTypeKind(self)
+    end
+
     def size
       Int64.from_ptr(C.LLVMSizeOf(self))
     end
@@ -29,6 +35,25 @@ module LLVM
     def align
       Int64.from_ptr(C.LLVMAlignOf(self))
     end
+
+    def element_type
+      case self.kind
+      when :pointer, :vector, :array
+        Type.from_ptr(C.LLVMGetElementType(self))
+      end
+    end
+
+    def null_pointer
+      ConstantExpr.from_ptr(C.LLVMConstPointerNull(self))
+    end
+
+    def null
+      ConstantExpr.from_ptr(C.LLVMConstNull(self))
+    end
+
+    def pointer(address_space = 0)
+      Type.pointer(self, address_space)
+    end
     
     def self.from_ptr(ptr)
       ptr.null? ? nil : new(ptr)
@@ -46,11 +71,11 @@ module LLVM
       from_ptr(C.LLVMVectorType(LLVM::Type(ty), element_count))
     end
     
-    def self.function(arg_types, result_type)
+    def self.function(arg_types, result_type, options = {})
       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, 0))
+      from_ptr(C.LLVMFunctionType(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0))
     end
     
     def self.struct(elt_types, is_packed)
@@ -99,8 +124,8 @@ module LLVM
     LLVM::Type.vector(ty, sz)
   end
   
-  def LLVM.Function(argtypes, rettype)
-    LLVM::Type.function(argtypes, rettype)
+  def LLVM.Function(argtypes, rettype, options = {})
+    LLVM::Type.function(argtypes, rettype, options)
   end
   
   def LLVM.Struct(*elt_types)

data/lib/llvm/core/value.rb

@@ -3,74 +3,89 @@ module LLVM
     def self.from_ptr(ptr)
       new(ptr) unless ptr.null?
     end
-    
-    class << self
-      private :new
-    end
-    
+
+    private_class_method :new
+
     def initialize(ptr)
       @ptr = ptr
     end
-    
+
     def to_ptr # :nodoc:
       @ptr
     end
-    
+
+    def ==(other)
+      case other
+      when LLVM::Value
+        @ptr == other.to_ptr
+      else
+        false
+      end
+    end
+
+    def eql?(other)
+      other.instance_of?(self.class) && self == other
+    end
+
     def self.type
-      raise NotImplementedError, "Value.type is abstract"
+      raise NotImplementedError, "#{self.name}.type() is abstract."
     end
-    
+
     def self.to_ptr
       type.to_ptr
     end
-    
+
     def type
       Type.from_ptr(C.LLVMTypeOf(self))
     end
-    
+
     def name
       C.LLVMGetValueName(self)
     end
-    
+
     def name=(str)
       C.LLVMSetValueName(self, str)
       str
     end
-    
+
     def dump
       C.LLVMDumpValue(self)
     end
-    
+
     def constant?
       case C.LLVMIsConstant(self)
       when 0 then false
       when 1 then true
       end
     end
-    
+
     def null?
       case C.LLVMIsNull(self)
       when 0 then false
       when 1 then true
       end
     end
-    
+
     def undefined?
       case C.LLVMIsUndef(self)
       when 0 then false
       when 1 then true
       end
     end
-    
+
     def add_attribute(attr)
       C.LLVMAddAttribute(self, attr)
     end
   end
-  
+
   class Argument < Value
   end
-  
+
   class BasicBlock < Value
+    def self.create(fun = nil, name = "")
+      self.from_ptr(C.LLVMAppendBasicBlock(fun, name))
+    end
+
     def build(builder = nil)
       if builder.nil?
         builder = Builder.create
@@ -81,120 +96,238 @@ module LLVM
       builder.position_at_end(self)
       yield builder
     ensure
-      builder.dispose
+      builder.dispose if islocal
+    end
+
+    def parent
+      fp = C.LLVMGetBasicBlockParent(self)
+      LLVM::Function.from_ptr(fp) unless fp.null?
+    end
+
+    def next
+      ptr = C.LLVMGetNextBasicBlock(self)
+      BasicBlock.from_ptr(ptr) unless ptr.null?
+    end
+
+    def previous
+      ptr = C.LLVMGetPreviousBasicBlock(self)
+      BasicBlock.from_ptr(ptr) unless ptr.null?
+    end
+
+    def first_instruction  # deprecated
+      instructions.first
+    end
+
+    def last_instruction  # deprecated
+      instructions.last
+    end
+
+    def instructions
+      @instructions ||= InstructionCollection.new(self)
+    end
+
+    class InstructionCollection
+      include Enumerable
+
+      def initialize(block)
+        @block = block
+      end
+
+      def each
+        return to_enum :each unless block_given?
+        inst, last = first, last
+
+        while inst
+          yield inst
+          break if inst == last
+          inst = inst.next
+        end
+
+        self
+      end
+
+      def first
+        ptr = C.LLVMGetFirstInstruction(@block)
+        LLVM::Instruction.from_ptr(ptr) unless ptr.null?
+      end
+
+      def last
+        ptr = C.LLVMGetLastInstruction(@block)
+        LLVM::Instruction.from_ptr(ptr) unless ptr.null?
+      end
     end
   end
-  
-  class Constant < Value
-    def self.type
-      raise NotImplementedError, "Constant.type() is abstract."
+
+  class User < Value
+    def operands
+      @operand_collection ||= OperandCollection.new(self)
+    end
+
+    class OperandCollection
+      include Enumerable
+
+      def initialize(user)
+        @user = user
+      end
+
+      def [](i)
+        ptr = C.LLVMGetOperand(@user, i)
+        Value.from_ptr(ptr) unless ptr.null?
+      end
+
+      def []=(i, v)
+        C.LLVMSetOperand(@user, i, v)
+      end
+
+      def size
+        C.LLVMGetNumOperands(@user)
+      end
+
+      def each
+        return to_enum :each unless block_given?
+        0.upto(size-1) { |i| yield self[i] }
+        self
+      end
     end
-    
+  end
+
+  class Constant < User
     def self.null
       from_ptr(C.LLVMConstNull(type))
     end
-    
+
     def self.undef
       from_ptr(C.LLVMGetUndef(type))
     end
-    
+
     def self.null_ptr
       from_ptr(C.LLVMConstPointerNull(type))
     end
+
+    def bitcast_to(type)
+      ConstantExpr.from_ptr(C.LLVMConstBitCast(self, type))
+    end
+
+    def gep(*indices)
+      indices = Array(indices)
+      FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
+        indices_ptr.write_array_of_pointer(indices)
+        return ConstantExpr.from_ptr(
+          C.LLVMConstGEP(self, indices_ptr, indices.size))
+      end
+    end
   end
-  
+
+  module Support
+    def allocate_pointers(size_or_values, &block)
+      if size_or_values.is_a?(Integer)
+        raise ArgumentError, 'block not given' unless block_given?
+        size = size_or_values
+        values = (0...size).map { |i| yield i }
+      else
+        values = size_or_values
+        size = values.size
+      end
+      FFI::MemoryPointer.new(:pointer, size).write_array_of_pointer(values)
+    end
+
+    module_function :allocate_pointers
+  end
+
   class ConstantArray < Constant
     def self.string(str, null_terminate = true)
-      from_ptr(C.LLVMConstString(str, null_terminate ? 0 : 1))
+      from_ptr(C.LLVMConstString(str, str.length, null_terminate ? 0 : 1))
     end
-    
-    def self.const(type, size)
-      vals = (0...size).map { |i| yield i }
-      from_ptr C.LLVMConstArray(type, vals, size)
+
+    # ConstantArray.const(type, 3) {|i| ... } or
+    # ConstantArray.const(type, [...])
+    def self.const(type, size_or_values, &block)
+      vals = LLVM::Support.allocate_pointers(size_or_values, &block)
+      from_ptr C.LLVMConstArray(type, vals, vals.size / vals.type_size)
     end
   end
-  
+
   class ConstantExpr < Constant
   end
-  
+
   class ConstantInt < Constant
     def self.all_ones
       from_ptr(C.LLVMConstAllOnes(type))
     end
-    
+
     def self.from_i(n, signed = true)
       from_ptr(C.LLVMConstInt(type, n, signed ? 1 : 0))
     end
-    
+
     def self.parse(str, radix = 10)
       from_ptr(C.LLVMConstIntOfString(type, str, radix))
     end
-    
+
     def -@
       self.class.from_ptr(C.LLVMConstNeg(self))
     end
-    
+
     def not
       self.class.from_ptr(C.LLVMConstNot(self))
     end
-    
+
     def +(rhs)
       self.class.from_ptr(C.LLVMConstAdd(self, rhs))
     end
-    
+
     def nsw_add(rhs)
       self.class.from_ptr(C.LLVMConstNSWAdd(self, rhs))
     end
-    
+
     def *(rhs)
       self.class.from_ptr(C.LLVMConstMul(self, rhs))
     end
-    
+
     def udiv(rhs)
       self.class.from_ptr(C.LLVMConstUDiv(self, rhs))
     end
-    
+
     def /(rhs)
       self.class.from_ptr(C.LLVMConstSDiv(self, rhs))
     end
-    
+
     def urem(rhs)
       self.class.from_ptr(C.LLVMConstURem(self, rhs))
     end
-    
+
     def rem(rhs)
       self.class.from_ptr(C.LLVMConstSRem(self, rhs))
     end
-    
+
     def and(rhs) # Ruby's && cannot be overloaded
       self.class.from_ptr(C.LLVMConstAnd(self, rhs))
     end
-    
+
     def or(rhs) # Nor is ||.
       self.class.from_ptr(C.LLVMConstOr(self, rhs))
     end
-    
+
     def xor(rhs) # Nor is ||.
       self.class.from_ptr(C.LLVMConstXor(self, rhs))
     end
-    
+
     def icmp(pred, rhs)
       self.class.from_ptr(C.LLVMConstICmp(pred, self, rhs))
     end
-    
+
     def <<(bits)
       self.class.from_ptr(C.LLVMConstShl(self, rhs))
     end
-    
+
     def >>(bits)
       self.class.from_ptr(C.LLVMConstLShr(self, rhs))
     end
-    
+
     def ashr(bits)
       self.class.from_ptr(C.LLVMConstAShr(self, rhs))
     end
   end
-  
+
   def LLVM.const_missing(const) # :nodoc:
     case const.to_s
     when /Int(\d+)/
@@ -212,226 +345,284 @@ module LLVM
       super
     end
   end
-  
+
   # Native integer type
   ::LLVM::Int = const_get("Int#{NATIVE_INT_SIZE}")
-  
+
   def LLVM.Int(val)
     case val
     when LLVM::ConstantInt then val
     when Integer then Int.from_i(val)
     end
   end
-  
+
   class ConstantReal < Constant
     def self.from_f(n)
       from_ptr(C.LLVMConstReal(type, n))
     end
-    
+
     def self.parse(str)
       from_ptr(C.LLVMConstRealOfString(type, str))
     end
-    
+
     def -@
       self.class.from_ptr(C.LLVMConstFNeg(self))
     end
-    
+
     def +(rhs)
       self.class.from_ptr(C.LLVMConstFAdd(self, rhs))
     end
-    
+
     def *(rhs)
       self.class.from_ptr(C.LLVMConstFMul(self, rhs))
     end
-    
+
     def /(rhs)
       self.class.from_ptr(C.LLVMConstFDiv(self, rhs))
     end
-    
+
     def rem(rhs)
       self.class.from_ptr(C.LLVMConstFRem(self, rhs))
     end
-    
+
     def fcmp(pred, rhs)
       self.class.from_ptr(C.LLMVConstFCmp(pred, self, rhs))
     end
   end
-  
+
   class Float < ConstantReal
     def self.type
       Type.from_ptr(C.LLVMFloatType)
     end
   end
-  
+
   def LLVM.Float(val)
     Float.from_f(val)
   end
-  
+
   class Double < ConstantReal
     def self.type
       Type.from_ptr(C.LLVMDoubleType)
     end
   end
-  
+
   def LLVM.Double(val)
     Double.from_f(val)
   end
-  
+
   class ConstantStruct < Constant
-    def self.const(size, packed = false)
-      vals = (0..size).map { |i| yield i }
-      from_ptr(C.LLVMConstStruct(vals, size, packed ? 1 : 0))
+    # ConstantStruct.const(size) {|i| ... } or
+    # ConstantStruct.const([...])
+    def self.const(size_or_values, packed = false, &block)
+      vals = LLVM::Support.allocate_pointers(size_or_values, &block)
+      from_ptr C.LLVMConstStruct(vals, vals.size / vals.type_size, packed ? 1 : 0)
     end
   end
-  
+
   class ConstantVector < Constant
     def self.all_ones
       from_ptr(C.LLVMConstAllOnes(type))
     end
-    
-    def self.const(size)
-      vals = (0..size).map { |i| yield i }
-      from_ptr(C.LLVMConstVector(vals, size))
+
+    def self.const(size_or_values, &block)
+      vals = LLVM::Support.allocate_pointers(size_or_values, &block)
+      from_ptr(C.LLVMConstVector(vals, vals.size / vals.type_size))
     end
   end
-  
+
   class GlobalValue < Constant
     def declaration?
       C.LLVMIsDeclaration(self)
     end
-    
+
     def linkage
       C.LLVMGetLinkage(self)
     end
-    
+
     def linkage=(linkage)
       C.LLVMSetLinkage(self, linkage)
     end
-    
+
     def section
       C.LLVMGetSection(self)
     end
-    
+
     def section=(section)
       C.LLVMSetSection(self, section)
     end
-    
+
     def visibility
       C.LLVMGetVisibility(self)
     end
-    
+
     def visibility=(viz)
       C.LLVMSetVisibility(self, viz)
     end
-    
+
     def alignment
       C.LLVMGetAlignment(self)
     end
-    
+
     def alignment=(bytes)
       C.LLVMSetAlignment(self, bytes)
     end
+
+    def initializer
+      Value.from_ptr(C.LLVMGetInitializer(self))
+    end
+
+    def initializer=(val)
+      C.LLVMSetInitializer(self, val)
+    end
+
+    def global_constant?
+      C.LLVMIsGlobalConstant(self)
+    end
+
+    def global_constant=(flag)
+      C.LLVMSetGlobalConstant(self, flag)
+    end
   end
-  
+
   class Function < GlobalValue
     def call_conv=(conv)
       C.LLVMSetFunctionCallConv(self, conv)
       conv
     end
-    
+
     def add_attribute(attr)
       C.LLVMAddFunctionAttr(self, attr)
     end
-    
+
     def remove_attribute(attr)
       C.LLVMRemoveFunctionAttr(self, attr)
     end
-    
+
     def basic_blocks
       @basic_block_collection ||= BasicBlockCollection.new(self)
     end
-    
+
     class BasicBlockCollection
+      include Enumerable
+
       def initialize(fun)
         @fun = fun
       end
-      
+
       def size
         C.LLVMCountBasicBlocks(@fun)
       end
-      
+
+      def each
+        return to_enum :each unless block_given?
+
+        ptr = C.LLVMGetFirstBasicBlock(@fun)
+        0.upto(size-1) do |i|
+          yield BasicBlock.from_ptr(ptr)
+          ptr = C.LLVMGetNextBasicBlock(ptr)
+        end
+
+        self
+      end
+
       def append(name = "")
-        BasicBlock.from_ptr(C.LLVMAppendBasicBlock(@fun, name))
+        BasicBlock.create(@fun, name)
       end
-      
+
       def entry
         BasicBlock.from_ptr(C.LLVMGetEntryBasicBlock(@fun))
       end
+
+      def first
+        ptr = C.LLVMGetFirstBasicBlock(@fun)
+        BasicBlock.from_ptr(ptr) unless ptr.null?
+      end
+
+      def last
+        ptr = C.LLVMGetLastBasicBlock(@fun)
+        BasicBlock.from_ptr(ptr) unless ptr.null?
+      end
     end
-    
+
     def params
       @parameter_collection ||= ParameterCollection.new(self)
     end
-    
+
     class ParameterCollection
       def initialize(fun)
         @fun = fun
       end
-      
+
       def [](i)
         Value.from_ptr(C.LLVMGetParam(@fun, i))
       end
-      
+
       def size
         C.LLVMCountParams(@fun)
       end
-      
+
       include Enumerable
-      
+
       def each
+        return to_enum :each unless block_given?
         0.upto(size-1) { |i| yield self[i] }
+        self
       end
     end
   end
-  
+
   class GlobalAlias < GlobalValue
   end
-  
+
   class GlobalVariable < GlobalValue
     def initializer
       Value.from_ptr(C.LLVMGetInitializer(self))
     end
-    
+
     def initializer=(val)
       C.LLVMSetInitializer(self, val)
     end
-    
+
     def thread_local?
       case C.LLVMIsThreadLocal(self)
       when 0 then false
       else true
       end
     end
-    
+
     def thread_local=(local)
       C.LLVMSetThreadLocal(self, local ? 1 : 0)
     end
   end
-  
-  class Instruction < Value
+
+  class Instruction < User
+    def parent
+      ptr = C.LLVMGetInstructionParent(self)
+      LLVM::BasicBlock.from_ptr(ptr) unless ptr.null?
+    end
+
+    def next
+      ptr = C.LLVMGetNextInstruction(self)
+      LLVM::Instruction.from_ptr(ptr) unless ptr.null?
+    end
+
+    def previous
+      ptr = C.LLVMGetPreviousInstruction(self)
+      LLVM::Instruction.from_ptr(ptr) unless ptr.null?
+    end
   end
-  
+
   class CallInst < Instruction
     def call_conv=(conv)
       C.LLVMSetInstructionCallConv(self, conv)
       conv
     end
-    
+
     def call_conv
       C.LLVMGetInstructionCallConv(self)
     end
   end
-  
+
   class Phi < Instruction
     # Add incoming branches to a phi node by passing an alternating list
     # of resulting values and basic blocks. e.g.
@@ -441,11 +632,11 @@ module LLVM
       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
-      
+
       size = vals.size
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |vals_ptr|
         vals_ptr.write_array_of_pointer(vals)
@@ -454,11 +645,11 @@ module LLVM
           C.LLVMAddIncoming(self, vals_ptr, blocks_ptr, vals.size)
         end
       end
-      
+
       nil
     end
   end
-  
+
   class SwitchInst < Instruction
     # Adds a case to a switch instruction. First the value to match on,
     # then the basic block.