ruby-llvm 2.7.0 → 2.9.0

data/README.rdoc

@@ -1,28 +1,31 @@
 = LLVM
 
 Author:: Jeremy Voorhis
-Contributors:: Evan Phoenix
-Copyright:: Copyright (c) 2010 Jeremy Voorhis
+Contributors:: Evan Phoenix, Takanori Ishikawa, Ronaldo M. Ferraz
+Copyright:: Copyright (c) 2010-2011 Jeremy Voorhis
 License:: BSD 3-clause (see LICENSE)
 
-This package contains Ruby bindings to the LLVM api, enabling users to make use
-of LLVM's optimization passes and JIT compilation for implementing compiled
-DSLs, callback functions, or fast Ruby method implementations.
+This package contains Ruby bindings to the LLVM api, enabling users to
+make use of LLVM's optimization passes and JIT compilation for
+implementing compiled DSLs, callback functions, or fast Ruby method
+implementations.
 
-ruby-llvm has been tested on the following Ruby interpreters:
 
-* MRI 1.8.7
-* MRI 1.9.1
+
+ruby-llvm has been tested on Mac OS X 10.6 using the following Ruby interpreters:
+
+* MRI 1.8.7-p174
+* MRI 1.9.2-p180
 * JRuby 1.4.0
 
-If using MRI, then at least ffi >= 0.5.4 is required.
+If using MRI, ffi >= 1.0.7 is recommended.
 
 == Requirements
-* LLVM 2.7, compiled with --shared-library
+* LLVM 2.9, including libLLVM-2.9 (compile LLVM with --enable-shared)
 
 == About version numbers
 
-The first two digits of ruby-llvm's version number refer to the required major
-and minor version of LLVM. The third digit refers to the ruby-llvm release
-itself. Because LLVM's api changes often, this coupling between LLVM and
-ruby-llvm versions is necessary.
+The first two digits of ruby-llvm's version number refer to the required
+major and minor version of LLVM. The third digit refers to the ruby-llvm
+release itself. Because LLVM's api changes often, this coupling between
+LLVM and ruby-llvm versions is useful.

data/lib/llvm.rb

@@ -1,10 +1,12 @@
+require 'rubygems'
 require 'ffi'
 
 module LLVM
   module C
     extend ::FFI::Library
+
     # load required libraries
-    ffi_lib 'LLVM-2.7'
+    ffi_lib ['LLVM-2.9', 'libLLVM-2.9']
   end
   
   NATIVE_INT_SIZE = case FFI::Platform::ARCH

data/lib/llvm/analysis.rb

@@ -35,12 +35,8 @@ module LLVM
   end
   
   class Function
-    def verify(action = :abort)
-      str = FFI::MemoryPointer.new(FFI.type_size(:pointer))
-      case status = C.LLVMVerifyFunction(self, action, str)
-        when 1 then str.read_string
-        else nil
-      end
+    def verify(action = :abort_process)
+      C.LLVMVerifyFunction(self, action) != 0
     end
   end
 end

data/lib/llvm/core.rb

@@ -24,7 +24,76 @@ module LLVM
       :no_implicit_float, 1 << 23,
       :naked,             1 << 24
     ]
