ruby-llvm 13.0.1 → 13.0.2

data/test/mcjit_test.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class MCJITTestCase < Minitest::Test
-  def setup
-    LLVM.init_jit(true)
-  end
-
-  def create_square_function_module
-    LLVM::Module.new('square').tap do |mod|
-      mod.functions.add(:square, [LLVM::Int], LLVM::Int) do |fun, x|
-        fun.basic_blocks.append.build do |builder|
-          n = builder.mul(x, x)
-          builder.ret(n)
-        end
-      end
-
-      mod.verify!
-    end
-  end
-
-  def test_simple_function
-    mod = create_square_function_module
-
-    engine = LLVM::MCJITCompiler.new(mod, :opt_level => 0)
-
-    result = engine.run_function(mod.functions['square'], 5)
-    assert_equal 25, result.to_i
-  end
-
-  def test_functions_named
-    mod = LLVM::Module.new('foo').tap do |mod|
-      mod.functions.add(:foo, [], LLVM::Int)
-      mod.verify!
-    end
-
-    engine = LLVM::MCJITCompiler.new(mod, :opt_level => 0)
-
-    # TODO: fix or replace find_function
-    skip
-
-    ['foo', :foo].each do |name|
-      engine.functions[name].tap do |fun|
-        assert fun, "function named #{name.inspect}"
-        assert_equal 'foo', fun.name
-      end
-    end
-  end
-
-  def test_add_module
-    main_mod = LLVM::Module.new('main')
-
-    main_mod.functions.add(:square, [LLVM::Int], LLVM::Int) do |square|
-      main_mod.functions.add(:call_square, [], LLVM::Int) do |call_square|
-        call_square.basic_blocks.append.build do |builder|
-          n = builder.call(square, LLVM::Int(5))
-          builder.ret(n)
-        end
-      end
-    end
-
-    main_mod.verify!
-
-    engine = LLVM::MCJITCompiler.new(main_mod, :opt_level => 0)
-    engine.modules << create_square_function_module
-
-    result = engine.run_function(main_mod.functions['call_square'])
-    assert_equal 25, result.to_i
-  end
-
-  def test_remove_module
-    mod1 = LLVM::Module.new('foo')
-    mod2 = LLVM::Module.new('bar')
-
-    foo = mod1.functions.add(:foo, [], LLVM::Int)
-    bar = mod2.functions.add(:bar, [], LLVM::Int)
-
-    engine = LLVM::MCJITCompiler.new(mod1, :opt_level => 0)
-
-    (engine.modules << mod2).tap do |ret|
-      assert_equal engine.modules, ret, '#<< returns self'
-    end
-
-    # TODO: fix or replace find_function
-    skip
-
-    refute_nil engine.functions[:bar]
-    engine.modules.delete(mod2).tap do |ret|
-      assert_instance_of LLVM::Module, ret, '#delete returns module'
-      assert_equal mod2, ret
-    end
-    assert_nil engine.functions[:bar]
-  end
-
-  def test_accessors
-    main_mod = LLVM::Module.new('main')
-    engine = LLVM::MCJITCompiler.new(main_mod, :opt_level => 0)
-    assert_match(/^e-/, engine.data_layout.to_s)
-    assert_match(/gnu/, engine.target_machine.triple)
-  end
-end

data/test/memory_access_test.rb

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-require "tempfile"
-
-class ModuleTestCase < Minitest::Test
-
-  def setup
-    LLVM.init_jit
-  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
-
-  def test_simple_module
-    assert_equal 1, simple_function().to_i
-  end
-
-  def test_global_variable
-    yielded = false
-
-    define_module('test_globals_add') do |mod|
-      mod.globals.add(LLVM::Int32, 'i') do |var|
-        yielded = true
-
-        assert var.kind_of?(LLVM::GlobalVariable)
-
-        # unnamed_addr
-        assert !var.unnamed_addr?
-        var.unnamed_addr = true
-        assert var.unnamed_addr?
-
-        assert (var.dll_storage_class == :default)
-        var.dll_storage_class = :dll_import
-        assert (var.dll_storage_class == :dll_import)
-
-        # global_constant
-        assert !var.global_constant?
-        var.global_constant = true
-        assert var.global_constant?
-
-        assert_output("", "Warning: Passing Integer value to LLVM::GlobalValue#global_constant=(Boolean) is deprecated.\n") do
-          var.global_constant = 0
-        end
-        assert !var.global_constant?
-      end
-    end
-
-    assert yielded, 'LLVM::Module::GlobalCollection#add takes block'
-  end
-
-  def test_to_s
-    mod = LLVM::Module.new('test_print')
-    assert_equal mod.to_s,
-      "; ModuleID = 'test_print'\nsource_filename = \"test_print\"\n"
-  end
-
-  def test_dump
-    mod = LLVM::Module.new('test_print')
-    expected_pattern = /^; ModuleID = 'test_print'$/
-
-    Tempfile.open('test_dump.1') do |tmpfile|
-      # debug stream (stderr)
-      stderr_old = $stderr.dup
-      $stderr.reopen(tmpfile.path, 'a')
-      begin
-        mod.dump
-        $stderr.flush
-        assert_match expected_pattern, File.read(tmpfile.path)
-      ensure
-        $stderr.reopen(stderr_old)
-      end
-    end
-  end
-
-  def test_module_properties
-    mod = LLVM::Module.new('mod')
-
-    assert_equal '', mod.triple
-
-    mod.triple = 'x86-linux-gnu'
-    assert_equal 'x86-linux-gnu', mod.triple
-
-    assert_equal '', mod.data_layout
-
-    mod.data_layout = 'e-p:32:32'
-    assert_equal 'e-p:32:32', mod.data_layout
-  end
-
-end

