ruby-llvm 3.2.0.beta.1 → 3.3.0

data/lib/llvm/execution_engine_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.2'
+  ffi_lib 'LLVM-3.3'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -19,6 +19,13 @@ module LLVM::C
   # @scope class
   attach_function :link_in_jit, :LLVMLinkInJIT, [], :void
   
+  # (Not documented)
+  # 
+  # @method link_in_mcjit()
+  # @return [nil] 
+  # @scope class
+  attach_function :link_in_mcjit, :LLVMLinkInMCJIT, [], :void
+  
   # (Not documented)
   # 
   # @method link_in_interpreter()
@@ -36,6 +43,24 @@ module LLVM::C
     layout :dummy, :char
   end
   
+  # (Not documented)
+  # 
+  # = Fields:
+  # :opt_level ::
+  #   (Integer) 
+  # :code_model ::
+  #   (unknown) 
+  # :no_frame_pointer_elim ::
+  #   (Integer) 
+  # :enable_fast_i_sel ::
+  #   (Integer) 
+  class MCJITCompilerOptions < FFI::Struct
+    layout :opt_level, :uint,
+           :code_model, :char,
+           :no_frame_pointer_elim, :int,
+           :enable_fast_i_sel, :int
+  end
+  
   # ===-- Operations on generic values --------------------------------------===
   # 
   # @method create_generic_value_of_int(ty, n, is_signed)
@@ -136,6 +161,41 @@ module LLVM::C
   # @scope class
   attach_function :create_jit_compiler_for_module, :LLVMCreateJITCompilerForModule, [:pointer, :pointer, :uint, :pointer], :int
   
+  # (Not documented)
+  # 
+  # @method initialize_mcjit_compiler_options(options, size_of_options)
+  # @param [MCJITCompilerOptions] options 
+  # @param [Integer] size_of_options 
+  # @return [nil] 
+  # @scope class
+  attach_function :initialize_mcjit_compiler_options, :LLVMInitializeMCJITCompilerOptions, [MCJITCompilerOptions, :ulong], :void
+  
+  # Create an MCJIT execution engine for a module, with the given options. It is
+  # the responsibility of the caller to ensure that all fields in Options up to
+  # the given SizeOfOptions are initialized. It is correct to pass a smaller
+  # value of SizeOfOptions that omits some fields. The canonical way of using
+  # this is:
+  # 
+  # LLVMMCJITCompilerOptions options;
+  # LLVMInitializeMCJITCompilerOptions(&options, sizeof(options));
+  # ... fill in those options you care about
+  # LLVMCreateMCJITCompilerForModule(&jit, mod, &options, sizeof(options),
+  #                                  &error);
+  # 
+  # Note that this is also correct, though possibly suboptimal:
+  # 
+  # LLVMCreateMCJITCompilerForModule(&jit, mod, 0, 0, &error);
+  # 
+  # @method create_mcjit_compiler_for_module(out_jit, m, options, size_of_options, out_error)
+  # @param [FFI::Pointer(*ExecutionEngineRef)] out_jit 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [MCJITCompilerOptions] options 
+  # @param [Integer] size_of_options 
+  # @param [FFI::Pointer(**CharS)] out_error 
+  # @return [Integer] 
+  # @scope class
+  attach_function :create_mcjit_compiler_for_module, :LLVMCreateMCJITCompilerForModule, [:pointer, :pointer, MCJITCompilerOptions, :ulong, :pointer], :int
+  
   # Deprecated: Use LLVMCreateExecutionEngineForModule instead.
   # 
   # @method create_execution_engine(out_ee, mp, out_error)

data/lib/llvm/linker.rb

@@ -22,8 +22,6 @@ module LLVM
     # @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
 

data/lib/llvm/linker_ffi.rb

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

data/lib/llvm/support.rb

@@ -12,7 +12,7 @@ module LLVM
       OpaqueType   = LLVM::C::OpaqueType
       OpaqueModule = LLVM::C::OpaqueModule
 
-      lib_name = FFI.map_library_name('RubyLLVMSupport-3.2')
+      lib_name = FFI.map_library_name("RubyLLVMSupport-#{LLVM_VERSION}")
       lib_path = File.expand_path("../../ext/ruby-llvm-support/#{lib_name}", File.dirname(__FILE__))
       ffi_lib [lib_path]
 

data/lib/llvm/target.rb

@@ -44,7 +44,7 @@ module LLVM
           C.send init
         end
       rescue FFI::NotFoundError
-        raise ArgumentError, "LLVM target #{target} is not linked in. Try `llvm-config-3.2 --targets-built'."
+        raise ArgumentError, "LLVM target #{target} is not linked in. Try `llvm-config-#{LLVM_VERSION} --targets-built'."
       end
 
       begin