-    
+
+    enum :opcode, [
+      # Terminator Instructions
+      :ret,             1,
+      :br,              2,
+      :switch,          3,
+      :indirectbr,      4,
+      :invoke,          5,
+      :unwind,          6,
+      :unreachable,     7,
+
+      # Standard Binary Operators
+      :add,             8,
+      :fadd,            9,
+      :sub,             10,
+      :fsub,            11,
+      :mul,             12,
+      :fmul,            13,
+      :udiv,            14,
+      :sdiv,            15,
+      :fdiv,            16,
+      :urem,            17,
+      :srem,            18,
+      :frem,            19,
+
+      # Logical Operators
+      :shl,             20,
+      :lshr,            21,
+      :ashr,            22,
+      :and,             23,
+      :or,              24,
+      :xor,             25,
+
+      # Memory Operators
+      :alloca,          26,
+      :load,            27,
+      :store,           28,
+      :getelementptr,   29,
+
+      # Cast Operators
+      :trunc,           30,
+      :zext,            31,
+      :sext,            32,
+      :fptoui,          33,
+      :fptosi,          34,
+      :uitofp,          35,
+      :sitofp,          36,
+      :fptrunc,         37,
+      :fpext,           38,
+      :ptrtoint,        39,
+      :inttoptr,        40,
+      :bitcast,         41,
+
+      # Other Operators
+      :icmp,            42,
+      :fcmp,            43,
+      :phi,             44,
+      :call,            45,
+      :select,          46,
+
+      # UserOp1
+      # UserOp2
+      :vaarg,           49,
+      :extractelement,  50,
+      :insertelement,   51,
+      :shufflevector,   52,
+      :extractvalue,    53,
+      :insertvalue,     54,
+    ]
+
     enum :type_kind, [
       :void,
       :float,
@@ -206,6 +275,11 @@ module LLVM
     attach_function :LLVMSetValueName, [:pointer, :string], :void
     attach_function :LLVMDumpValue, [:pointer], :void
     
+    # Operations on Users
+    attach_function :LLVMGetOperand, [:pointer, :int], :pointer
+    attach_function :LLVMSetOperand, [:pointer, :int, :pointer], :void
+    attach_function :LLVMGetNumOperands, [:pointer], :int
+
     # Constants of any type
     attach_function :LLVMConstNull, [:pointer], :pointer
     attach_function :LLVMConstAllOnes, [:pointer], :pointer
@@ -233,6 +307,7 @@ module LLVM
     attach_function :LLVMConstVector, [:pointer, :uint], :pointer
     
     # Constant expressions
+    attach_function :LLVMGetConstOpcode, [:pointer], :opcode
     attach_function :LLVMAlignOf, [:pointer], :pointer
     attach_function :LLVMSizeOf, [:pointer], :pointer
     attach_function :LLVMConstNeg, [:pointer], :pointer
@@ -309,10 +384,10 @@ module LLVM
     attach_function :LLVMDeleteGlobal, [:pointer], :void
     attach_function :LLVMGetInitializer, [:pointer], :pointer
     attach_function :LLVMSetInitializer, [:pointer, :pointer], :void
-    attach_function :LLVMIsThreadLocal, [:pointer], :int
+    attach_function :LLVMIsThreadLocal, [:pointer], :bool
     attach_function :LLVMSetThreadLocal, [:pointer, :int], :void
-    attach_function :LLVMIsGlobalConstant, [:pointer], :int
-    attach_function :LLVMSetGlobalConstant, [:pointer, :int], :void
+    attach_function :LLVMIsGlobalConstant, [:pointer], :bool
+    attach_function :LLVMSetGlobalConstant, [:pointer, :bool], :void
     
     # Aliases
     attach_function :LLVMAddAlias, [:pointer, :pointer, :pointer, :string], :pointer
@@ -443,7 +518,7 @@ module LLVM
     attach_function :LLVMBuildMalloc, [:pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildArrayMalloc, [:pointer, :pointer, :pointer, :string], :string
     attach_function :LLVMBuildAlloca, [:pointer, :pointer, :string], :pointer
-    attach_function :LLVMBuildArrayAlloca, [:pointer, :pointer, :string], :pointer
+    attach_function :LLVMBuildArrayAlloca, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildFree, [:pointer, :pointer], :pointer
     attach_function :LLVMBuildLoad, [:pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildStore, [:pointer, :pointer, :pointer], :pointer
@@ -459,7 +534,7 @@ module LLVM
     attach_function :LLVMBuildSExt, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildFPToUI, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildFPToSI, [:pointer, :pointer, :pointer, :string], :pointer
-    attach_function :LLVMBuildUIToFP, [:pointer, :pointer, :string], :pointer
+    attach_function :LLVMBuildUIToFP, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildSIToFP, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildFPTrunc, [:pointer, :pointer, :pointer, :string], :pointer
     attach_function :LLVMBuildFPExt, [:pointer, :pointer, :pointer, :string], :pointer
@@ -504,6 +579,7 @@ module LLVM
     # Pass managers
     attach_function :LLVMCreatePassManager, [], :pointer
     attach_function :LLVMCreateFunctionPassManager, [:pointer], :pointer
+    attach_function :LLVMCreateFunctionPassManagerForModule, [:pointer], :pointer
     attach_function :LLVMRunPassManager, [:pointer, :pointer], :int
     attach_function :LLVMInitializeFunctionPassManager, [:pointer], :int
     attach_function :LLVMRunFunctionPassManager, [:pointer, :pointer], :int

data/lib/llvm/core/builder.rb

@@ -1,314 +1,325 @@
 module LLVM
   class Builder
-    class << self
-      private :new
-    end
-    
+    private_class_method :new
+
     def initialize(ptr) # :nodoc:
       @ptr = ptr
     end
-    
+
     def to_ptr # :nodoc:
       @ptr
     end
-    
+
     def self.create
       new(C.LLVMCreateBuilder())
     end
-    
+
+    def position(block, instruction)
+      raise "block must not be nil" if block.nil?
+      C.LLVMPositionBuilder(self, block, instruction)
+      self
+    end
+
+    def position_before(instruction)
+      raise "instruction must not be nil" if instruction.nil?
+      C.LLVMPositionBuilderBefore(self, instruction)
+      self
+    end
+
     def position_at_end(block)
+      raise "block must not be nil" if block.nil?
       C.LLVMPositionBuilderAtEnd(self, block)
       self
     end
-    
+
     def get_insert_block
       BasicBlock.from_ptr(C.LLVMGetInsertBlock(self))
     end
-    
+
     # Terminators
-    
+
     def ret_void
       Instruction.from_ptr(C.LLVMBuildRetVoid(self))
     end
-    
+
     def ret(val)
       Instruction.from_ptr(C.LLVMBuildRet(self, val))
     end
-    
+
     def aggregate_ret(*vals)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * vals.size) do |vals_ptr|
         vals_ptr.write_array_of_pointer(vals)
         Instruction.from_ptr(C.LLVMBuildAggregateRet(self, vals_ptr, vals.size))
       end
     end
-    
+
     def br(block)
       Instruction.from_ptr(
         C.LLVMBuildBr(self, block))
     end
-    
+
     def cond(cond, iftrue, iffalse)
       Instruction.from_ptr(
         C.LLVMBuildCondBr(self, cond, iftrue, iffalse))
     end
-    
+
     def switch(val, block, ncases)
       SwitchInst.from_ptr(C.LLVMBuildSwitch(self, val, block, ncases))
     end
-    
+
     def invoke(fun, args, _then, _catch, name = "")
       Instruction.from_ptr(
         C.LLVMBuildInvoke(self,
           fun, args, args.size, _then, _catch, name))
     end
-    
+
     def unwind
       Instruction.from_ptr(C.LLVMBuildUnwind(self))
     end
-    
+
     def unreachable
       Instruction.from_ptr(C.LLVMBuildUnreachable(self))
     end
-    
+
     # Arithmetic
-    
+
     def add(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildAdd(self, lhs, rhs, name))
     end
-    
+
     def nsw_add(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildNSWAdd(self, lhs, rhs, name))
     end
-    
+
     def fadd(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFAdd(self, lhs, rhs, name))
     end
-    
+
     def sub(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildSub(self, lhs, rhs, name))
     end
-    
+
     def fsub(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFSub(self, lhs, rhs, name))
     end
-    
+
     def mul(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildMul(self, lhs, rhs, name))
     end
-    
+
     def fmul(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFMul(self, lhs, rhs, name))
     end
-    
+
     def udiv(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildUDiv(self, lhs, rhs, name))
     end
-    
+
     def sdiv(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildSDiv(self, lhs, rhs, name))
     end
-    
+
     def exact_sdiv(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildExactSDiv(self, lhs, rhs, name))
     end
-    
+
     def fdiv(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFDiv(self, lhs, rhs, name))
     end
-    
+
     def urem(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildURem(self, lhs, rhs, name))
     end
-    
+
     def srem(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildSRem(self, lhs, rhs, name))
     end
-    
+
     def frem(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFRem(self, lhs, rhs, name))
     end
-    
+
     def shl(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildShl(self, lhs, rhs, name))
     end
-    
+
     def lshr(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildLShr(self, lhs, rhs, name))
     end
-    
+
     def ashr(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildAShr(self, lhs, rhs, name))
     end
-    
+
     def and(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildAnd(self, lhs, rhs, name))
     end
-    
+
     def or(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildOr(self, lhs, rhs, name))
     end
-    
+
     def xor(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildXor(self, lhs, rhs, name))
     end
-    
+
     def neg(arg, name = "")
       Instruction.from_ptr(C.LLVMBuildNeg(self, arg, name))
     end
-    
+
     def not(arg, name = "")
       Instruction.from_ptr(C.LLVMBuildNot(self, arg, name))
     end
-    
+
     # Memory
-    
+
     def malloc(ty, name = "")
       Instruction.from_ptr(C.LLVMBuildMalloc(self, LLVM::Type(ty), name))
     end
-    
+
     def array_malloc(ty, val, name = "")
       Instruction.from_ptr(C.LLVMBuildArrayMalloc(self, LLVM::Type(ty), val, name))
     end
-    
+
     def alloca(ty, name = "")
       Instruction.from_ptr(C.LLVMBuildAlloca(self, LLVM::Type(ty), name))
     end
-    
+
     def array_alloca(ty, val, name = "")
       Instruction.from_ptr(C.LLVMBuildArrayAlloca(self, LLVM::Type(ty), val, name))
     end
-    
+
     def free(pointer)
       Instruction.from_ptr(C.LLVMBuildFree(self, pointer))
     end
-    
+
     def load(pointer, name = "")
       Instruction.from_ptr(C.LLVMBuildLoad(self, pointer, name))
     end
-    
+
     def store(val, pointer)
       Instruction.from_ptr(C.LLVMBuildStore(self, val, pointer))
     end
-    
+
     def gep(pointer, indices, name = "")
       indices = Array(indices)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
         indices_ptr.write_array_of_pointer(indices)
         return Instruction.from_ptr(
-          C.LLVMBuildInBoundsGEP(self, pointer, indices_ptr, indices.size, name))
+          C.LLVMBuildGEP(self, pointer, indices_ptr, indices.size, name))
       end
     end
-    
+
     def inbounds_gep(pointer, indices, name = "")
       indices = Array(indices)
       FFI::MemoryPointer.new(FFI.type_size(:pointer) * indices.size) do |indices_ptr|
         indices_ptr.write_array_of_pointer(indices)
         return Instruction.from_ptr(
-          C.LLVMBuildGEP(self, pointer, indices_ptr, indices.size, name))
+          C.LLVMBuildInBoundsGEP(self, pointer, indices_ptr, indices.size, name))
       end
     end
