ruby-llvm-next 10.0.0

data/lib/llvm/core/context.rb

@@ -0,0 +1,24 @@
+module LLVM
+  class Context
+    def initialize(ptr = nil)
+      @ptr = ptr || C.context_create()
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Obtains a reference to the global Context.
+    def self.global
+      new(C.get_global_context())
+    end
+
+    # Diposes the Context.
+    def dispose
+      return if @ptr.nil?
+      C.context_dispose(@ptr)
+      @ptr = nil
+    end
+  end
+end

data/lib/llvm/core/module.rb

@@ -0,0 +1,240 @@
+module LLVM
+  class Module
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr)
+      return if ptr.null?
+      mod = allocate
+      mod.instance_variable_set(:@ptr, ptr)
+      mod
+    end
+
+    # Important: Call #dispose to free backend memory after use, but not when using JITCompiler with this module.
+    def initialize(name)
+      @ptr = C.module_create_with_name(name)
+    end
+
+    def dispose
+      return if @ptr.nil?
+
+      C.dispose_module(@ptr)
+      @ptr = nil
+    end
+
+    # Get module triple.
+    #
+    # @return [String]
+    def triple
+      C.get_target(self)
+    end
+
+    # Set module triple.
+    #
+    # @param [String] triple
+    def triple=(triple)
+      C.set_target(self, triple.to_s)
+    end
+
+    # Get module data layout.
+    #
+    # @return [String]
+    def data_layout
+      C.get_data_layout(self)
+    end
+
+    # Set module data layout.
+    #
+    # @param [String, TargetDataLayout] data_layout
+    def data_layout=(data_layout)
+      C.set_data_layout(self, data_layout.to_s)
+    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
+
+      # Returns the Type with the given name (symbol or string).
+      def named(name)
+        Type.from_ptr(C.get_type_by_name(@module, name.to_s), nil)
+      end
+
+      alias [] named
+    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.add_global(@module, LLVM::Type(ty), name.to_s)).tap do |gvar|
+          yield gvar if block_given?
+        end
+      end
+
+      # Returns the GlobalVariable with the given name (symbol or string).
+      def named(name)
+        GlobalValue.from_ptr(C.get_named_global(@module, name.to_s))
+      end
+
+      # Returns the first GlobalVariable in the collection.
+      def first
+        GlobalValue.from_ptr(C.get_first_global(@module))
+      end
+
+      # Returns the last GlobalVariable in the collection.
+      def last
+        GlobalValue.from_ptr(C.get_last_global(@module))
+      end
+
+      # Returns the next GlobalVariable in the collection after global.
+      def next(global)
+        GlobalValue.from_ptr(C.get_next_global(global))
+      end
+
+      # Returns the previous GlobalVariable in the collection before global.
+      def previous(global)
+        GlobalValue.from_ptr(C.get_previous_global(global))
+      end
+
+      # Deletes the GlobalVariable from the collection.
+      def delete(global)
+        C.delete_global(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? FunctionType
+          type = args.first
+        else
+          type = Type.function(*args)
+        end
+        function = Function.from_ptr(C.add_function(@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.get_named_function(@module, name.to_s))
+      end
+
+      # Returns the first Function in the collection.
+      def first
+        Function.from_ptr(C.get_first_function(@module))
+      end
+
+      # Returns the last Function in the collection.
+      def last
+        Function.from_ptr(C.get_last_function(@module))
+      end
+
+      # Returns the next Function in the collection after function.
+      def next(function)
+        Function.from_ptr(C.get_next_function(function))
+      end
+
+      # Returns the previous Function in the collection before function.
+      def previous(function)
+        Function.from_ptr(C.get_previous_function(function))
+      end
+
+      # Deletes the Function from the collection.
+      def delete(function)
+        C.delete_function(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
+
+    # Returns the LLVM IR of the module as a string.
+    def to_s
+      C.print_module_to_string(self)
+    end
+
+    # Print the module's IR to the standard error.
+    def dump
+      C.dump_module(self)
+    end
+
+  end
+end

data/lib/llvm/core/pass_manager.rb

@@ -0,0 +1,80 @@
+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.
+    #
+    # @param [LLVM::ExecutionEngine, LLVM::TargetMachine] machine
+    def initialize(machine = nil)
+      if machine
+        warn("[DEPRECATION] PassManager.new should be called without parameters")
+      end
+      @ptr = C.create_pass_manager()
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Append a pass to the pass queue.
+    #
+    # @param  [Symbol] name
+    # @return [LLVM::PassManager]
+    def <<(name)
+      send(:"#{name}!")
+
+      self
+    end
+
+    # Run the pass queue on the given module.
+    #
+    # @param  [LLVM::Module] mod
+    # @return [true, false] Indicates whether the module was modified.
+    def run(mod)
+      C.run_pass_manager(self, mod) != 0
+    end
+
+    # Disposes the pass manager.
+    def dispose
+      return if @ptr.nil?
+
+      finalize
+
+      C.dispose_pass_manager(@ptr)
+      @ptr = nil
+    end
+
+    protected
+
+    def finalize
+    end
+  end
+
+  class FunctionPassManager < PassManager
+    # Creates a new function pass manager.
+    #
+    # @param [LLVM::ExecutionEngine, LLVM::TargetMachine] machine
+    # @param [LLVM::Module] mod
+    def initialize(machine, mod)
+      @ptr = C.create_function_pass_manager_for_module(mod)
+      C.add_target_data(machine.data_layout, @ptr)
+
+      C.initialize_function_pass_manager(self) != 0
+    end
+
+    # Run the pass queue on the given function.
+    #
+    # @param  [LLVM::Function] fn
+    # @return [true, false] indicates whether the function was modified.
+    def run(fn)
+      C.run_function_pass_manager(self, fn) != 0
+    end
+
+    protected
+
+    def finalize
+      C.finalize_function_pass_manager(self) != 0
+    end
+  end
+end

data/lib/llvm/core/type.rb

@@ -0,0 +1,210 @@
+module LLVM
+  class Type
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr, kind)
+      return if ptr.null?
+      kind ||= C.get_type_kind(ptr)
+      ty = case kind
+      when :integer  then IntType.allocate
+      when :function then FunctionType.allocate
+      when :struct   then StructType.allocate
+      else allocate
+      end
+      ty.instance_variable_set(:@ptr, ptr)
+      ty.instance_variable_set(:@kind, kind)
+      ty
+    end
+
+    # Returns a symbol representation of the types kind (ex. :pointer, :vector, :array.)
+    def kind
+      @kind
+    end
+
+    # Returns the size of the type.
+    def size
+      LLVM::Int64.from_ptr(C.size_of(self))
+    end
+
+    def align
+      LLVM::Int64.from_ptr(C.align_of(self))
+    end
+
+    # Returns the type of this types elements (works only for Pointer, Vector, and Array types.)
+    def element_type
+      case kind
+      when :pointer, :vector, :array
+        Type.from_ptr(C.get_element_type(self), nil)
+      end
+    end
+
+    # Returns a null pointer ConstantExpr of this type.
+    def null_pointer
+      ConstantExpr.from_ptr(C.const_pointer_null(self))
+    end
+
+    # Returns a null ConstantExpr of this type.
+    def null
+      ConstantExpr.from_ptr(C.const_null(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
+
+    # Print the type's representation to stdout.
+    def dump
+      C.dump_type(self)
+    end
+
+    # Creates an array type of Type with the given size.
+    def self.array(ty, sz = 0)
+      from_ptr(C.array_type(LLVM::Type(ty), sz), :array)
+    end
+
+    # Creates the pointer type of Type with the given address space.
+    def self.pointer(ty, address_space = 0)
+      from_ptr(C.pointer_type(LLVM::Type(ty), address_space), :pointer)
+    end
+
+    # Creates a vector type of Type with the given element count.
+    def self.vector(ty, element_count)
+      from_ptr(C.vector_type(LLVM::Type(ty), element_count), :vector)
+    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)
+      from_ptr(C.function_type(LLVM::Type(result_type), arg_types_ptr, arg_types.size, options[:varargs] ? 1 : 0), :function)
+    end
+
+    # Creates a struct type with the given array of element types.
+    def self.struct(elt_types, is_packed, name = nil)
+      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)
+      if name
+        struct = from_ptr(C.struct_create_named(Context.global, name), :struct)
+        C.struct_set_body(struct, elt_types_ptr, elt_types.size, is_packed ? 1 : 0) unless elt_types.empty?
+        struct
+      else
+        from_ptr(C.struct_type(elt_types_ptr, elt_types.size, is_packed ? 1 : 0), :struct)
+      end
+    end
+
+    # Creates a void type.
+    def self.void
+      from_ptr(C.void_type, :void)
+    end
+
+    def self.rec
+      h = opaque
+      ty = yield h
+      h.refine(ty)
+      ty
+    end
+  end
+
+  class IntType < Type
+    def width
+      C.get_int_type_width(self)
+    end
+  end
+
+  class FunctionType < Type
+    def return_type
+      Type.from_ptr(C.get_return_type(self), nil)
+    end
+
+    def argument_types
+      size = C.count_param_types(self)
+      result = nil
+      FFI::MemoryPointer.new(FFI.type_size(:pointer) * size) do |types_ptr|
+        C.get_param_types(self, types_ptr)
+        result = types_ptr.read_array_of_pointer(size)
+      end
+      result.map { |p| Type.from_ptr(p, nil) }
+    end
+
+    def vararg?
+      C.is_function_var_arg(self) != 0
+    end
+  end
+
+  class StructType < Type
+    # Returns the name of the struct.
+    def name
+      C.get_struct_name(self)
+    end
+
+    # Returns the element types of the struct.
+    def element_types
+      count = C.count_struct_element_types(self)
+      elt_types = nil
+      FFI::MemoryPointer.new(FFI.type_size(:pointer) * count) do |types_ptr|
+        C.get_struct_element_types(self, types_ptr)
+        elt_types = types_ptr.read_array_of_pointer(count).map { |type_ptr| Type.from_ptr(type_ptr, nil) }
+      end
+      elt_types
+    end
+
+    # Sets the struct body.
+    def element_types=(elt_types)
+      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)
+      C.struct_set_body(self, elt_types_ptr, elt_types.size, 0)
+    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)
+    name = if elt_types.last.is_a? String
+      elt_types.pop
+    else
+      nil
+    end
+    LLVM::Type.struct(elt_types, false, name)
+  end
+
+  # Shortcut to Type.void.
+  def Void
+    LLVM::Type.void
+  end
+
+end