data/lib/llvm/target_ffi.rb

@@ -4,7 +4,7 @@ require 'ffi'
 
 module LLVM::C
   extend FFI::Library
-  ffi_lib 'LLVM-3.2'
+  ffi_lib 'LLVM-3.3'
   
   def self.attach_function(name, *_)
     begin; super; rescue FFI::NotFoundError => e
@@ -299,14 +299,7 @@ module LLVM::C
   attach_function :dispose_target_data, :LLVMDisposeTargetData, [OpaqueTargetData], :void
   
   # (Not documented)
-  module TargetMachineWrappers
-    def emit_to_file(m, filename, codegen, error_message)
-      LLVM::C.target_machine_emit_to_file(self, m, filename, codegen, error_message)
-    end
-  end
-  
-  class TargetMachine < FFI::Struct
-    include TargetMachineWrappers
+  class OpaqueTargetMachine < FFI::Struct
     layout :dummy, :char
   end
   
@@ -491,77 +484,89 @@ module LLVM::C
   # @param [Symbol from _enum_code_gen_opt_level_] level 
   # @param [Symbol from _enum_reloc_mode_] reloc 
   # @param [Symbol from _enum_code_model_] code_model 
-  # @return [TargetMachine] 
+  # @return [OpaqueTargetMachine] 
   # @scope class
-  attach_function :create_target_machine, :LLVMCreateTargetMachine, [Target, :string, :string, :string, :code_gen_opt_level, :reloc_mode, :code_model], TargetMachine
+  attach_function :create_target_machine, :LLVMCreateTargetMachine, [Target, :string, :string, :string, :code_gen_opt_level, :reloc_mode, :code_model], OpaqueTargetMachine
   
   # Dispose the LLVMTargetMachineRef instance generated by
   #   LLVMCreateTargetMachine.
   # 
   # @method dispose_target_machine(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [nil] 
   # @scope class
-  attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [TargetMachine], :void
+  attach_function :dispose_target_machine, :LLVMDisposeTargetMachine, [OpaqueTargetMachine], :void
   
   # Returns the Target used in a TargetMachine
   # 
   # @method get_target_machine_target(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [Target] 
   # @scope class
-  attach_function :get_target_machine_target, :LLVMGetTargetMachineTarget, [TargetMachine], Target
+  attach_function :get_target_machine_target, :LLVMGetTargetMachineTarget, [OpaqueTargetMachine], Target
   
   # Returns the triple used creating this target machine. See
   #   llvm::TargetMachine::getTriple. The result needs to be disposed with
   #   LLVMDisposeMessage.
   # 
   # @method get_target_machine_triple(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [String] 
   # @scope class
-  attach_function :get_target_machine_triple, :LLVMGetTargetMachineTriple, [TargetMachine], :string
+  attach_function :get_target_machine_triple, :LLVMGetTargetMachineTriple, [OpaqueTargetMachine], :string
   
   # Returns the cpu used creating this target machine. See
   #   llvm::TargetMachine::getCPU. The result needs to be disposed with
   #   LLVMDisposeMessage.
   # 
   # @method get_target_machine_cpu(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [String] 
   # @scope class
-  attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [TargetMachine], :string
+  attach_function :get_target_machine_cpu, :LLVMGetTargetMachineCPU, [OpaqueTargetMachine], :string
   
   # Returns the feature string used creating this target machine. See
   #   llvm::TargetMachine::getFeatureString. The result needs to be disposed with
   #   LLVMDisposeMessage.
   # 
   # @method get_target_machine_feature_string(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [String] 
   # @scope class
-  attach_function :get_target_machine_feature_string, :LLVMGetTargetMachineFeatureString, [TargetMachine], :string
+  attach_function :get_target_machine_feature_string, :LLVMGetTargetMachineFeatureString, [OpaqueTargetMachine], :string
   
   # Returns the llvm::DataLayout used for this llvm:TargetMachine.
   # 
   # @method get_target_machine_data(t)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @return [OpaqueTargetData] 
   # @scope class
-  attach_function :get_target_machine_data, :LLVMGetTargetMachineData, [TargetMachine], OpaqueTargetData
+  attach_function :get_target_machine_data, :LLVMGetTargetMachineData, [OpaqueTargetMachine], OpaqueTargetData
   
   # Emits an asm or object file for the given module to the filename. This
   #   wraps several c++ only classes (among them a file stream). Returns any
   #   error in ErrorMessage. Use LLVMDisposeMessage to dispose the message.
   # 
   # @method target_machine_emit_to_file(t, m, filename, codegen, error_message)
