ruby-llvm 2.9.1 → 2.9.3

data/test/ipo_test.rb

@@ -0,0 +1,53 @@
+require "test_helper"
+require "llvm/core"
+require 'llvm/transforms/ipo'
+require 'llvm/core/pass_manager'
+
+class IPOTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_gdce
+    mod = LLVM::Module.new('test')
+
+    fn1 = mod.functions.add("fn1", [], LLVM.Void) do |fn|
+      fn.linkage = :internal
+      fn.basic_blocks.append.build do |builder|
+        builder.ret_void
+      end
+    end
+
+    fn2 = mod.functions.add("fn2", [], LLVM.Void) do |fn|
+      fn.linkage = :internal
+      fn.basic_blocks.append.build do |builder|
+        builder.ret_void
+      end
+    end
+
+    main = mod.functions.add("main", [], LLVM.Void) do |fn|
+      fn.basic_blocks.append.build do |builder|
+        builder.call(fn1)
+        builder.ret_void
+      end
+    end
+
+    fns = mod.functions.to_a
+    assert fns.include?(fn1)
+    assert fns.include?(fn2)
+    assert fns.include?(main)
+
+    # optimize
+    engine = LLVM::JITCompiler.new(mod)
+    passm  = LLVM::PassManager.new(engine)
+
+    passm.gdce!
+    passm.run(mod)
+
+    fns = mod.functions.to_a
+    assert fns.include?(fn1)
+    assert !fns.include?(fn2), 'fn2 should be eliminated'
+    assert fns.include?(main)
+  end
+end

data/test/memory_access_test.rb

