ruby-llvm-next 10.0.0

data/test/basic_block_test.rb

@@ -0,0 +1,87 @@
+require "test_helper"
+
+class BasicBlockTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+    @module = LLVM::Module.new("BasicBlockTestCase")
+  end
+
+  def test_basic_block_collection
+    @module.functions.add("test_basic_block_collection", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      assert_instance_of LLVM::BasicBlock, block1
+
+      assert_equal 1, coll.size
+      assert_equal coll.first, coll.last,
+                   'Only one block exists in the function'
+      assert_equal coll.first, coll.entry,
+                   'The entry block for the function is always the first block'
+
+      block2 = coll.append
+      assert_equal 2, coll.size
+      assert_equal block1, coll.first
+      assert_equal block2, coll.last
+
+      [ coll.each.to_a, coll.to_a ].each do |blocks|
+        assert_equal 2, blocks.size
+        assert_equal block1, blocks[0]
+        assert_equal block2, blocks[1]
+      end
+    end
+  end
+
+  def test_basic_block
+    @module.functions.add("test_basic_block", [], LLVM.Void) do |fn|
+      coll = fn.basic_blocks
+
+      block1 = coll.append
+      block2 = coll.append
+
+      assert_equal fn, block1.parent
+      assert_equal fn, block2.parent
+
+      assert_equal block2, block1.next
+      assert_equal block1, block2.previous
+
+      block1.build do |builder|
+        builder.br(block2)
+      end
+
+      block2.build do |builder|
+        builder.ret_void
+      end
+
+      assert_equal block1.first_instruction,
+                   block1.last_instruction
+      assert_equal block2.first_instruction,
+                   block2.last_instruction
+    end
+  end
+
+  def test_basic_block_enumerable
+    @module.functions.add("test_basic_block_enumerable", [LLVM::Double], LLVM::Double) do |fn, arg|
+      block1 = fn.basic_blocks.append
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 0, insts.size, 'Empty basic block'
+      end
+
+      block1.build do |builder|
+        builder.ret(builder.fadd(arg, LLVM.Double(1.0)))
+      end
+
+      [ block1.instructions.to_a, block1.instructions.each.to_a ].each do |insts|
+        assert_equal 2, insts.size
+        assert_equal block1.first_instruction, insts[0]  # deprecated
+        assert_equal block1.last_instruction,  insts[1]  # deprecated
+        assert_equal block1.instructions.first, insts[0]
+        assert_equal block1.instructions.last,  insts[1]
+      end
+
+    end
+  end
+
+end

data/test/binary_operations_test.rb

@@ -0,0 +1,58 @@
+require "test_helper"
+
+class BasicOperationsTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_integer_binary_operations
+    integer_binary_operation_assertion(:add, 3, 2, 3 + 2)
+    integer_binary_operation_assertion(:sub, 3, 2, 3 - 2)
+    integer_binary_operation_assertion(:mul, 3, 2, 3 * 2)
+    integer_binary_operation_assertion(:udiv, 10, 2, 10 / 2)
+    integer_binary_operation_assertion(:sdiv, 10, 2, 10 / 2)
+    integer_binary_operation_assertion(:urem, 10, 3, 10 % 3)
+    integer_binary_operation_assertion(:srem, 10, 3, 10 % 3)
+  end
+
+  def test_integer_bitwise_binary_operations
+    integer_binary_operation_assertion(:shl, 2, 3, 2 << 3)
+    integer_binary_operation_assertion(:lshr, 16, 3, 16 >> 3)
+    integer_binary_operation_assertion(:ashr, 16, 3, 16 >> 3)
+    integer_binary_operation_assertion(:and, 2, 1, 2 & 1)
+    integer_binary_operation_assertion(:or, 2, 1, 2 | 1)
+    integer_binary_operation_assertion(:xor, 3, 2, 3 ^ 2)
+  end
+
+  def test_float_binary_operations
+    float_binary_operation_assertion(:fadd, 3.1, 2.2, 3.1 + 2.2)
+    float_binary_operation_assertion(:fsub, 3.1, 2.2, 3.1 - 2.2)
+    float_binary_operation_assertion(:fmul, 3.1, 2.2, 3.1 * 2.2)
+    float_binary_operation_assertion(:fdiv, 3.1, 2.2, 3.1 / 2.2)
+    float_binary_operation_assertion(:frem, 3.1, 2.2, 3.1 % 2.2)
+  end
+
+  def integer_binary_operation_assertion(operation, operand1, operand2, expected_result)
+    result = run_binary_operation(operation,
+                                  LLVM::Int(operand1), LLVM::Int(operand2),
+                                  LLVM::Int).to_i
+    assert_equal expected_result, result
+  end
+
+  def float_binary_operation_assertion(operation, operand1, operand2, expected_result)
+    result = run_binary_operation(operation,
+                                  LLVM::Float(operand1), LLVM::Float(operand2),
+                                  LLVM::Float).to_f
+    assert_in_delta expected_result, result, 0.001
+  end
+
+  def run_binary_operation(operation, operand1, operand2, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(operation, operand1, operand2))
+    end
+  end
+
+end

data/test/bitcode_test.rb

@@ -0,0 +1,24 @@
+require "test_helper"
+require "tempfile"
+
+class BitcodeTestCase < Minitest::Test
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_bitcode
+    test_module = define_module("test_module") do |mod|
+      define_function(mod, "test_function", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+    end
+    Tempfile.open("bitcode") do |tmp|
+      assert test_module.write_bitcode(tmp)
+      new_module = LLVM::Module.parse_bitcode(tmp.path)
+      result = run_function_on_module(new_module, "test_function").to_i
+      assert_equal 1, result
+    end
+  end
+end

data/test/branch_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+
+class BranchTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_branching
+    assert_equal 0, direct_jump_function().to_i
+    assert_equal 0, conditional_jump_function().to_i
+    assert_equal 0, switched_jump_function().to_i
+  end
+
+  def direct_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.br(branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+  def conditional_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.cond(builder.icmp(:eq, LLVM::Int(1), LLVM::Int(2)), branch_1, branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+  def switched_jump_function
+    run_function([], [], LLVM::Int) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      branch_1 = function.basic_blocks.append
+      branch_2 = function.basic_blocks.append
+      builder.position_at_end(entry)
+      switch = builder.switch(LLVM::Int(1), branch_1, LLVM::Int(1) => branch_2)
+      builder.position_at_end(branch_1)
+      builder.ret(LLVM::Int(1))
+      builder.position_at_end(branch_2)
+      builder.ret(LLVM::Int(0))
+    end
+  end
+
+end

data/test/call_test.rb

@@ -0,0 +1,82 @@
+require "test_helper"
+
+class CallTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_simple_call
+    test_module = define_module("test_module") do |host_module|
+      define_function(host_module, "test_function", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+    end
+    assert_equal 1, run_function_on_module(test_module, "test_function").to_i
+  end
+
+  def test_nested_call
+    test_module = define_module("test_module") do |host_module|
+      function_1 = define_function(host_module, "test_function_1", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(LLVM::Int(1))
+      end
+      function_2 = define_function(host_module, "test_function_2", [], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(builder.call(function_1))
+      end
+    end
+    assert_equal 1, run_function_on_module(test_module, "test_function_2").to_i
+  end
+
+  def test_recursive_call
+    test_module = define_module("test_module") do |host_module|
+      define_function(host_module, "test_function", [LLVM::Int], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        recurse = function.basic_blocks.append
+        exit = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.cond(builder.icmp(:uge, arguments.first, LLVM::Int(5)), exit, recurse)
+        builder.position_at_end(recurse)
+        result = builder.call(function, builder.add(arguments.first, LLVM::Int(1)))
+        builder.br(exit)
+        builder.position_at_end(exit)
+        builder.ret(builder.phi(LLVM::Int, entry => arguments.first, recurse => result))
+      end
+    end
+    assert_equal 5, run_function_on_module(test_module, "test_function", 1).to_i
+  end
+
+  def test_external
+    test_module = define_module("test_module") do |host_module|
+      external = host_module.functions.add("abs", [LLVM::Int], LLVM::Int)
+      define_function(host_module, "test_function", [LLVM::Int], LLVM::Int) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        builder.ret(builder.call(external, arguments.first))
+      end
+    end
+    assert_equal(-10.abs, run_function_on_module(test_module, "test_function", -10).to_i)
+  end
+
+  def test_external_string
+    test_module = define_module("test_module") do |host_module|
+      global = host_module.globals.add(LLVM::Array(LLVM::Int8, 5), "path")
+      global.linkage = :internal
+      global.initializer = LLVM::ConstantArray.string("PATH")
+      external = host_module.functions.add("getenv", [LLVM::Pointer(LLVM::Int8)], LLVM::Pointer(LLVM::Int8))
+      define_function(host_module, "test_function", [], LLVM::Pointer(LLVM::Int8)) do |builder, function, *arguments|
+        entry = function.basic_blocks.append
+        builder.position_at_end(entry)
+        parameter = builder.gep(global, [LLVM::Int(0), LLVM::Int(0)])
+        builder.ret(builder.call(external, parameter))
+      end
+    end
+    assert_equal ENV["PATH"], run_function_on_module(test_module, "test_function").to_ptr.read_pointer.read_string
+  end
+
+end

data/test/comparisons_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+
+class ComparisonsTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_integer_comparison
+    integer_comparison_assertion(:eq, 1, 1, LLVM_SIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:ne, 1, 1, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:ugt, 2, 2, LLVM_UNSIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:uge, 2, 1, LLVM_UNSIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:ult, 1, 1, LLVM_UNSIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:ule, 1, 2, LLVM_UNSIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:sgt, -2, 2, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:sge, -2, 1, LLVM_SIGNED, LLVM_FALSE)
+    integer_comparison_assertion(:slt, -1, 2, LLVM_SIGNED, LLVM_TRUE)
+    integer_comparison_assertion(:sle, -1, 2, LLVM_SIGNED, LLVM_TRUE)
+  end
+
+  def test_float_comparison
+    float_comparison_assertion(:oeq, 1.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:one, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ogt, 2.0, 2.0, LLVM_FALSE)
+    float_comparison_assertion(:oge, 2.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:olt, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ole, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:ord, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:ueq, 1.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:une, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ugt, 2.0, 2.0, LLVM_FALSE)
+    float_comparison_assertion(:uge, 2.0, 1.0, LLVM_TRUE)
+    float_comparison_assertion(:ult, 1.0, 1.0, LLVM_FALSE)
+    float_comparison_assertion(:ule, 1.0, 2.0, LLVM_TRUE)
+    float_comparison_assertion(:uno, 1.0, 2.0, LLVM_FALSE)
+  end
+
+  def integer_comparison_assertion(operation, operand1, operand2, signed, expected_result)
+    result = run_comparison_operation(:icmp,
+                                      operation,
+                                      LLVM::Int.from_i(operand1, signed),
+                                      LLVM::Int.from_i(operand2, signed),
+                                      LLVM::Int1).to_i(false)
+    assert_equal expected_result, result
+  end
+
+  def float_comparison_assertion(operation, operand1, operand2, expected_result)
+    result = run_comparison_operation(:fcmp,
+                                      operation,
+                                      LLVM::Float(operand1),
+                                      LLVM::Float(operand2),
+                                      LLVM::Int1).to_i(false)
+    assert_equal expected_result, result
+  end
+
+  def run_comparison_operation(comparison_operation, comparison_operator,
+                               operand1, operand2, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(comparison_operation, comparison_operator, operand1, operand2))
+    end
+  end
+
+end

data/test/conversions_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ConversionsTestCase < Minitest::Test
+
+  def setup
+    LLVM.init_jit
+  end
+
+  def test_trunc_to
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(257), LLVM::Int8, LLVM_UNSIGNED, 1)
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(123), LLVM::Int1, LLVM_UNSIGNED, 1)
+    integer_conversion_assertion(:trunc, LLVM::Int32.from_i(122), LLVM::Int1, LLVM_UNSIGNED, 0)
+  end
+
+  def test_zext_to
+    integer_conversion_assertion(:zext, LLVM::Int16.from_i(257), LLVM::Int32, LLVM_UNSIGNED, 257)
+  end
+
+  def test_sext_to
+    integer_conversion_assertion(:sext, LLVM::Int1.from_i(1), LLVM::Int32, LLVM_SIGNED, -1)
+    integer_conversion_assertion(:sext, LLVM::Int8.from_i(-1), LLVM::Int16, LLVM_UNSIGNED, 65535)
+  end
+
+  def test_fptrunc_to
+    float_conversion_assertion(:fp_trunc, LLVM::Double(123.0), LLVM::Float, 123.0)
+  end
+
+  def test_fpext_to
+    float_conversion_assertion(:fp_ext, LLVM::Float(123.0), LLVM::Double, 123.0)
+    float_conversion_assertion(:fp_ext, LLVM::Float(123.0), LLVM::Float, 123.0)
+  end
+
+  def test_fptoui_to
+    different_type_assertion(:fp2ui, LLVM::Double(123.3), LLVM::Int32, :integer, 123)
+    different_type_assertion(:fp2ui, LLVM::Double(0.7), LLVM::Int32, :integer, 0)
+    different_type_assertion(:fp2ui, LLVM::Double(1.7), LLVM::Int32, :integer, 1)
+  end
+
+  def test_fptosi_to
+    different_type_assertion(:fp2si, LLVM::Double(-123.3), LLVM::Int32, :integer, -123)
+    different_type_assertion(:fp2si, LLVM::Double(0.7), LLVM::Int32, :integer, 0)
+    different_type_assertion(:fp2si, LLVM::Double(1.7), LLVM::Int32, :integer, 1)
+  end
+
+  def test_uitofp_to
+    different_type_assertion(:ui2fp, LLVM::Int32.from_i(257), LLVM::Float, :float, 257.0)
+    different_type_assertion(:ui2fp, LLVM::Int8.from_i(-1), LLVM::Double, :float, 255.0)
+  end
+
+  def test_sitofp_to
+    different_type_assertion(:si2fp, LLVM::Int32.from_i(257), LLVM::Float, :float, 257.0)
+    different_type_assertion(:si2fp, LLVM::Int8.from_i(-1), LLVM::Double, :float, -1.0)
+  end
+
+  def test_bitcast_to
+    different_type_assertion(:bit_cast, LLVM::Int8.from_i(255), LLVM::Int8, :integer, -1)
+  end
+
+  def test_int64
+    integer_conversion_assertion(:zext, LLVM::Int64.from_i(2**62 + 123), LLVM::Int64, LLVM_SIGNED, 2**62 + 123)
+    integer_conversion_assertion(:zext, LLVM::Int64.from_i(-2**62 - 123), LLVM::Int64, LLVM_SIGNED, -2**62 - 123)
+    integer_conversion_assertion(:zext, LLVM::Int64.from_i(2**63 + 123), LLVM::Int64, LLVM_UNSIGNED, 2**63 + 123)
+  end
+
+  def integer_conversion_assertion(operation, operand, return_type, signed, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    assert_equal expected_result, result.to_i(signed)
+  end
+
+  def float_conversion_assertion(operation, operand, return_type, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    assert_in_delta expected_result, result.to_f(return_type), 0.001
+  end
+
+  def different_type_assertion(operation, operand, return_type, assertion_type, expected_result)
+    result = run_conversion_operation(operation, operand, return_type)
+    if assertion_type == :integer
+      assert_equal expected_result, result.to_i
+    else
+      assert_in_delta expected_result, result.to_f(return_type), 0.001
+    end
+  end
+
+  def run_conversion_operation(operation, operand, return_type)
+    run_function([], [], return_type) do |builder, function, *arguments|
+      entry = function.basic_blocks.append
+      builder.position_at_end(entry)
+      builder.ret(builder.send(operation, operand, return_type))
+    end
+  end
+
+end