ruby-llvm 3.1.0.beta.1 → 3.2.0.beta.1

data/lib/llvm/execution_engine.rb

@@ -5,19 +5,6 @@ require 'llvm/analysis'
 require 'llvm/execution_engine_ffi'
 
 module LLVM
-  # @private
-  module C
-    attach_function :initialize_x86_target_info, :LLVMInitializeX86TargetInfo, [], :void
-    attach_function :initialize_x86_target, :LLVMInitializeX86Target, [], :void
-    attach_function :initialize_x86_target_mc, :LLVMInitializeX86TargetMC, [], :void
-  end
-
-  def LLVM.init_x86
-    LLVM::C.initialize_x86_target
-    LLVM::C.initialize_x86_target_info
-    LLVM::C.initialize_x86_target_mc
-  end
-
   class JITCompiler
     # Important: Call #dispose to free backend memory after use. Do not call #dispose on mod any more.
     def initialize(mod, opt_level = 3)
@@ -36,7 +23,7 @@ module LLVM
         end
       end
     end
-    
+
     def dispose
       return if @ptr.nil?
       C.dispose_execution_engine(@ptr)
@@ -48,6 +35,13 @@ module LLVM
       @ptr
     end
 
+    # Get the associated data layout.
+    #
+    # @return [TargetDataLayout]
+    def data_layout
+      TargetDataLayout.from_ptr(C.get_execution_engine_target_data(self))
+    end
+
     # Execute the given LLVM::Function with the supplied args (as
     # GenericValues).
     # Important: Call #dispose on the returned GenericValue to
@@ -82,7 +76,7 @@ module LLVM
     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?
@@ -90,7 +84,7 @@ module LLVM
       val.instance_variable_set(:@ptr, ptr)
       val
     end
-    
+
     def dispose
       return if @ptr.nil?
       C.dispose_generic_value(@ptr)
@@ -113,7 +107,7 @@ module LLVM
     def self.from_d(val)
       from_ptr(C.create_generic_value_of_float(LLVM::Double, val))
     end
-    
+
     # Creates a GenericValue from a Ruby boolean.
     def self.from_b(b)
       from_i(b ? 1 : 0, LLVM::Int1, false)
@@ -135,12 +129,12 @@ module LLVM
     def to_f(type = LLVM::Float.type)
       C.generic_value_to_float(type, self)
     end
-    
+
     # Converts a GenericValue to a Ruby boolean.
     def to_b
       to_i(false) != 0
     end
-    
+
     def to_value_ptr
       C.generic_value_to_pointer(self)
     end

data/lib/llvm/execution_engine_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.1'
+  ffi_lib 'LLVM-3.2'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e

data/lib/llvm/linker.rb

@@ -0,0 +1,35 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/linker_ffi'
+
+module LLVM
+  class Module
+    # Link the current module into +other+.
+    #
+    # @return [nil, String] human-readable error if linking has failed
+    def link_into(other)
+      LLVM.with_message_output do |msg|
+        # HACK ALERT: ffi-gen missed LLVMLinkerPreserveSource enumeration for
+        # some reason. It is inlined as a constant here.
+
+        # C.link_modules(mod, self, :linker_preserve_source, msg)
+        C.link_modules(other, self, 1, msg)
+      end
+    end
+
+    # Link the current module into +other+, and dispose the current module.
+    #
+    # @return [nil, String] human-readable error if linking has failed
+    def link_into_and_destroy(other)
+      result = LLVM.with_message_output do |msg|
+        # HACK ALERT: ffi-gen missed LLVMLinkerPreserveSource enumeration for
+        # some reason. It is inlined as a constant here.
+        C.link_modules(other, self, :linker_destroy_source, msg)
+      end
+
+      @ptr = nil
+
+      result
+    end
+  end
+end

data/lib/llvm/linker_ffi.rb

