ruby-llvm 2.9.1 → 2.9.3

data/README.rdoc

@@ -1,7 +1,7 @@
 = LLVM
 
 Author:: Jeremy Voorhis
-Contributors:: Evan Phoenix, David Holroyd, Takanori Ishikawa, Ronaldo M. Ferraz, Mac Malone
+Contributors:: Evan Phoenix, David Holroyd, Takanori Ishikawa, Ronaldo M. Ferraz, Mac Malone, Chris Wailes, Ary Borenszweig
 Copyright:: Copyright (c) 2010-2011 Jeremy Voorhis
 License:: BSD 3-clause (see LICENSE)
 
@@ -13,7 +13,8 @@ implementations.
 ruby-llvm has been tested on Mac OS X 10.6 using the following Ruby interpreters:
 
 * MRI 1.8.7-p174
-* MRI 1.9.2-p180
+* MRI 1.9.2-p290
+* MRI 1.9.3-preview1
 * JRuby 1.4.0
 
 If using MRI, ffi >= 1.0.7 is recommended (only ffi >= 1.0.0 is required).

data/ext/ruby-llvm-support/Rakefile

@@ -0,0 +1,18 @@
+require 'rake/clean'
+require 'ffi'
+
+CC = "g++"
+LLVM_CONFIG = `llvm-config --cxxflags --ldflags --libs all`.gsub("\n"," ")
+OUTPUT = FFI.map_library_name "RubyLLVMSupport-2.9.2"
+OUTPUT_DIR = "../../lib"
+SRC = "support.cpp"
+CLOBBER.include(OUTPUT)
+
+task :default => [:build]
+
+desc "Build the shared library"
+task :build => [OUTPUT]
+
+file OUTPUT => [SRC] do
+  sh "#{CC} -shared #{SRC} #{LLVM_CONFIG} -o #{OUTPUT_DIR}/#{OUTPUT}"
+end

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

@@ -0,0 +1,12 @@
+/*
+ * Extended bindings for LLVM.
+ */
+
+#include <llvm/Support/DynamicLibrary.h>
+
+extern "C" {
+  int LLVMLoadLibraryPermanently(const char* filename) {
+    return llvm::sys::DynamicLibrary::LoadLibraryPermanently(filename);
+  }
+}
+

data/lib/llvm/analysis.rb

@@ -16,10 +16,15 @@ module LLVM
   end
   
   class Module
+    # Verify that the module is valid.
+    # @return [nil, String] human-readable description of any invalid
+    #   constructs if invalid.
     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
@@ -29,14 +34,28 @@ module LLVM
         str = FFI::MemoryPointer.new(FFI.type_size(:pointer))
         status = C.LLVMVerifyModule(self, action, str)
         case status
-          when 1 then str.read_string
-          else nil
+        when 1 then str.read_string
+        else nil
         end
       end
   end
   
   class Function
-    def verify(action = :abort_process)
+    # Verify that a function is valid.
+    # @return [true, false]
+    def verify
+      do_verification(:return_status)
+    end
+
+    # Verify that a function is valid, and abort the process if not.
+    # @return [true, false]
+    def verify!
+      do_verification(:abort_process)
+    end
+
+    private
+
+    def do_verification(action)
       C.LLVMVerifyFunction(self, action) != 0
     end
   end

data/lib/llvm/core/bitcode.rb

@@ -0,0 +1,88 @@
+module LLVM
+  # @private
+  module C
+    attach_function :LLVMParseBitcode, [:pointer, :buffer_out, :buffer_out], :int
+    attach_function :LLVMParseBitcodeInContext, [:pointer, :pointer, :buffer_out, :buffer_out], :int
+    attach_function :LLVMWriteBitcodeToFile, [:pointer, :string], :int
+    attach_function :LLVMWriteBitcodeToFD, [:pointer, :int, :int, :int], :int
+  end
+
+  class Module
+    # Parse a module from a memory buffer
+    # @param [String, LLVM::MemoryBuffer] path_or_memory_buffer
+    # @return [LLVM::Module]
+    def self.parse_bitcode(path_or_memory_buffer)
+      memory_buffer = case path_or_memory_buffer
+                      when MemoryBuffer then path_or_memory_buffer
+                      else MemoryBuffer.from_file(path_or_memory_buffer)
+                      end
+      FFI::MemoryPointer.new(:pointer) do |mod_ref|
+        FFI::MemoryPointer.new(:pointer) do |msg_ref|
+          status = C.LLVMParseBitcode(memory_buffer, mod_ref, msg_ref)
+          raise msg_ref.get_pointer(0).get_string(0) if status != 0
+          return from_ptr(mod_ref.get_pointer(0))
+        end
+      end
+    end
+
+    # Write bitcode to the given path, IO object or file descriptor
+    # @param [String, IO, Integer] path_or_io Pathname, IO object or file descriptor
+    # @return [true, false] Success
+    def write_bitcode(path_or_io)
+      status = if path_or_io.respond_to?(:path)
+                 C.LLVMWriteBitcodeToFile(self, path_or_io.path)
+               elsif path_or_io.respond_to?(:fileno)
+                 C.LLVMWriteBitcodeToFD(self, path_or_io.fileno, 0, 1)
+               elsif path_or_io.kind_of?(Integer)
+                 C.LLVMWriteBitcodeToFD(self, path_or_io, 0, 1)
+               else
+                 C.LLVMWriteBitcodeToFile(self, path_or_io.to_str)
+               end
+      return status == 0
+    end
+  end
+
+  # @private
+  class MemoryBuffer
+    private_class_method :new
+
+    # @private
+    def initialize(ptr)
+      @ptr = ptr
+    end
+
+    # @private
+    def to_ptr
+      @ptr
+    end
+
+    # Read the contents of a file into a memory buffer
+    # @param [String] path
+    # @return [LLVM::MemoryBuffer]
+    def self.from_file(path)
+      FFI::MemoryPointer.new(:pointer) do |buf_ref|
+        FFI::MemoryPointer.new(:pointer) do |msg_ref|
+          status = C.LLVMCreateMemoryBufferWithContentsOfFile(path.to_str, buf_ref, msg_ref)
+          raise msg_ref.get_pointer(0).get_string(0) if status != 0
+          return new(buf_ref.get_pointer(0))
+        end
+      end
+    end
+
+    # Read STDIN into a memory buffer
+    # @return [LLVM::MemoryBuffer]
+    def self.from_stdin
+      FFI::Buffer.new(:pointer) do |buf_ref|
+        FFI::Buffer.new(:pointer) do |msg_ref|
+          status = C.LLVMCreateMemoryBufferWithSTDIN(buf_ref, msg_ref)
+          raise msg_ref.get_pointer(0).get_string(0) if status != 0
+          return new(buf_ref.get_pointer(0))
+        end
+      end
+    end
+
+    def dispose
+      C.LLVMDisposeMemoryBuffer(@ptr)
+    end
+  end
+end