waj-ruby-llvm 2.9.2

data/lib/llvm/core/context.rb

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

data/lib/llvm/core/module.rb

@@ -0,0 +1,232 @@
+module LLVM  
+  class Module
+    # @private
+    def self.from_ptr(ptr)
+      return if ptr.null?
+      mod = allocate
+      mod.instance_variable_set(:@ptr, ptr)
+      mod
+    end
+    
+    def initialize(name)
+      @ptr = C.LLVMModuleCreateWithName(name)
+    end
+    
+    # @private
+    def to_ptr
+      @ptr
+    end
+    
+    # Checks if the module is equal to other.
+    def ==(other)
+      case other
+      when LLVM::Module
+        @ptr == other.to_ptr
+      else
+        false
+      end
+    end
+
+    # Checks if the module is equal to other.
+    def eql?(other)
+      other.instance_of?(self.class) && self == other
+    end
+
+    # Returns a TypeCollection of all the Types in the module.
+    def types
+      @types ||= TypeCollection.new(self)
+    end
+    
+    class TypeCollection
+      def initialize(mod)
+        @module = mod
+      end
+      
+      # Adds the given Type to the collection with the given name (symbol or string).
+      def add(name, type)
+        C.LLVMAddTypeName(@module, name.to_s, type)
+      end
+      
+      # Returns the Type with the given name (symbol or string).
+      def named(name)
+        Type.from_ptr(C.LLVMGetTypeByName(@module, name.to_s))
+      end
+      
+      # Returns the Type with the a name equal to key (symbol or string).
+      def [](key)
+        named(key)
+      end
+      
+      # Adds the given Type to the collection with a name equal to key (symbol or string).
+      def []=(key, type)
+        add(key, type)
+      end
+    end
+    
+    # Returns an Enumerable of all the GlobalVariables in the module.
+    def globals
+      @globals ||= GlobalCollection.new(self)
+    end
+    
+    class GlobalCollection
+      include Enumerable
+      
+      def initialize(mod)
+        @module = mod
+      end
+      
+      # Adds a GlobalVariable with the given type and name to the collection (symbol or string).
+      def add(ty, name)
+        GlobalVariable.from_ptr(C.LLVMAddGlobal(@module, LLVM::Type(ty), name.to_s))
+      end
+      
+      # Returns the GlobalVariable with the given name (symbol or string).
+      def named(name)
+        GlobalValue.from_ptr(C.LLVMGetNamedGlobal(@module, name.to_s))
+      end
+      
+      # Returns the first GlobalVariable in the collection.
+      def first
+        GlobalValue.from_ptr(C.LLVMGetFirstGlobal(@module))
+      end
+      
+      # Returns the last GlobalVariable in the collection.
+      def last
+        GlobalValue.from_ptr(C.LLVMGetLastGlobal(@module))
+      end
+      
+      # Returns the next GlobalVariable in the collection after global.
+      def next(global)
+        GlobalValue.from_ptr(C.LLVMGetNextGlobal(global))
+      end
+      
+      # Returns the previous GlobalVariable in the collection before global.
+      def previous(global)
+        GlobalValue.from_ptr(C.LLVMGetPreviousGlobal(global))
+      end
+      
+      # Deletes the GlobalVariable from the collection.
+      def delete(global)
+        C.LLVMDeleteGlobal(global)
+      end
+      
+      # Returns the GlobalVariable with a name equal to key (symbol or string) or at key (integer).
+      def [](key)
+        case key
+        when String, Symbol then named(key)
+        when Integer then
+          i = 0
+          g = first
+          until i >= key || g.nil?
+            g = self.next(g)
+            i += 1
+          end
+          g
+        end
+      end
+      
+      # Iterates through each GlobalVariable in the collection.
+      def each
+        g = first
+        until g.nil?
+          yield g
+          g = self.next(g)
+        end
+      end
+    end
+    
+    # Returns a FunctionCollection of all the Functions in the module.
+    def functions
+      @functions ||= FunctionCollection.new(self)
+    end
+    
+    class FunctionCollection
+      include Enumerable
+      
+      def initialize(mod)
+        @module = mod
+      end
+      
+      # Adds a Function with the given name (symbol or string) and args (Types).
+      def add(name, *args)
+        if args.first.kind_of? Type
+          type = args.first
+        else
+          type = Type.function(*args)
+        end
+        function = Function.from_ptr(C.LLVMAddFunction(@module, name.to_s, type))
+        
+        if block_given?
+          params = (0...function.params.size).map { |i| function.params[i] }
+          yield function, *params
+        end
+        
+        function        
+      end
+      
+      # Returns the Function with the given name (symbol or string).
+      def named(name)
+        Function.from_ptr(C.LLVMGetNamedFunction(@module, name.to_s))
+      end
+      
+      # Returns the first Function in the collection.
+      def first
+        Function.from_ptr(C.LLVMGetFirstFunction(@module))
+      end
+      
+      # Returns the last Function in the collection.
+      def last
+        Function.from_ptr(C.LLVMGetLastFunction(@module))
+      end
+      
+      # Returns the next Function in the collection after function.
+      def next(function)
+        Function.from_ptr(C.LLVMGetNextFunction(function))
+      end
+      
+      # Returns the previous Function in the collection before function.
+      def previous(function)
+        Function.from_ptr(C.LLVMGetPreviousFunction(function))
+      end
+      
+      # Deletes the Function from the collection.
+      def delete(function)
+        C.LLVMDeleteFunction(function)
+      end
+      
+      # Returns the Function with a name equal to key (symbol or string) or at key (integer).
+      def [](key)
+        case key
+        when String, Symbol then named(key)
+        when Integer
+          i = 0
+          f = first
+          until i >= key || f.nil?
+            f = self.next(f)
+            i += 1
+          end
+          f
+        end
+      end
+      
+      # Iterates through each Function in the collection.
+      def each
+        f = first
+        until f.nil?
+          yield f
+          f = self.next(f)
+        end
+      end
+    end
+    
+    # Print the module's IR to stdout.
+    def dump
+      C.LLVMDumpModule(self)
+    end
+    
+    # Dispose the module.
+    def dispose
+      C.LLVMDisposeModule(@ptr)
+    end
+  end
+end