@@ -0,0 +1,45 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  ffi_lib 'LLVM-3.2'
+  
+  def self.attach_function(name, *_)
+    begin; super; rescue FFI::NotFoundError => e
+      (class << self; self; end).class_eval { define_method(name) { |*_| raise e } }
+    end
+  end
+  
+  # (Not documented)
+  # 
+  # <em>This entry is only for documentation and no real method. The FFI::Enum can be accessed via #enum_type(:linker_mode).</em>
+  # 
+  # === Options:
+  # :linker_destroy_source ::
+  #   
+  # 
+  # @method _enum_linker_mode_
+  # @return [Symbol]
+  # @scope class
+  enum :linker_mode, [
+    :linker_destroy_source, 0
+  ]
+  
+  # Links the source module into the destination module, taking ownership
+  # of the source module away from the caller. Optionally returns a
+  # human-readable description of any errors that occurred in linking.
+  # OutMessage must be disposed with LLVMDisposeMessage. The return value
+  # is true if an error occurred, false otherwise.
+  # 
+  # @method link_modules(dest, src, mode, out_message)
+  # @param [FFI::Pointer(ModuleRef)] dest 
+  # @param [FFI::Pointer(ModuleRef)] src 
+  # @param [Symbol from _enum_linker_mode_] mode 
+  # @param [FFI::Pointer(**CharS)] out_message 
+  # @return [Integer] 
+  # @scope class
+  attach_function :link_modules, :LLVMLinkModules, [:pointer, :pointer, :linker_mode, :pointer], :int
+  
+end

data/lib/llvm/support.rb

@@ -1,20 +1,46 @@
+require 'llvm/core_ffi'
+
 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-3.1.0')))
-      ffi_lib [support_lib]
+
+      OpaqueValue  = LLVM::C::OpaqueValue
+      OpaqueType   = LLVM::C::OpaqueType
+      OpaqueModule = LLVM::C::OpaqueModule
+
+      lib_name = FFI.map_library_name('RubyLLVMSupport-3.2')
+      lib_path = File.expand_path("../../ext/ruby-llvm-support/#{lib_name}", File.dirname(__FILE__))
+      ffi_lib [lib_path]
+
       attach_function :load_library_permanently, :LLVMLoadLibraryPermanently, [:string], :int
+      attach_function :has_unnamed_addr, :LLVMHasUnnamedAddr, [OpaqueValue], :int
+      attach_function :set_unnamed_addr, :LLVMSetUnnamedAddr, [OpaqueValue, :int], :void
+      attach_function :dump_type, :LLVMDumpType, [OpaqueType], :void
+      attach_function :print_module, :LLVMPrintModuleToFD, [OpaqueModule, :int, :int, :int], :void
+
+      attach_function :initialize_all_target_infos,
+          :LLVMInitializeAllTargetInfos, [], :void
+      attach_function :initialize_all_targets,
+          :LLVMInitializeAllTargets, [], :void
+      attach_function :initialize_all_target_mcs,
+          :LLVMInitializeAllTargetMCs, [], :void
+      attach_function :initialize_all_asm_printers,
+          :LLVMInitializeAllAsmPrinters, [], :void
+
+      attach_function :initialize_native_target,
+          :LLVMInitializeNativeTarget, [], :void
+      attach_function :initialize_native_target_asm_printer,
+          :LLVMInitializeNativeTargetAsmPrinter, [], :void
     end
   end
 
   def load_library(libname)
     Support::C.load_library_permanently(libname)
+
     nil
   end
 

data/lib/llvm/target.rb

@@ -3,5 +3,322 @@ require 'llvm/core'
 require 'llvm/target_ffi'
 
 module LLVM
