waj-ruby-llvm 2.9.2

data/test/generic_value_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class GenericValueTestCase < Test::Unit::TestCase
+
+  def setup
+    LLVM.init_x86
+  end
+
+  def test_from_i
+    assert_equal 2, LLVM::GenericValue.from_i(2).to_i
+    assert_equal 2 ,LLVM::GenericValue.from_i(2.2).to_i
+  end
+
+  def test_from_float
+    assert_in_delta 2.2, LLVM::GenericValue.from_f(2.2).to_f, 1e-6
+  end
+
+  def test_from_double
+    assert_in_delta 2.2, LLVM::GenericValue.from_d(2.2).to_f(LLVM::Double), 1e-6
+  end
+
+end

data/test/instruction_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+class InstructionTestCase < Test::Unit::TestCase
+  def setup
+    LLVM.init_x86
+    @module = LLVM::Module.new("InstructionTestCase")
+  end
+
+  def test_instruction
+    fn = @module.functions.add("test_instruction", [LLVM::Double], LLVM::Double) do |fn, arg|
+      fn.basic_blocks.append.build do |builder|
+        builder.ret(
+          builder.fadd(arg, LLVM.Double(3.0)))
+      end
+    end
+
+    entry = fn.basic_blocks.entry
+
+    inst1 = entry.instructions.first
+    inst2 = entry.instructions.last
+
+    assert_kind_of LLVM::Instruction, inst1
+    assert_kind_of LLVM::Instruction, inst2
+
+    assert_equal inst2, inst1.next
+    assert_equal inst1, inst2.previous
+    assert_equal entry, inst1.parent
+    assert_equal entry, inst2.parent
+  end
+end
+
+

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