-    
+
     def struct_gep(pointer, idx, name = "")
       Instruction.from_ptr(C.LLVMBuildStructGEP(self, pointer, idx, name))
     end
-    
+
     def global_string(string, name = "")
       Instruction.from_ptr(C.LLVMBuildGlobalString(self, string, name))
     end
-    
+
     def global_string_pointer(string, name = "")
-      Instruction.from_ptr(C.LLVMBuildGlobalStringPointer(self, string, name))
+      Instruction.from_ptr(C.LLVMBuildGlobalStringPtr(self, string, name))
     end
-    
+
     # Casts
-    
+
     def trunc(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildTrunc(self, val, LLVM::Type(ty), name))
     end
-    
+
     def zext(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildZExt(self, val, LLVM::Type(ty), name))
     end
-    
+
     def sext(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildSExt(self, val, LLVM::Type(ty), name))
     end
-    
+
     def fp2ui(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildFPToUI(self, val, LLVM::Type(ty), name))
     end
-    
+
     def fp2si(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildFPToSI(self, val, LLVM::Type(ty), name))
     end
-    
+
     def ui2fp(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildUIToFP(self, val, LLVM::Type(ty), name))
     end
-    
+
     def si2fp(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildSIToFP(self, val, LLVM::Type(ty), name))
     end
