ruby-llvm 13.0.1 → 13.0.2

data/test/call_test.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-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

data/test/double_test.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class DoubleTestCase < Minitest::Test
-  def setup
-    LLVM.init_jit
-  end
-
-  def test_double
-    mod = LLVM::Module.new("Double Test")
-    mod.functions.add(:sin, [LLVM::Double], LLVM::Double)
-
-    builder = LLVM::Builder.new
-
-    mod.functions.add('test', [LLVM::Double], LLVM::Double) do |fun, p0|
-      p0.name = 'x'
-
-      bb = fun.basic_blocks.append
-      builder.position_at_end(bb)
-
-      builder.ret(builder.fadd(p0, LLVM::Double(1.0)))
-    end
-
-    engine = LLVM::MCJITCompiler.new(mod)
-
-    arg = 5.0
-    result = engine.run_function(mod.functions["test"], arg)
-    assert_equal arg + 1, result.to_f(LLVM::Double)
-
-    # TODO: fix this
-    #    assert_in_delta(Math.sin(1.0),
-    #      engine.run_function(mod.functions["sin"], 1.0).to_f(LLVM::Double),
-    #      1e-10)
-  end
-end

data/test/equality_test.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "llvm/core"
-
-class EqualityTestCase < Minitest::Test
-  def setup
-    LLVM.init_jit
-  end
-
-  class MyModule < LLVM::Module; end
-  class MyInt < LLVM::Int32; end
-  class MyType < LLVM::Type; end
-  class MyFunction < LLVM::Function; end
-
-  def assert_equalities(options)
-    map = {
-      :equal     => method(:assert_equal),
-      :not_equal => lambda {|n, m, name| assert n != m, name },
-      :same      => method(:assert_same),
-      :not_same  => lambda {|n, m, name| assert !n.equal?(m), name },
-      :eql       => lambda {|n, m, name| assert n.eql?(m), name  },
-      :not_eql   => lambda {|n, m, name| assert !n.eql?(m), name },
-    }
-
-    map.each do |name, callable|
-      options[name].combination(2).each do |n, m|
-        callable.call(n, m, name.to_s)
-      end
-    end
-  end
-
-  def test_int_value
-    int1 = LLVM::Int32.from_i(1)
-    int2 = LLVM::Int32.from_ptr(int1.to_ptr)
-    int3 = LLVM::Int32.from_i(2)
-    int4 = MyInt.from_ptr(int1.to_ptr)
-
-    assert_equalities :equal     => [int1, int2, int4],
-                      :not_equal => [int1, int3],
-                      :same      => [int1, int1],
-                      :not_same  => [int1, int2, int3, int4],
-                      :eql       => [int1, int2],
-                      :not_eql   => [int1, int3]
-  end
-
-  def test_module
-    mod1 = LLVM::Module.new('test')
-    mod2 = LLVM::Module.from_ptr(mod1.to_ptr)
-    mod3 = LLVM::Module.new('dummy')
-    mod4 = MyModule.from_ptr(mod1.to_ptr)
-
-    assert_equalities :equal     => [mod1, mod2, mod4],
-                      :not_equal => [mod1, mod3],
-                      :same      => [mod1, mod1],
-                      :not_same  => [mod1, mod2, mod3, mod4],
-                      :eql       => [mod1, mod2],
-                      :not_eql   => [mod1, mod3]
-  end
-
-  def test_type
-    type1 = LLVM::Float.type
-    type2 = LLVM::Type.from_ptr(type1.to_ptr, nil)
-    type3 = LLVM::Double.type
-    type4 = MyType.from_ptr(type1.to_ptr, :mytype)
-
-    assert_equalities :equal     => [type1, type2, type4],
-                      :not_equal => [type1, type3],
-                      :same      => [type1, type1],
-                      :not_same  => [type1, type2, type3, type4],
-                      :eql       => [type1, type2],
-                      :not_eql   => [type1, type3]
-  end
-
-  def test_function
-    mod = LLVM::Module.new('test')
-
-    fn1 = mod.functions.add('test1', [], LLVM.Void)
-    fn2 = LLVM::Function.from_ptr(fn1.to_ptr)
-    fn3 = mod.functions.add('test2', [], LLVM.Void)
-    fn4 = MyFunction.from_ptr(fn1.to_ptr)
-
-    assert_equalities :equal     => [fn1, fn2, fn4],
-                      :not_equal => [fn1, fn3],
-                      :same      => [fn1, fn1],
-                      :not_same  => [fn1, fn2, fn3, fn4],
-                      :eql       => [fn1, fn2],
-                      :not_eql   => [fn1, fn3]
-  end
-
-end