-  # nothing here
+  # A shorthand for {LLVM::Target.init_native}
+  def self.init_jit
+    LLVM::Target.init_native
+  end
+
+  # @deprecated Use LLVM.init_jit or LLVM::Target.init('X86').
+  def self.init_x86
+    warn "LLVM.init_x86 is deprecated. Use LLVM.init_jit or LLVM::Target.init('X86')."
+    LLVM::Target.init('X86')
+  end
+
+  # You need to call {Target.init} for a target to be usable.
+  class Target
+    # Initializes target +target+; in particular, TargetInfo, Target and TargetMC.
+    #
+    # @param [String]      target      Target name in LLVM format, e.g. "X86", "ARM" or "PowerPC".
+    # @param [true, false] asm_printer Initialize corresponding AsmPrinter.
+    def self.init(target, asm_printer=false)
+      C.module_eval do
+        attach_function :"initialize_target_info_#{target}",
+            :"LLVMInitialize#{target}TargetInfo", [], :void
+        attach_function :"initialize_target_#{target}",
+            :"LLVMInitialize#{target}Target", [], :void
+        attach_function :"initialize_target_#{target}_mc",
+            :"LLVMInitialize#{target}TargetMC", [], :void
+
+        attach_function :"initialize_#{target}_asm_printer",
+            :"LLVMInitialize#{target}AsmPrinter", [], :void
+        attach_function :"initialize_#{target}_asm_parser",
+            :"LLVMInitialize#{target}AsmParser", [], :void
+        attach_function :"initialize_#{target}_disassembler",
+            :"LLVMInitialize#{target}Disassembler", [], :void
+      end
+
+      begin
+        %W(initialize_target_info_#{target}
+           initialize_target_#{target}
+           initialize_target_#{target}_mc).each do |init|
+          C.send init
+        end
+      rescue FFI::NotFoundError
+        raise ArgumentError, "LLVM target #{target} is not linked in. Try `llvm-config-3.2 --targets-built'."
+      end
+
+      begin
+        C.send :"initialize_#{target}_asm_printer" if asm_printer
+      rescue FFI::NotFoundError => e
+        raise ArgumentError, "LLVM target #{target} does not implement an ASM routime: #{e.message}"
+      end
+    end
+
+    # Initializes all available targets.
+    #
+    # @param [true, false] asm_printer Initialize corresponding AsmPrinters.
+    def self.init_all(asm_printer=false)
+      Support::C.initialize_all_target_infos
+      Support::C.initialize_all_targets
+      Support::C.initialize_all_target_mcs
+
+      Support::C.initialize_all_asm_printers if asm_printer
+    end
+
+    # Initializes native target. Useful for JIT applications.
+    #
+    # @param [true, false] asm_printer Initialize corresponding AsmPrinter.
+    def self.init_native(asm_printer=false)
+      Support::C.initialize_native_target
+
+      Support::C.initialize_native_target_asm_printer if asm_printer
+    end
+
+    # Enumerate all initialized targets.
+    #
+    # @yield [Target]
+    def self.each(&block)
+      return to_enum(:each) if block.nil?
+
+      target = C.get_first_target
+      until target.null?
+        yield from_ptr(target)
+
+        target = C.get_next_target(target)
+      end
+    end
+
+    # Fetch a target by its name.
+    #
+    # @return [Target]
+    def self.by_name(name)
+      each do |target|
+        return target if target.name == name
+      end
+    end
+
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # Returns the name of the target.
+    #
+    # @return [String]
+    def name
+      C.get_target_name(self)
+    end
+
+    # Returns the description of the target.
+    #
+    # @return [String]
+    def description
+      C.get_target_description(self)
+    end
+
+    # Returns if the target has a JIT.
+    def jit?
+      !C.target_has_jit(self).zero?
+    end
+
+    # Returns if the target has a TargetMachine associated.
+    def target_machine?
+      !C.target_has_target_machine(self).zero?
+    end
+
+    # Returns if the target has an ASM backend (required for emitting output).
+    def asm_backend?
+      !C.target_has_asm_backend(self).zero?
+    end
+
+    # Constructs a TargetMachine.
+    #
+    # @param  [String]        triple     Target triple
+    # @param  [String]        cpu        Target CPU
+    # @param  [String]        features   Target feature string
+    # @param  [Symbol]        opt_level  :none, :less, :default, :aggressive
+    # @param  [Symbol]        reloc      :default, :static, :pic, :dynamic_no_pic
+    # @param  [Symbol]        code_model :default, :jit_default, :small, :kernel, :medium, :large
+    # @return [TargetMachine]
+    def create_machine(triple, cpu="", features="",
+                       opt_level=:default, reloc=:default, code_model=:default)
+      TargetMachine.from_ptr(C.create_target_machine(self,
+            triple, cpu, features, opt_level, reloc, code_model))
+    end
+  end
+
+  class TargetMachine
+    include PointerIdentity
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # Destroys this instance of TargetMachine.
+    def dispose
+      return if @ptr.nil?
+
+      C.dispose_target_machine(self)
+      @ptr = nil
+    end
+
+    # Returns the corresponding Target.
+    #
+    # @return [Target]
+    def target
+      Target.from_ptr(C.get_target_machine_target(self))
+    end
+
+    # Returns the triple used for creating this target machine.
+    def triple
+      C.get_target_machine_triple(self)
+    end
+
+    # Returns the CPU used for creating this target machine.
+    def cpu
+      C.get_target_machine_cpu(self)
+    end
+
+    # Returns the feature string used for creating this target machine.
+    def features
+      C.get_target_machine_feature_string(self)
+    end
+
+    # Returns the data layout used for this target machine.
+    #
+    # @return [TargetDataLayout]
+    def data_layout
+      TargetDataLayout.from_ptr(C.get_target_machine_data(self))
+    end
+
+    # Emits an asm or object file for the given module.
+    #
+    # @param [Symbol] codegen :assembly, :object
+    def emit(mod, filename, codegen=:assembly)
+      LLVM.with_error_output do |err|
+        C.target_machine_emit_to_file(self, mod, filename.to_s, codegen, err)
+      end
+    end
+  end
+
+  # @private
+  module C
+    # ffi_gen autodetects :string, which is too weak to be usable
+    # with LLVMDisposeMessage
+    attach_function :copy_string_rep_of_target_data, :LLVMCopyStringRepOfTargetData, [OpaqueTargetData], :pointer
+  end
+
+  class TargetDataLayout
+    # Creates a target data layout from a string representation.
+    #
+    # @param [String] representation
+    def initialize(representation)
+      @ptr = C.create_target_data(representation.to_s)
+    end
+
+    # @private
+    def self.from_ptr(ptr)
+      target = allocate
+      target.instance_variable_set :@ptr, ptr
+      target
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Destroys this instance of TargetDataLayout.
+    def dispose
+      return if ptr.nil?
+
+      C.dispose_target_data(self)
+      @ptr = nil
+    end
+
+    # Returns string representation of target data layout.
+    #
+    # @return [String]
+    def to_s
+      string_ptr = C.copy_string_rep_of_target_data(self)
+      string = string_ptr.read_string
+      C.dispose_message(string_ptr)
+
+      string
+    end
+
+    # Returns the byte order of a target, either :big_endian or :little_endian.
+    def byte_order
+      C.byte_order(self)
+    end
+
+    # Returns the pointer size in bytes for a target.
+    #
+    # @param [Integer] addr_space address space number
+    def pointer_size(addr_space=0)
+      C.pointer_size_for_as(self, addr_space)
+    end
+
+    # Returns the integer type that is the same size as a pointer on a target.
+    #
+    # @param [Integer] addr_space address space number
+    def int_ptr_type(addr_space=0)
+      Type.from_ptr(C.int_ptr_type_for_as(self, addr_space), :integer)
+    end
+
+    # Computes the size of a type in bits for a target.
+    def bit_size_of(type)
+      C.size_of_type_in_bits(self, type)
+    end
+
+    # Computes the storage size of a type in bytes for a target.
+    def storage_size_of(type)
+      C.store_size_of_type(self, type)
+    end
+
+    # Computes the ABI size of a type in bytes for a target.
+    def abi_size_of(type)
+      C.abi_size_of_type(self, type)
+    end
+
+    # Computes the ABI alignment of a type in bytes for a target.
+    def abi_alignment_of(type)
+      C.abi_alignment_of_type(self, type)
+    end
+
+    # Computes the call frame alignment of a type in bytes for a target.
+    def call_frame_alignment_of(type)
+      C.call_frame_alignment_of_type(self, type)
+    end
+
+    # Computes the preferred alignment of a type or a global variable in bytes
+    # for a target.
+    #
+    # @param [LLVM::Type, LLVM::GlobalValue] entity
+    def preferred_alignment_of(entity)
+      case entity
+      when LLVM::Type
+        C.preferred_alignment_of_type(self, entity)
+      when LLVM::GlobalValue
+        C.preferred_alignment_of_global(self, entity)
+      end
+    end
+
+    # Computes the structure element that contains the byte offset for a target.
+    def element_at_offset(type, offset)
+      C.element_at_offset(self, type, offset)
+    end
+
+    # Computes the byte offset of the indexed struct element for a target.
+    def offset_of_element(type, element)
+      C.offset_of_element(self, type, element)
+    end
+  end
 end