-    
+
     def fp_trunc(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildFPTrunc(self, val, LLVM::Type(ty), name))
     end
-    
+
     def fp_ext(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildFPExt(self, val, LLVM::Type(ty), name))
     end
-    
+
     def ptr2int(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildPtrToInt(self, val, LLVM::Type(ty), name))
     end
-    
+
     def int2ptr(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildIntToPtr(self, val, LLVM::Type(ty), name))
     end
-    
+
     def bit_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildBitCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def zext_or_bit_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildZExtOrBitCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def sext_or_bit_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildSExtOrBitCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def trunc_or_bit_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildTruncOrBitCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def pointer_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildPointerCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def int_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildIntCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     def fp_cast(val, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildFPCast(self, val, LLVM::Type(ty), name))
     end
-    
+
     # Comparisons
-    
+
     def icmp(pred, lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildICmp(self, pred, lhs, rhs, name))
     end
-    
+
     def fcmp(pred, lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildFCmp(self, pred, lhs, rhs, name))
     end
-    
+
     # Misc
-    
+
     def phi(ty, *incoming)
       if incoming.last.kind_of? String
-        name = incomimg.pop
+        name = incoming.pop
       else
         name = ""
       end
@@ -317,8 +328,9 @@ module LLVM
       phi.add_incoming(*incoming) unless incoming.empty?
       phi
     end