-  # @param [TargetMachine] t 
+  # @param [OpaqueTargetMachine] t 
   # @param [FFI::Pointer(ModuleRef)] m 
   # @param [String] filename 
   # @param [Symbol from _enum_code_gen_file_type_] codegen 
   # @param [FFI::Pointer(**CharS)] error_message 
   # @return [Integer] 
   # @scope class
-  attach_function :target_machine_emit_to_file, :LLVMTargetMachineEmitToFile, [TargetMachine, :pointer, :string, :code_gen_file_type, :pointer], :int
+  attach_function :target_machine_emit_to_file, :LLVMTargetMachineEmitToFile, [OpaqueTargetMachine, :pointer, :string, :code_gen_file_type, :pointer], :int
+  
+  # Compile the LLVM IR stored in \p M and store the result in \p OutMemBuf.
+  # 
+  # @method target_machine_emit_to_memory_buffer(t, m, codegen, error_message, out_mem_buf)
+  # @param [OpaqueTargetMachine] t 
+  # @param [FFI::Pointer(ModuleRef)] m 
+  # @param [Symbol from _enum_code_gen_file_type_] codegen 
+  # @param [FFI::Pointer(**CharS)] error_message 
+  # @param [FFI::Pointer(*MemoryBufferRef)] out_mem_buf 
+  # @return [Integer] 
+  # @scope class
+  attach_function :target_machine_emit_to_memory_buffer, :LLVMTargetMachineEmitToMemoryBuffer, [OpaqueTargetMachine, :pointer, :code_gen_file_type, :pointer, :pointer], :int
   
 end

data/lib/llvm/transforms/builder.rb

@@ -0,0 +1,102 @@
+require 'llvm'
+require 'llvm/core'
+require 'llvm/transforms/builder_ffi'
+
+module LLVM
+  class PassManagerBuilder
+    include PointerIdentity
+
+    attr_reader :size_level
+    attr_reader :opt_level
+    attr_reader :unit_at_a_time
+    attr_reader :unroll_loops
+    attr_reader :simplify_lib_calls
+    attr_reader :inliner_threshold
+
+    def initialize
+      @ptr = C.pass_manager_builder_create
+
+      @size_level         = 0
+      @opt_level          = 0
+      @unit_at_a_time     = false
+      @unroll_loops       = false
+      @simplify_lib_calls = false
+      @inliner_threshold  = 0
+    end
+
+    def dispose
+      return if @ptr.nil?
+
+      C.pass_manager_builder_dispose(@ptr)
+      @ptr = nil
+    end
+
+    # Specify the basic optimization level.
+    # @param [Integer] level 0 = -O0, 1 = -O1, 2 = -O2, 3 = -O3
+    def opt_level=(level)
+      @opt_level = level.to_i
+      C.pass_manager_builder_set_opt_level(self, @opt_level)
+    end
+
+    # How much we're optimizing for size.
+    # @param [Integer] level 0 = none, 1 = -Os, 2 = -Oz
+    def size_level=(level)
+      @size_level = level.to_i
+      C.pass_manager_builder_set_size_level(self, @size_level)
+    end
+
+    # @param [Boolean] do_unit_at_a_time
+    def unit_at_a_time=(do_unit_at_a_time)
+      @unit_at_a_time = do_unit_at_a_time
+      C.pass_manager_builder_set_disable_unit_at_a_time(self, flag(!@unit_at_a_time))
+    end
+
+    # @param [Boolean] do_unroll
+    def unroll_loops=(do_unroll)
+      @unroll_loops = do_unroll
+      C.pass_manager_builder_set_disable_unroll_loops(self, flag(!@unroll_loops))
+    end
+
+    # @param [Boolean] do_simplify_lib_calls
+    def simplify_lib_calls=(do_simplify_lib_calls)
+      @simplify_lib_calls = do_simplify_lib_calls
+      C.pass_manager_builder_set_disable_simplify_lib_calls(self, flag(!@simplify_lib_calls))
+    end
+
+    # @param [Integer] threshold 0 = -O1, 225 = -O2, 275 = -O3
+    def inliner_threshold=(threshold)
+      @inliner_threshold = threshold
+      C.pass_manager_builder_use_inliner_with_threshold(self, @inliner_threshold)
+    end
+
+    # Populate a pass manager.
+    # @param [PassManager, FunctionPassManager] pass_manager
+    def build(pass_manager)
+      case pass_manager
+      when FunctionPassManager
+        C.pass_manager_builder_populate_function_pass_manager(self, pass_manager)
+
+      when PassManager
+        C.pass_manager_builder_populate_module_pass_manager(self, pass_manager)
+      end
+    end
+
+    # Populate an LTO pass manager.
+    # @param [PassManager] pass_manager
+    def build_with_lto(pass_manager, internalize=false, run_inliner=false)
+      if pass_manager.is_a?(FunctionPassManager)
+        raise ArgumentError, "FunctionPassManager does not support LTO"
+      end
+
+      # Add flag() when the header gets fixed and has LLVMBool
+      C.pass_manager_builder_populate_lto_pass_manager(self,
+            pass_manager, internalize, run_inliner)
+    end
+
+    private
+
+    def flag(boolean)
+      boolean ? 1 : 0
+    end
+  end
+end