data/lib/llvm/core/pass_manager.rb

@@ -0,0 +1,76 @@
+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.
+  class PassManager
+    # Creates a new pass manager on the given ExecutionEngine.
+    def initialize(execution_engine)
+      ptr = C.LLVMCreatePassManager()
+      C.LLVMAddTargetData(
+        C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
+      @ptr = ptr
+
+      do_initialization
+    end
+    
+    # @private
+    def to_ptr
+      @ptr
+    end
+    
+    # Append a pass to the pass queue.
+    # @param [Symbol]
+    # @return [LLVM::PassManager]
+    def <<(name)
+      send(:"#{name}!")
+      self
+    end
+
+    # 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) != 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
+    # Creates a new pass manager on the given ExecutionEngine and Module.
+    def initialize(execution_engine, mod)
+      ptr = C.LLVMCreateFunctionPassManagerForModule(mod)
+      C.LLVMAddTargetData(
+        C.LLVMGetExecutionEngineTargetData(execution_engine), ptr)
+      @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
+
+    def do_finalization
+      C.LLVMFinalizeFunctionPassManager(self) != 0
+    end
+  end
+end

data/lib/llvm/core/type.rb

@@ -0,0 +1,173 @@
+module LLVM  
+  class Type
+    # @private
+    def to_ptr
+      @ptr
+    end
+    
+    # LLVM's represents types uniquely, and supports pointer equality. 
+    def ==(type)
+      case type
+      when LLVM::Type
+        @ptr == type.to_ptr
+      else
+        false
+      end
+    end
+
+    # Checks if the type is equal to other.
+    def eql?(other)
+      other.instance_of?(self.class) && self == other
+    end
+
+    # Returns a symbol representation of the types kind (ex. :pointer, :vector, :array.)
+    def kind
+      C.LLVMGetTypeKind(self)
+    end
+
+    # Returns the size of the type.
+    def size
+      LLVM::Int64.from_ptr(C.LLVMSizeOf(self))
+    end
+    
+    def align
+      LLVM::Int64.from_ptr(C.LLVMAlignOf(self))
+    end
+
+    # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
+    def element_type
+      case self.kind
+      when :pointer, :vector, :array
+        Type.from_ptr(C.LLVMGetElementType(self))
+      end
+    end
+
+    # Returns a null pointer ConstantExpr of this type.
+    def null_pointer
+      ConstantExpr.from_ptr(C.LLVMConstPointerNull(self))
+    end
+
+    # Returns a null ConstantExpr of this type.
+    def null
+      ConstantExpr.from_ptr(C.LLVMConstNull(self))
+    end
+
+    # Creates a pointer type with this type and the given address space.
+    def pointer(address_space = 0)
+      Type.pointer(self, address_space)
+    end
+    
+    # @private
+    def self.from_ptr(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.
+    def self.array(ty, sz = 0)
+      from_ptr(C.LLVMArrayType(LLVM::Type(ty), sz))
+    end
+    
+    # Creates the pointer type of Type with the given address space.
+    def self.pointer(ty, address_space = 0)
+      from_ptr(C.LLVMPointerType(LLVM::Type(ty), address_space))
+    end
+    
+    # Creates a vector type of Type with the given element count.
+    def self.vector(ty, element_count)
+      from_ptr(C.LLVMVectorType(LLVM::Type(ty), element_count))
+    end
+    
+    # Creates a function type. Takes an array of argument Types and the result Type. The only option is <tt>:varargs</tt>, 
+    # which when set to true makes the function type take a variable number of args.
+    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)
+      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.
+    def self.struct(elt_types, is_packed)
+      elt_types.map! { |ty| LLVM::Type(ty) }
+      elt_types_ptr = FFI::MemoryPointer.new(FFI.type_size(:pointer) * elt_types.size)
+      elt_types_ptr.write_array_of_pointer(elt_types)
+      from_ptr(C.LLVMStructType(elt_types_ptr, elt_types.size, is_packed ? 1 : 0))
+    end
+
+    # Creates a void type.
+    def self.void
+      from_ptr(C.LLVMVoidType)
+    end
+    
+    # Creates an opaque type.
+    def self.opaque
+      from_ptr(C.LLVMOpaqueType)
+    end
+    
+    def self.rec
+      h = opaque
+      ty = yield h
+      h.refine(ty)
+      ty
+    end
+    
+    def refine(ty)
+      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 Type(ty)
+    case ty
+    when LLVM::Type then ty
+    else ty.type
+    end
+  end
+  
+  # Shortcut to Type.array.
+  def Array(ty, sz = 0)
+    LLVM::Type.array(ty, sz)
+  end
+  
+  # Shortcut to Type.pointer.
+  def Pointer(ty)
+    LLVM::Type.pointer(ty)
+  end
+  
+  # Shortcut to Type.vector.
+  def Vector(ty, sz)
+    LLVM::Type.vector(ty, sz)
+  end
+  
+  # Shortcut to Type.function.
+  def Function(argtypes, rettype, options = {})
+    LLVM::Type.function(argtypes, rettype, options)
+  end
+  
+  # Shortcut to Type.struct.
+  def Struct(*elt_types)
+    LLVM::Type.struct(elt_types, false)
+  end
+
+  # Shortcut to Type.void.
+  def Void
+    LLVM::Type.void
+  end
+end