ruby-llvm-next 10.0.0

data/test/memory_access_test.rb

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,53 @@
+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
+end

data/test/phi_test.rb

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,113 @@
+# encoding: ascii-8bit
+
+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)
+      assert_match(/xorl\t%eax, %eax/, tmp.read)
+    end
+
+    Tempfile.open('emit') do |tmp|
+      mach.emit(mod, tmp.path, :object)
+      assert_match(/\x66\x31\xc0/, File.read(tmp.path, mode: 'rb'))
+    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