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

data/LICENSE

@@ -0,0 +1,30 @@
+Copyright (c) 2010-2011 Jeremy Voorhis
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the author nor the names of his contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,49 @@
+Ruby-LLVM
+=========
+
+Ruby-LLVM is a Ruby language binding to the LLVM compiler infrastructure
+library. LLVM allows users to create just-in-time (JIT) compilers, ahead-of-time
+(AOT) compilers for multiple architectures, code analyzers and more. LLVM
+bindings can also be used to speed up Ruby code by compiling Ruby methods on the
+fly.
+
+Requirements
+------------
+* LLVM 3.2, including libLLVM-3.2 (compile LLVM with --enable-shared).
+* In order to ensure the usability of JIT features (i.e. create_jit_compiler), compile LLVM with --enable-jit as well.
+
+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 useful.
+
+Homebrew
+--------
+LLVM can be installed with Homebrew by executing `brew install llvm --shared`
+
+See Also
+--------
+* [The LLVM project](http://llvm.org)
+* [ffi-gen](https://github.com/neelance/ffi-gen) – Generate
+  [FFI](https://github.com/ffi/ffi) bindings with LLVM and Clang
+
+License
+-------
+Ruby-LLVM is available under the BSD 3-clause (see LICENSE), Copyright (c) 2010-2013 Jeremy Voorhis
+
+Ruby-LLVM is possible because of its contributors:
+
+* Evan Phoenix
+* David Holroyd
+* Takanori Ishikawa
+* Ronaldo M. Ferraz
+* Mac Malone
+* Chris Wailes
+* Ary Borenszweig
+* Richard Musiol
+* Juan Wajnerman
+* Steven Farlie
+* Peter Zotov

data/ext/ruby-llvm-support/Rakefile

@@ -2,12 +2,35 @@ require 'rake/clean'
 require 'rubygems'
 require 'ffi'
 
-CC = "g++"
-LLVM_CONFIG = `llvm-config --cxxflags --ldflags --libs all`.gsub("\n"," ")
-OUTPUT = FFI.map_library_name "RubyLLVMSupport-3.1.0"
-OUTPUT_DIR = "../../lib"
-SRC = "support.cpp"
-CLOBBER.include(OUTPUT)
+# Change this when updating for a newer LLVM.
+LLVM_VERSION = '3.2'
+
+def check_llvm_config(name)
+  actual_version = `#{name} --version`
+  actual_version.strip == LLVM_VERSION
+rescue Errno::ENOENT
+  false
+end
+
+def invoke_llvm_config(options)
+  variants = %W(llvm-config-#{LLVM_VERSION} llvm-config)
+
+  variants.each do |name|
+    if check_llvm_config(name)
+      return `#{name} #{options}`.gsub("\n", " ")
+    end
+  end
+
+  raise RuntimeError, "No valid llvm-config found. Tried: #{variants}"
+end
+
+LLVM_CONFIG = invoke_llvm_config('--cxxflags --ldflags')
+
+CXX    = "g++"
+SRC    = "support.cpp"
+OUTPUT = FFI.map_library_name("RubyLLVMSupport-#{LLVM_VERSION}")
+
+CLEAN.include(OUTPUT)
 
 task :default => [:build]
 
@@ -15,5 +38,5 @@ desc "Build the shared library"
 task :build => [OUTPUT]
 
 file OUTPUT => [SRC] do
-  sh "#{CC} -shared #{SRC} #{LLVM_CONFIG} -o #{OUTPUT_DIR}/#{OUTPUT}"
+  sh "#{CXX} -shared -lLLVM-#{LLVM_VERSION} #{SRC} #{LLVM_CONFIG} -o #{OUTPUT}"
 end

data/ext/ruby-llvm-support/support.cpp

@@ -2,12 +2,59 @@
  * Extended bindings for LLVM.
  */
 
-#include <llvm/ADT/StringRef.h>
+#include <llvm-c/Core.h>
+#include <llvm/Type.h>
+#include <llvm/GlobalValue.h>
 #include <llvm/Support/DynamicLibrary.h>
+#include <llvm/Support/TargetSelect.h>
+#include <llvm/Support/raw_ostream.h>
 
 extern "C" {
+  using namespace llvm;
+
   int LLVMLoadLibraryPermanently(const char* filename) {
     return llvm::sys::DynamicLibrary::LoadLibraryPermanently(filename);
   }
+
+  LLVMBool LLVMHasUnnamedAddr(LLVMValueRef global) {
+    return unwrap<GlobalValue>(global)->hasUnnamedAddr();
+  }
+
+  void LLVMSetUnnamedAddr(LLVMValueRef global, LLVMBool val) {
+    unwrap<GlobalValue>(global)->setUnnamedAddr(val != 0);
+  }
+
+  void LLVMDumpType(LLVMTypeRef type) {
+    unwrap<Type>(type)->dump();
+  }
+
+  int LLVMPrintModuleToFD(LLVMModuleRef module, int fd, LLVMBool shouldClose, LLVMBool unbuffered) {
+    raw_fd_ostream os(fd, shouldClose, unbuffered);
+    unwrap(module)->print(os, 0);
+  }
+
+  void LLVMInitializeAllTargetInfos() {
+    llvm::InitializeAllTargetInfos();
+  }
+
+  void LLVMInitializeAllTargets() {
+    llvm::InitializeAllTargets();
+  }
+
+  void LLVMInitializeAllTargetMCs() {
+    llvm::InitializeAllTargetMCs();
+  }
+
+  void LLVMInitializeAllAsmPrinters() {
+    llvm::InitializeAllAsmPrinters();
+  }
+
+  void LLVMInitializeNativeTarget() {
+    llvm::InitializeNativeTarget();
+  }
+
+  void LLVMInitializeNativeTargetAsmPrinter() {
+    llvm::InitializeNativeTargetAsmPrinter();
+  }
 }
 

data/lib/llvm.rb

@@ -1,12 +1,35 @@
 require 'rubygems'
 require 'ffi'
 
-require 'llvm/support'
-
 module LLVM
+  require 'llvm/support'
+
   # @private
   module C
     extend ::FFI::Library
-    ffi_lib ['LLVM-3.1']
+    ffi_lib ['LLVM-3.2']
+  end
+
+  module PointerIdentity
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Checks if the value is equal to other.
+    def ==(other)
+      other.respond_to?(:to_ptr) &&
+          @ptr == other.to_ptr
+    end
+
+    # Computes hash.
+    def hash
+      @ptr.address.hash
+    end
+
+    # Checks if the value is equivalent to other.
+    def eql?(other)
+      self == other
+    end
   end
 end

data/lib/llvm/analysis.rb

@@ -11,25 +11,22 @@ module LLVM
     def verify
       do_verification(:return_status)
     end
-    
+
     # Verify that a module is valid, and abort the process if not.
     # @return [nil]
     def verify!
       do_verification(:abort_process)
     end
-    
+
     private
-      def do_verification(action)
-        result = nil
-        FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |str|
-          status = C.verify_module(self, action, str)
-          result = str.read_string if status == 1
-          C.dispose_message str.read_pointer
-        end
-        result
+
+    def do_verification(action)
+      LLVM.with_message_output do |str|
+        C.verify_module(self, action, str)
       end
+    end
   end
-  
+
   class Function
     # Verify that a function is valid.
     # @return [true, false]

data/lib/llvm/analysis_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/core.rb

@@ -1,12 +1,47 @@
 require 'llvm'
 require 'llvm/core_ffi'
+require 'llvm/support'
 
 module LLVM
   # @private
   module C
     attach_function :dispose_message, :LLVMDisposeMessage, [:pointer], :void
   end
-  
+
+  # Yields a pointer suitable for storing an LLVM output message.
+  # If the message pointer is non-NULL (an error has happened), converts
+  # the result to a string and returns it. Otherwise, returns +nil+.
+  #
+  # @yield  [FFI::MemoryPointer]
+  # @return [String, nil]
+  def self.with_message_output
+    result = nil
+
+    FFI::MemoryPointer.new(FFI.type_size(:pointer)) do |str|
+      yield str
+
+      msg_ptr = str.read_pointer
+
+      unless msg_ptr.null?
+        result = msg_ptr.read_string
+        C.dispose_message msg_ptr
+      end
+    end
+
+    result
+  end
+
+  # Same as #with_message_output, but raises a RuntimeError with the
+  # resulting message.
+  #
+  # @yield  [FFI::MemoryPointer]
+  # @return [nil]
+  def self.with_error_output(&block)
+    error = with_message_output(&block)
+
+    raise RuntimeError, error unless error.nil?
+  end
+
   require 'llvm/core/context'
   require 'llvm/core/module'
   require 'llvm/core/type'

data/lib/llvm/core/bitcode_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/core/builder.rb

@@ -4,7 +4,7 @@ module LLVM
     def initialize
       @ptr = C.create_builder()
     end
-    
+
     def dispose
       return if @ptr.nil?
       C.dispose_builder(@ptr)
@@ -17,8 +17,9 @@ module LLVM
     end
 
     # Position the builder at the given Instruction within the given BasicBlock.
-    # @param [LLVM::BasicBlock]
-    # @param [LLVM::Instruction]
+    #
+    # @param  [LLVM::BasicBlock]  block
+    # @param  [LLVM::Instruction] instruction
     # @return [LLVM::Builder]
     def position(block, instruction)
       raise "Block must not be nil" if block.nil?
@@ -27,7 +28,8 @@ module LLVM
     end
 
     # Positions the builder before the given Instruction.
-    # @param [LLVM::Instruction]
+    #
+    # @param  [LLVM::Instruction] instruction
     # @return [LLVM::Builder]
     def position_before(instruction)
       raise "Instruction must not be nil" if instruction.nil?
@@ -36,7 +38,8 @@ module LLVM
     end
 
     # Positions the builder at the end of the given BasicBlock.
-    # @param [LLVM::BasicBlock]
+    #
+    # @param  [LLVM::BasicBlock] block
     # @return [LLVM::Builder]
     def position_at_end(block)
       raise "Block must not be nil" if block.nil?
@@ -45,6 +48,7 @@ module LLVM
     end
 
     # The BasicBlock at which the Builder is currently positioned.
+    #
     # @return [LLVM::BasicBlock]
     def insert_block
       BasicBlock.from_ptr(C.get_insert_block(self))
@@ -434,7 +438,7 @@ module LLVM
     end
 
     # Builds a inbounds getelementptr instruction. If the indices are outside
-    # the allocated pointer the value is undefined. 
+    # the allocated pointer the value is undefined.
     # @param [LLVM::Value] ptr A pointer to an aggregate value
     # @param [Array<LLVM::Value>] indices Ruby array of LLVM::Value representing
     #   indices into the aggregate
@@ -452,11 +456,12 @@ module LLVM
     end
 
     # Builds a struct getelementptr Instruction.
-    # @param [LLVM::Value] ptr A pointer to a structure
-    # @param [LLVM::Value] idx Unsigned integer representing the index of a
+    #
+    # @param  [LLVM::Value] pointer A pointer to a structure
+    # @param  [LLVM::Value] idx     Unsigned integer representing the index of a
     #   structure member
-    # @param [String] name The name of the result in LLVM IR
-    # @return [LLVM::Instruction] The resulting pointer
+    # @param  [String]      name    The name of the result in LLVM IR
+    # @return [LLVM::Instruction]   The resulting pointer
     # @LLVMinst gep
     # @see http://llvm.org/docs/GetElementPtr.html
     def struct_gep(pointer, idx, name = "")
@@ -484,7 +489,7 @@ module LLVM
     # @param [LLVM::Value] val Integer or vector of integers to be truncated
     # @param [LLVM::Type, #type] ty Integer or vector of integers of equal size
     #   to val
-    # @param [String] name The name of the result in LLVM IR 
+    # @param [String] name The name of the result in LLVM IR
     # @return [LLVM::Instruction] The truncated value
     # @LLVMinst trunc
     def trunc(val, ty, name = "")
@@ -496,7 +501,7 @@ module LLVM
     # @param [LLVM::Value] val Integer or vector of integers to be extended
     # @param [LLVM::Type, #type] ty Integer or vector of integer type of
     #   greater size than val
-    # @param [String] name The name of the result in LLVM IR 
+    # @param [String] name The name of the result in LLVM IR
     # @return [LLVM::Instruction] The extended value
     # @LLVMinst zext
     def zext(val, ty, name = "")
@@ -508,7 +513,7 @@ module LLVM
     # @param [LLVM::Value] val Integer or vector of integers to be extended
     # @param [LLVM::Type] ty Integer or vector of integer type of greater size
     #   than the size of val
-    # @param [String] name The name of the result in LLVM IR 
+    # @param [String] name The name of the result in LLVM IR
     # @return [LLVM::Instruction] The extended value
     # @LLVMinst sext
     def sext(val, ty, name = "")
@@ -741,7 +746,8 @@ module LLVM
 
     # Builds a call Instruction. Calls the given Function with the given
     # args (Instructions).
-    # @param [LLVM::Function] fun
+    #
+    # @param [LLVM::Function]     fun
     # @param [Array<LLVM::Value>] args
     # @param [LLVM::Instruction]
     # @LLVMinst call

data/lib/llvm/core/module.rb

@@ -1,5 +1,7 @@
-module LLVM  
+module LLVM
   class Module
+    include PointerIdentity
+
     # @private
     def self.from_ptr(ptr)
       return if ptr.null?
@@ -7,111 +9,113 @@ module LLVM
       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
-    
-    # @private
-    def to_ptr
-      @ptr
+
+    # Get module triple.
+    #
+    # @return [String]
+    def triple
+      C.get_target(self)
     end
-    
-    # Checks if the module is equal to other.
-    def ==(other)
-      case other
-      when LLVM::Module
-        @ptr == other.to_ptr
-      else
-        false
-      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
 
-    # Checks if the module is equal to other.
-    def eql?(other)
-      other.instance_of?(self.class) && self == other
+    # 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
-      
-      # 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
+
+      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))
+        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
@@ -126,7 +130,7 @@ module LLVM
           g
         end
       end
-      
+
       # Iterates through each GlobalVariable in the collection.
       def each
         g = first
@@ -136,19 +140,19 @@ module LLVM
         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
@@ -157,45 +161,45 @@ module LLVM
           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        
+
+        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
@@ -210,7 +214,7 @@ module LLVM
           f
         end
       end
-      
+
       # Iterates through each Function in the collection.
       def each
         f = first
@@ -220,10 +224,30 @@ module LLVM
         end
       end
     end
-    
-    # Print the module's IR to stdout.
-    def dump
-      C.dump_module(self)
+
+    # Print the module's IR to the given IO object or integer file descriptor.
+    #
+    # The IO object#fileno must not be nil. If fd_or_io is nil or omitted,
+    # dump the module to the output stream for debugging (stderr).
+    def dump(fd_or_io=nil)
+      if fd_or_io.nil?
+        C.dump_module(self)
+      else
+        fd = if fd_or_io.kind_of? ::Integer
+          fd_or_io
+        elsif fd_or_io.respond_to? :fileno
+          fd_or_io.fileno
+        end
+
+        raise ArgumentError, 'Expected IO object or Integer file descriptor' if fd.nil?
+        Support::C.print_module(
+          self,
+          fd,
+          0,  # should_close=false : not be closed automatically
+          0   # unbuffered=false   : buffered internally
+        )
+      end
     end
+
   end
 end