data/test/parameter_collection_test.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ParameterCollectionTestCase < Minitest::Test
-  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/pass_manager_builder_test.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'llvm/config'
-require 'llvm/transforms/builder'
-
-class PassManagerBuilderTest < Minitest::Test
-  def setup
-    LLVM.init_jit
-    @builder = LLVM::PassManagerBuilder.new
-
-    @pass_manager = LLVM::PassManager.new
-  end
-
-  def teardown
-    @builder.dispose
-    @pass_manager.dispose
-  end
-
-  def test_init
-    assert_equal  0,     @builder.size_level
-    assert_equal  0,     @builder.opt_level
-    assert_equal  false, @builder.unit_at_a_time
-    assert_equal  false, @builder.unroll_loops
-    assert_equal  false, @builder.simplify_lib_calls
-    assert_equal  0,     @builder.inliner_threshold
-  end
-
-  def test_opt_level
-    @builder.opt_level = 3
-    assert_equal 3, @builder.opt_level
-  end
-
-  def test_build
-    @builder.build(@pass_manager)
-  end
-
-  def test_build_with_lto
-    assert_output('', '') do
-      @builder.build_with_lto(@pass_manager)
-    end
-  end
-
-  def test_build_with_lto_deprecated_internalize_param
-    assert_output("", "Warning: Passing Integer value to LLVM::PassManagerBuilder#build_with_lto is deprecated.\n") do
-      @builder.build_with_lto(@pass_manager, 0)
-    end
-  end
-
-  def test_build_with_lto_deprecated_run_inliner_param
-    assert_output("", "Warning: Passing Integer value to LLVM::PassManagerBuilder#build_with_lto is deprecated.\n") do
-      @builder.build_with_lto(@pass_manager, false, 0)
-    end
-  end
-
-  PASSES = [
-    'always_inline!',
-    'adce!',
-    'tailcallelim!',
-    'fun_attrs!',
-    'mergefunc!',
-  ].freeze
-
-  describe "PassManager Passes" do
-    before do
-      assert @pass_manager = LLVM::PassManager.new
-    end
-    PASSES.each do |pass|
-      it "should return '#{pass}'" do
-        assert_nil @pass_manager.send(pass)
-      end
-    end
-  end
-end

data/test/phi_test.rb

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

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

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class StructTestCase < Minitest::Test
-
-  LLVM_UNPACKED = false
-  LLVM_PACKED = true
-
-  def setup
-    LLVM.init_jit
-  end
-
-  def test_simple_struct
-    struct = LLVM::Struct(LLVM::Int, LLVM::Float)
-    assert_instance_of LLVM::StructType, struct
-    assert_equal 2, struct.element_types.size
-    assert_equal LLVM::Int.type, struct.element_types[0]
-    assert_equal LLVM::Float.type, struct.element_types[1]
-  end
-
-  def test_named_struct
-    struct = LLVM::Struct(LLVM::Int, LLVM::Float, "struct100")
-    assert_instance_of LLVM::StructType, struct
-    assert_equal "struct100", struct.name
-  end
-
-  def test_deferred_element_type_setting
-    struct = LLVM::Struct("struct200")
-    struct.element_types = [LLVM::Int, LLVM::Float]
-    assert_equal 2, struct.element_types.size
-  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_constant_named_struct
-    struct_ty = LLVM::Struct(LLVM::Int, "struct300")
-    struct = LLVM::ConstantStruct.named_const(struct_ty, [ LLVM::Int(1) ])
-    assert_instance_of LLVM::ConstantStruct, struct
-    assert_equal 1, struct.operands.size
-    assert_equal struct_ty, struct.type
-  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/target_test.rb