data/lib/llvm/transforms/builder_ffi.rb

@@ -0,0 +1,118 @@
+# Generated by ffi_gen. Please do not change this file by hand.
+
+require 'ffi'
+
+module LLVM::C
+  extend FFI::Library
+  ffi_lib 'LLVM-3.3'
+  
+  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)
+  class OpaquePassManagerBuilder < FFI::Struct
+    layout :dummy, :char
+  end
+  
+  # See llvm::PassManagerBuilder.
+  # 
+  # @method pass_manager_builder_create()
+  # @return [OpaquePassManagerBuilder] 
+  # @scope class
+  attach_function :pass_manager_builder_create, :LLVMPassManagerBuilderCreate, [], OpaquePassManagerBuilder
+  
+  # (Not documented)
+  # 
+  # @method pass_manager_builder_dispose(pmb)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_dispose, :LLVMPassManagerBuilderDispose, [OpaquePassManagerBuilder], :void
+  
+  # See llvm::PassManagerBuilder::OptLevel.
+  # 
+  # @method pass_manager_builder_set_opt_level(pmb, opt_level)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] opt_level 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_opt_level, :LLVMPassManagerBuilderSetOptLevel, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::SizeLevel.
+  # 
+  # @method pass_manager_builder_set_size_level(pmb, size_level)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] size_level 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_size_level, :LLVMPassManagerBuilderSetSizeLevel, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::DisableUnitAtATime.
+  # 
+  # @method pass_manager_builder_set_disable_unit_at_a_time(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_unit_at_a_time, :LLVMPassManagerBuilderSetDisableUnitAtATime, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::DisableUnrollLoops.
+  # 
+  # @method pass_manager_builder_set_disable_unroll_loops(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_unroll_loops, :LLVMPassManagerBuilderSetDisableUnrollLoops, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::DisableSimplifyLibCalls
+  # 
+  # @method pass_manager_builder_set_disable_simplify_lib_calls(pmb, value)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] value 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_set_disable_simplify_lib_calls, :LLVMPassManagerBuilderSetDisableSimplifyLibCalls, [OpaquePassManagerBuilder, :int], :void
+  
+  # See llvm::PassManagerBuilder::Inliner.
+  # 
+  # @method pass_manager_builder_use_inliner_with_threshold(pmb, threshold)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [Integer] threshold 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_use_inliner_with_threshold, :LLVMPassManagerBuilderUseInlinerWithThreshold, [OpaquePassManagerBuilder, :uint], :void
+  
+  # See llvm::PassManagerBuilder::populateFunctionPassManager.
+  # 
+  # @method pass_manager_builder_populate_function_pass_manager(pmb, pm)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [FFI::Pointer(PassManagerRef)] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_function_pass_manager, :LLVMPassManagerBuilderPopulateFunctionPassManager, [OpaquePassManagerBuilder, :pointer], :void
+  
+  # See llvm::PassManagerBuilder::populateModulePassManager.
+  # 
+  # @method pass_manager_builder_populate_module_pass_manager(pmb, pm)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [FFI::Pointer(PassManagerRef)] pm 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_module_pass_manager, :LLVMPassManagerBuilderPopulateModulePassManager, [OpaquePassManagerBuilder, :pointer], :void
+  
+  # See llvm::PassManagerBuilder::populateLTOPassManager.
+  # 
+  # @method pass_manager_builder_populate_lto_pass_manager(pmb, pm, internalize, run_inliner)
+  # @param [OpaquePassManagerBuilder] pmb 
+  # @param [FFI::Pointer(PassManagerRef)] pm 
+  # @param [Integer] internalize 
+  # @param [Integer] run_inliner 
+  # @return [nil] 
+  # @scope class
+  attach_function :pass_manager_builder_populate_lto_pass_manager, :LLVMPassManagerBuilderPopulateLTOPassManager, [OpaquePassManagerBuilder, :pointer, :int, :int], :void
+  
+end