-    
+
     def call(fun, *args)
+      raise "No fun" if fun.nil?
       if args.last.kind_of? String
         name = args.pop
       else
@@ -329,47 +341,47 @@ module LLVM
       args_ptr.write_array_of_pointer(args)
       CallInst.from_ptr(C.LLVMBuildCall(self, fun, args_ptr, args.size, name))
     end
-    
+
     def select(_if, _then, _else, name = "")
       Instruction.from_ptr(C.LLVMBuildSelect(self, _if, _then, _else, name))
     end
-    
+
     def va_arg(list, ty, name = "")
       Instruction.from_ptr(C.LLVMBuildVAArg(self, list, LLVM::Type(ty), name))
     end
-    
+
     def extract_element(vector, index, name = "")
       Instruction.from_ptr(C.LLVMBuildExtractElement(self, vector, index, name))
     end
-    
+
     def insert_element(vector, elem, index, name = "")
       Instruction.from_ptr(C.LLVMBuildInsertElement(self, vector, elem, index, name))
     end
-    
+
     def shuffle_vector(vec1, vec2, mask, name = "")
       Instruction.from_ptr(C.LLVMBuildShuffleVector(self, vec1, vec2, mask, name))
     end
-    
+
     def extract_value(aggregate, index, name = "")
       Instruction.from_ptr(C.LLVMBuildExtractValue(self, aggregate, index, name))
     end
-    
+
     def insert_value(aggregate, elem, index, name = "")
       Instruction.from_ptr(C.LLVMBuildInsertValue(self, aggregate, elem, index, name))
     end
-    
+
     def is_null(val, name = "")
       Instruction.from_ptr(C.LLVMBuildIsNull(self, val, name))
     end
-    
+
     def is_not_null(val, name = "")
       Instruction.from_ptr(C.LLVMBuildIsNotNull(self, val, name))
     end
-    
+
     def ptr_diff(lhs, rhs, name = "")
       Instruction.from_ptr(C.LLVMBuildPtrDiff(lhs, rhs, name))
     end
-    
+
     def dispose
       C.LLVMDisposeBuilder(@ptr)
     end