@@ -1,126 +0,0 @@
-# encoding: ascii-8bit
-# frozen_string_literal: true
-
-require "test_helper"
-require 'tempfile'
-require 'llvm/version'
-require 'llvm/config'
-
-class TargetTestCase < Minitest::Test
-
-  def setup
-    LLVM::Target.init('X86', true)
-
-    @x86 = LLVM::Target.by_name('x86')
-  end
-
-  def test_init_native
-    LLVM::Target.init_native
-    LLVM::Target.init_native(true)
-  end
-
-  if LLVM::CONFIG::TARGETS_BUILT.include?('ARM')
-    def test_init_arm
-      LLVM::Target.init('ARM')
-      LLVM::Target.init('ARM', true)
-
-      arm_target = LLVM::Target.by_name('arm')
-      assert_equal 'arm', arm_target.name
-    end
-  end
-
-  def test_init_all
-    LLVM::Target.init_all
-    LLVM::Target.init_all(true)
-  end
-
-  def test_each
-    targets = LLVM::Target.each
-
-    assert_instance_of Enumerator, targets
-    assert targets.count > 0
-  end
-
-  def test_target
-    assert_equal 'x86', @x86.name
-    assert_equal "32-bit X86: Pentium-Pro and above", @x86.description
-    assert_equal true, @x86.jit?
-    assert_equal true, @x86.target_machine?
-    assert_equal true, @x86.asm_backend?
-  end
-
-  def test_target_machine
-    @x86 = LLVM::Target.by_name('x86')
-    mach = @x86.create_machine('x86-linux-gnu', 'i686')
-
-    assert_equal @x86, mach.target
-    assert_equal 'x86-linux-gnu', mach.triple
-    assert_equal 'i686', mach.cpu
-    assert_equal '', mach.features
-  end
-
-  def test_emit
-    mach = @x86.create_machine('x86-linux-gnu')
-
-    mod = define_module('test') do |mod|
-      define_function(mod, 'main', [], LLVM::Int) do |builder, fun|
-        entry = fun.basic_blocks.append
-        builder.position_at_end(entry)
-        builder.ret(LLVM::Int(0))
-      end
-    end
-
-    Tempfile.open('emit') do |tmp|
-      mach.emit(mod, tmp.path)
-      data = tmp.read
-      assert_match(/xorl\t%eax, %eax/, data)
-      assert_equal 218, data.length
-    end
-
-    # despite the above test, in LLVM <= 11 the objdump output was:
-    # 00000000 <main>:
-    #    0:   66 31 c0                xor    %ax,%ax
-    #    3:   66 c3                   retw
-    # In LLVM 13, the objdump output is:
-    # 00000000 <main>:
-    #    0:   31 c0                   xor    %eax,%eax
-    #    2:   c3                      ret
-    Tempfile.open('emit') do |tmp|
-      mach.emit(mod, tmp.path, :object)
-      data = File.read(tmp.path, mode: 'rb')
-      assert_match(/\x31\xc0\xc3/, data)
-      assert_equal 528, data.length
-    end
-  end
-
-  def test_data_layout
-    layout_be = LLVM::TargetDataLayout.new('E')
-    assert_equal :big_endian, layout_be.byte_order
-
-    desc = "e-p:32:32:32-S0-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f16:16:16-f32:32:32-f64:64:64-f128:128:128-v64:64:64-v128:128:128-a0:0:64"
-    layout = LLVM::TargetDataLayout.new(desc)
-
-    assert_equal desc, layout.to_s
-    assert_equal :little_endian, layout.byte_order
-    assert_equal 4, layout.pointer_size
-    assert_equal 4, layout.pointer_size(0)
-    assert_equal LLVM::Int32.type, layout.int_ptr_type
-    assert_equal LLVM::Int32.type, layout.int_ptr_type(0)
-
-    assert_equal 19, layout.bit_size_of(LLVM::Int19.type)
-    assert_equal 3, layout.storage_size_of(LLVM::Int19.type)
-    assert_equal 4, layout.abi_size_of(LLVM::Int19.type)
-    assert_equal 4, layout.abi_alignment_of(LLVM::Int19.type)
-    assert_equal 4, layout.call_frame_alignment_of(LLVM::Int19.type)
-    assert_equal 4, layout.preferred_alignment_of(LLVM::Int19.type)
-
-    struct = LLVM.Struct(LLVM::Int8, LLVM::Int32)
-
-    assert_equal 0, layout.offset_of_element(struct, 0)
-    assert_equal 4, layout.offset_of_element(struct, 1)
-
-    assert_equal 0, layout.element_at_offset(struct, 0)
-    assert_equal 0, layout.element_at_offset(struct, 3)
-    assert_equal 1, layout.element_at_offset(struct, 4)
-  end
-end

data/test/test_helper.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-$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
-
-begin
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter "/test/"
-  end
-rescue LoadError
-  warn "Proceeding without SimpleCov. gem install simplecov on supported platforms."
-end
-
-require "minitest/autorun"
-require 'minitest/reporters'
-
-Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-
-require "llvm/core"
-require "llvm/execution_engine"
-require "llvm/transforms/scalar"
-
-class Minitest::Test
-
-  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::MCJITCompiler.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