@@ -0,0 +1,38 @@
+require "test_helper"
+
+class MemoryAccessTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_memory_access
+    assert_equal 1 + 2, simple_memory_access_function(1, 2).to_i
+    assert_equal 3 + 4, array_memory_access_function(3, 4).to_i
+  end
+
+  def simple_memory_access_function(value1, value2)
+    run_function([LLVM::Int, LLVM::Int], [value1, value2], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer1 = builder.alloca(LLVM::Int)
+      pointer2 = builder.alloca(LLVM::Int)
+      builder.store(arguments.first, pointer1)
+      builder.store(arguments.last, pointer2)
+      builder.ret(builder.add(builder.load(pointer1), builder.load(pointer2)))
+    end
+  end
+
+  def array_memory_access_function(value1, value2)
+    run_function([LLVM::Int, LLVM::Int], [value1, value2], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer = builder.array_alloca(LLVM::Int, LLVM::Int(2))
+      builder.store(arguments.first, builder.gep(pointer, [LLVM::Int(0)]))
+      builder.store(arguments.last, builder.gep(pointer, [LLVM::Int(1)]))
+      builder.ret(builder.add(builder.load(builder.gep(pointer, [LLVM::Int(0)])),
+                              builder.load(builder.gep(pointer, [LLVM::Int(1)]))))
+    end
+  end
+
+end

data/test/module_test.rb

@@ -0,0 +1,21 @@
+require "test_helper"
+
+class ModuleTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_simple_module
+    assert_equal 1, simple_function().to_i
+  end
+
+  def simple_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(LLVM::Int(1))
+    end
+  end
+
+end

data/test/parameter_collection_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+class ParameterCollectionTestCase < Test::Unit::TestCase
+  def setup
+    @mod = LLVM::Module.new('test')
+    @fun = @mod.functions.add('fun', [LLVM::Int, LLVM::Int], LLVM::Int)
+    @fun.params[0].name = 'foo'
+    @fun.params[1].name = 'bar'
+  end
+
+  def test_positive_index_in_range
+    assert_equal 'foo', @fun.params[0].name
+    assert_equal 'bar', @fun.params[1].name
+  end
+
+  def test_negative_index_in_range
+    assert_equal 'foo', @fun.params[-2].name
+    assert_equal 'bar', @fun.params[-1].name
+  end
+
+  def test_positive_index_out_of_range
+    assert_nil @fun.params[2]
+  end
+
+  def test_negative_index_out_of_range
+    assert_nil @fun.params[-3]
+  end
+end

data/test/phi_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class PhiTest < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_phi
+    assert_equal 1, run_phi_function(0).to_i
+    assert_equal 0, run_phi_function(1).to_i
+  end
+
+  def run_phi_function(argument)
+    run_function([LLVM::Int], argument, LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      block1 = function.basic_blocks.append
+      block2 = function.basic_blocks.append
+      exit = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.cond(builder.icmp(:eq, arguments.first, LLVM::Int(0)), block1, block2)
+      builder.position_at_end(block1)
+      result1 = builder.add(arguments.first, LLVM::Int(1))
+      builder.br(exit)
+      builder.position_at_end(block2)
+      result2 = builder.sub(arguments.first, LLVM::Int(1))
+      builder.br(exit)
+      builder.position_at_end(exit)
+      builder.ret(builder.phi(LLVM::Int,
+                              block1 => result1,
+                              block2 => result2))
+    end
+  end
+end

data/test/select_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class SelectTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_select
+    assert_equal 0, select_function(1).to_i
+    assert_equal 1, select_function(0).to_i
+  end
+
+  def select_function(value)
+    run_function([LLVM::Int1], [value], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.select(arguments.first, LLVM::Int(0), LLVM::Int(1)))
+    end
+  end
+
+end

data/test/struct_test.rb

@@ -0,0 +1,75 @@
+require "test_helper"
+
+class StructTestCase < Test::Unit::TestCase
+
+  LLVM_UNPACKED = false
+  LLVM_PACKED = true
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_simple_struct
+    struct = LLVM::Struct(LLVM::Int, LLVM::Float)
+    assert_instance_of LLVM::Type, struct
+  end
+
+  def test_unpacked_constant_struct_from_size
+    struct = LLVM::ConstantStruct.const(2, LLVM_UNPACKED) { |i| LLVM::Int(i) }
+    assert_instance_of LLVM::ConstantStruct, struct
+    assert_equal 2, struct.operands.size
+  end
+
+  def test_unpacked_constant_struct_from_struct
+    struct = LLVM::ConstantStruct.const([LLVM::Int(0), LLVM::Int(1)], LLVM_UNPACKED)
+    assert_instance_of LLVM::ConstantStruct, struct
+    assert_equal 2, struct.operands.size
+  end
+
+  def test_packed_constant_struct_from_size
+    struct = LLVM::ConstantStruct.const(2, LLVM_PACKED) { |i| LLVM::Int(i) }
+    assert_instance_of LLVM::ConstantStruct, struct
+    assert_equal 2, struct.operands.size
+  end
+
+  def test_packed_constant_struct_from_struct
+    struct = LLVM::ConstantStruct.const([LLVM::Int(0), LLVM::Int(1)], LLVM_PACKED)
+    assert_instance_of LLVM::ConstantStruct, struct
+    assert_equal 2, struct.operands.size
+  end
+
+  def test_struct_values
+    assert_equal 2 + 3, run_struct_values(2, 3).to_i
+  end
+
+  def test_struct_access
+    assert_in_delta 2 + 3.3, run_struct_access(LLVM::Float, 2, 3.3).to_f, 0.001
+  end
+
+  def run_struct_values(value1, value2)
+    run_function([LLVM::Int, LLVM::Int], [value1, value2], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer = builder.alloca(LLVM::Struct(LLVM::Int, LLVM::Int))
+      struct = builder.load(pointer)
+      struct = builder.insert_value(struct, arguments.first, 0)
+      struct = builder.insert_value(struct, arguments.last, 1)
+      builder.ret(builder.add(builder.extract_value(struct, 0),
+                              builder.extract_value(struct, 1)))
+    end
+  end
+
+  def run_struct_access(return_type, value1, value2)
+    run_function([LLVM::Int, LLVM::Float], [value1, value2], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer = builder.alloca(LLVM::Struct(LLVM::Float, LLVM::Struct(LLVM::Int, LLVM::Float), LLVM::Int))
+      builder.store(arguments.first, builder.gep(pointer, [LLVM::Int(0), LLVM::Int32.from_i(1), LLVM::Int32.from_i(0)]))
+      builder.store(arguments.last, builder.gep(pointer, [LLVM::Int(0), LLVM::Int32.from_i(1), LLVM::Int32.from_i(1)]))
+      address1 = builder.gep(pointer, [LLVM::Int(0), LLVM::Int32.from_i(1), LLVM::Int32.from_i(0)])
+      address2 = builder.gep(pointer, [LLVM::Int(0), LLVM::Int32.from_i(1), LLVM::Int32.from_i(1)])
+      builder.ret(builder.fadd(builder.ui2fp(builder.load(address1), LLVM::Float), builder.load(address2)))
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,50 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+begin
+  require "ruby-debug"
+rescue LoadError
+  # Ignore ruby-debug is case it's not installed
+end
+
+require "test/unit"
+
+require "llvm/core"
+require "llvm/execution_engine"
+require "llvm/transforms/scalar"
+
+class Test::Unit::TestCase
+
+  LLVM_SIGNED = true
+  LLVM_UNSIGNED = false
+
+  LLVM_FALSE = 0
+  LLVM_TRUE = 1
+
+end
+
+def define_module(module_name)
+  new_module = LLVM::Module.new(module_name)
+  yield new_module
+  new_module.verify
+  new_module
+end
+
+def define_function(host_module, function_name, argument_types, return_type)
+  host_module.functions.add(function_name, argument_types, return_type) do |function, *arguments|
+    yield(LLVM::Builder.new, function, *arguments)
+  end
+end
+
+def run_function_on_module(host_module, function_name, *argument_values)
+  LLVM::JITCompiler.new(host_module).
+    run_function(host_module.functions[function_name], *argument_values)
+end
+
+def run_function(argument_types, argument_values, return_type, &block)
+  test_module = define_module("test_module") do |host_module|
+    define_function(host_module, "test_function", argument_types, return_type, &block)
+  end
+
+  run_function_on_module(test_module, "test_function", *argument_values)
+end
+

data/test/type_test.rb

@@ -0,0 +1,15 @@
+require "test_helper"
+
+class TypeTestCase < Test::Unit::TestCase
+
+  def test_element_type
+    pointer = LLVM.Pointer(LLVM::Int32.type)  
+    pointee = pointer.element_type
+
+    assert_equal :pointer, pointer.kind
+    assert_equal :integer, pointee.kind
+
+    assert_nil pointee.element_type
+  end
+
+end

data/test/vector_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class VectorTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_all_ones_vector
+    assert_raise(NotImplementedError) do
+      LLVM::ConstantVector.all_ones
+    end
+  end
+
+  def test_constant_vector_from_size
+    vector = LLVM::ConstantVector.const(2) { |i| LLVM::Int(i) }
+    assert_instance_of LLVM::ConstantVector, vector
+    assert_equal 2, vector.operands.size
+  end
+
+  def test_constant_vector_from_array
+    vector = LLVM::ConstantVector.const([LLVM::Int(0), LLVM::Int(1)])
+    assert_instance_of LLVM::ConstantVector, vector
+    assert_equal 2, vector.operands.size
+  end
+
+  def test_vector_elements
+    assert_equal 2 + 3, run_vector_elements(2, 3).to_i
+  end
+
+  def test_vector_shuffle
+    assert_equal 1 + 4, run_vector_shuffle(1, 2, 3, 4).to_i
+  end
+
+  def run_vector_elements(value1, value2)
+    run_function([LLVM::Int, LLVM::Int], [value1, value2], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      pointer = builder.alloca(LLVM::Vector(LLVM::Int, 2))
+      vector = builder.load(pointer)
+      vector = builder.insert_element(vector, arguments.first, LLVM::Int32.from_i(0))
+      vector = builder.insert_element(vector, arguments.last, LLVM::Int32.from_i(1))
+      builder.ret(builder.add(builder.extract_element(vector, LLVM::Int32.from_i(0)),
+                              builder.extract_element(vector, LLVM::Int32.from_i(1))))
+    end
+  end
+
+  def run_vector_shuffle(*values)
+    run_function([LLVM::Int, LLVM::Int, LLVM::Int, LLVM::Int], values, LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      vector1 = builder.load(builder.alloca(LLVM::Vector(LLVM::Int, 2)))
+      vector1 = builder.insert_element(vector1, arguments[0], LLVM::Int32.from_i(0))
+      vector1 = builder.insert_element(vector1, arguments[1], LLVM::Int32.from_i(1))
+      vector2 = builder.load(builder.alloca(LLVM::Vector(LLVM::Int, 2)))
+      vector2 = builder.insert_element(vector2, arguments[2], LLVM::Int32.from_i(0))
+      vector2 = builder.insert_element(vector2, arguments[3], LLVM::Int32.from_i(1))
+      vector3 = builder.shuffle_vector(vector1, vector2, LLVM::ConstantVector.const([LLVM::Int(0), LLVM::Int(3)]))
+      builder.ret(builder.add(builder.extract_element(vector3, LLVM::Int32.from_i(0)),
+                              builder.extract_element(vector3, LLVM::Int32.from_i(1))))
+    end
+  end
+
+end

metadata

@@ -1,39 +1,70 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ruby-llvm
-version: !ruby/object:Gem::Version 
+version: !ruby/object:Gem::Version
+  version: 2.9.3
   prerelease: 
-  version: 2.9.1
 platform: ruby
-authors: 
+authors:
 - Jeremy Voorhis
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-04-23 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2011-12-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: ffi
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70109058811900 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
-  version_requirements: *id001
-description: 
+  prerelease: false
+  version_requirements: *70109058811900
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70109058811480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70109058811480
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70109058811000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70109058811000
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70109058810580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70109058810580
+description: LLVM bindings for Ruby
 email: jvoorhis@gmail.com
 executables: []
-
-extensions: []
-
-extra_rdoc_files: 
+extensions:
+- ext/ruby-llvm-support/Rakefile
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - lib/llvm/analysis.rb
+- lib/llvm/core/bitcode.rb
 - lib/llvm/core/builder.rb
 - lib/llvm/core/context.rb
 - lib/llvm/core/module.rb
@@ -42,38 +73,84 @@ files:
 - lib/llvm/core/value.rb
 - lib/llvm/core.rb
 - lib/llvm/execution_engine.rb
+- lib/llvm/support.rb
 - lib/llvm/target.rb
 - lib/llvm/transforms/ipo.rb
 - lib/llvm/transforms/scalar.rb
+- lib/llvm/version.rb
 - lib/llvm.rb
+- ext/ruby-llvm-support/Rakefile
+- ext/ruby-llvm-support/support.cpp
 - README.rdoc
-has_rdoc: true
+- test/array_test.rb
+- test/basic_block_test.rb
+- test/basic_test.rb
+- test/binary_operations_test.rb
+- test/bitcode_test.rb
+- test/branch_test.rb
+- test/call_test.rb
+- test/comparisons_test.rb
+- test/conversions_test.rb
+- test/double_test.rb
+- test/equality_test.rb
+- test/generic_value_test.rb
+- test/instruction_test.rb
+- test/ipo_test.rb
+- test/memory_access_test.rb
+- test/module_test.rb
+- test/parameter_collection_test.rb
+- test/phi_test.rb
+- test/select_test.rb
+- test/struct_test.rb
+- test/test_helper.rb
+- test/type_test.rb
+- test/vector_test.rb
 homepage: http://github.com/jvoorhis/ruby-llvm
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.6.0
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: LLVM bindings for Ruby
-test_files: []
-
+test_files:
+- test/array_test.rb
+- test/basic_block_test.rb
+- test/basic_test.rb
+- test/binary_operations_test.rb
+- test/bitcode_test.rb
+- test/branch_test.rb
+- test/call_test.rb
+- test/comparisons_test.rb
+- test/conversions_test.rb
+- test/double_test.rb
+- test/equality_test.rb
+- test/generic_value_test.rb
+- test/instruction_test.rb
+- test/ipo_test.rb
+- test/memory_access_test.rb
+- test/module_test.rb
+- test/parameter_collection_test.rb
+- test/phi_test.rb
+- test/select_test.rb
+- test/struct_test.rb
+- test/test_helper.rb
+- test/type_test.rb
+- test/vector_test.rb
+has_rdoc: true