data/test/function_test.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "llvm/core"
-
-
-def with_function(arguments, retty, &block)
-  mod = LLVM::Module.new('test')
-  fun = mod.functions.add('fun', arguments, retty)
-  block.yield(fun)
-  mod.dispose
-end
-
-class FunctionTest < Minitest::Test
-
-  def test_type
-    with_function [], LLVM.Void do |fun|
-      type = fun.type
-
-      assert_instance_of LLVM::Type, type
-      assert_equal :pointer,  type.kind
-      assert_equal :function, type.element_type.kind
-    end
-  end
-
-  def test_function_type
-    with_function [], LLVM.Void do |fun|
-      type = fun.function_type
-
-      assert_instance_of LLVM::FunctionType, type
-      assert_equal :function, type.kind
-    end
-  end
-
-  def helper_test_attribute(name)
-    with_function [], LLVM.Void do |fun|
-      assert_equal 0, fun.attribute_count
-      assert_equal [], fun.attributes
-
-      fun.add_attribute(name)
-      assert_equal 1, fun.attribute_count
-      assert_equal [34], fun.attributes
-
-      assert_equal false, fun.verify
-
-      fun.remove_attribute(name)
-      assert_equal 0, fun.attribute_count
-      assert_equal [], fun.attributes
-
-      assert_equal false, fun.verify
-    end
-  end
-
-  def test_add_attribute_old_name
-    helper_test_attribute(:no_unwind_attribute)
-  end
-
-  def test_add_attribute_new_name
-    helper_test_attribute(:nounwind)
-  end
-
-end
-
-class FunctionTypeTest < Minitest::Test
-
-  def test_return_type
-    with_function [], LLVM.Void do |fun|
-      type = fun.function_type
-      assert_equal LLVM.Void, type.return_type
-    end
-
-    with_function [], LLVM::Int32 do |fun|
-      retty = fun.function_type.return_type
-
-      assert_kind_of LLVM::IntType, retty
-      assert_equal 32, retty.width
-    end
-  end
-
-  def test_argument_types
-    with_function [], LLVM.Void do |fun|
-      types = fun.function_type.argument_types
-      assert_equal [], types
-    end
-
-    with_function [LLVM::Int32], LLVM.Void do |fun|
-      types = fun.function_type.argument_types
-      assert_equal 1, types.size
-      a1 = types[0]
-      assert_kind_of LLVM::IntType, a1
-      assert_equal 32, a1.width
-    end
-  end
-
-  def test_vararg
-    with_function [], LLVM.Void do |fun|
-      type = fun.function_type
-      assert !type.vararg?, 'should be false'
-    end
-  end
-
-end

data/test/generic_value_test.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class GenericValueTestCase < Minitest::Test
-
-  def setup
-    LLVM.init_jit
-  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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class InstructionTestCase < Minitest::Test
-  def setup
-    LLVM.init_jit
-    @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/integer_test.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class IntegerTestCase < Minitest::Test
-
-  def test_const_zext
-    assert i = LLVM::Int8.from_i(-1)
-    assert_equal 'i8 -1', i.to_s
-    assert_equal :integer, i.type.kind
-    assert_equal 8, i.type.width
-    assert zext = i.zext(LLVM::Int64)
-    assert_equal 'i64 255', zext.to_s
-    assert_equal :integer, zext.type.kind
-    assert_equal 64, zext.type.width
-  end
-
-  def test_const_sext
-    assert i = LLVM::Int8.from_i(-1)
-    assert_equal 'i8 -1', i.to_s
-    assert_equal :integer, i.type.kind
-    assert_equal 8, i.type.width
-    assert sext = i.sext(LLVM::Int64)
-    assert_equal 'i64 -1', sext.to_s
-    assert_equal :integer, sext.type.kind
-    assert_equal 64, sext.type.width
-  end
-end

data/test/ipo_test.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "llvm/core"
-require 'llvm/transforms/ipo'
-require 'llvm/core/pass_manager'
-
-class IPOTestCase < Minitest::Test
-
-  def setup
-    LLVM.init_jit
-  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::MCJITCompiler.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/linker_test.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'llvm/core'
-require 'llvm/linker'
-
-class LinkerTestCase < Minitest::Test
-  def setup
-    LLVM.init_jit
-  end
-
-  def create_modules
-    @mod1 = define_module('mod1') do |mod|
-      mod1calc = mod.functions.add("calc", [], LLVM::Int32)
-
-      mod.functions.add("main", [], LLVM::Int32) do |fn|
-        fn.basic_blocks.append.build do |builder|
-          val = builder.call(mod1calc)
-          builder.ret val
-        end
-      end
-    end
-
-    @mod2 = define_module('mod2') do |mod|
-      mod.functions.add("calc", [], LLVM::Int32) do |fn|
-        fn.basic_blocks.append.build do |builder|
-          builder.ret LLVM::Int32.from_i(42)
-        end
-      end
-    end
-  end
-
-  def test_link_into
-    create_modules
-    @mod2.link_into(@mod1)
-
-    assert_equal 42, run_function_on_module(@mod1, 'main').to_i
-  end
-end