ruby-libjit 0.1.0

data/test/test_jit_function.rb

@@ -0,0 +1,329 @@
+require 'jit/function'
+require 'jit/value'
+require 'test/unit'
+
+class TestJitFunction < Test::Unit::TestCase
+  def test_if_false
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(1, function.apply(0))
+  end
+
+  def test_if_true
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(2, function.apply(1))
+  end
+
+  def test_if_false_else
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .else {
+          result.store f.const(JIT::Type::INT, 3)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(3, function.apply(0))
+  end
+
+  def test_if_true_else
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .else {
+          result.store f.const(JIT::Type::INT, 3)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(2, function.apply(1))
+  end
+
+  def test_if_false_else_if_true_else
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT, JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .elsif(f.get_param(1)) {
+          result.store f.const(JIT::Type::INT, 3)
+        } .else {
+          result.store f.const(JIT::Type::INT, 4)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(3, function.apply(0, 1))
+  end
+
+  def test_if_true_else_if_false_else
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT, JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .elsif(f.get_param(1)) {
+          result.store f.const(JIT::Type::INT, 3)
+        } .else {
+          result.store f.const(JIT::Type::INT, 4)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(2, function.apply(1, 0))
+  end
+
+  def test_if_false_else_if_false_else
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ JIT::Type::INT, JIT::Type::INT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        result = f.value(JIT::Type::INT)
+        result.store f.const(JIT::Type::INT, 1)
+        f.if(f.get_param(0)) {
+          result.store f.const(JIT::Type::INT, 2)
+        } .elsif(f.get_param(1)) {
+          result.store f.const(JIT::Type::INT, 3)
+        } .else {
+          result.store f.const(JIT::Type::INT, 4)
+        } .end
+        f.insn_return result
+      end
+    end
+
+    assert_equal(4, function.apply(0, 0))
+  end
+
+  def test_while_true_enters_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        true_value = f.const(JIT::Type::INT, 1)
+        false_value = f.const(JIT::Type::INT, 0)
+        f.while(proc { true_value }) {
+          f.insn_return true_value
+        }.end
+        f.insn_return false_value
+      end
+    end
+
+    assert_equal(1, function.apply)
+  end
+
+  def test_while_true_reenters_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        value = f.value(JIT::Type::INT)
+        value.store(f.const(JIT::Type::INT, 0))
+        f.while(proc { value < f.const(JIT::Type::INT, 2) }) {
+          value.store(value + f.const(JIT::Type::INT, 1))
+        }.end
+        f.insn_return value
+      end
+    end
+
+    assert_equal(2, function.apply)
+  end
+
+  def test_while_false_does_not_enter_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        true_value = f.const(JIT::Type::INT, 1)
+        false_value = f.const(JIT::Type::INT, 0)
+        f.while(proc { false_value }) {
+          f.insn_return true_value
+        }.end
+        f.insn_return false_value
+      end
+    end
+
+    assert_equal(0, function.apply)
+  end
+
+  def test_until_false_enters_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        true_value = f.const(JIT::Type::INT, 1)
+        false_value = f.const(JIT::Type::INT, 0)
+        f.until(proc { false_value }) {
+          f.insn_return true_value
+        }.end
+        f.insn_return false_value
+      end
+    end
+
+    assert_equal(1, function.apply)
+  end
+
+  def test_until_false_reenters_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        value = f.value(JIT::Type::INT)
+        value.store(f.const(JIT::Type::INT, 0))
+        f.until(proc { value == f.const(JIT::Type::INT, 2) }) {
+          value.store(value + f.const(JIT::Type::INT, 1))
+        }.end
+        f.insn_return value
+      end
+    end
+
+    assert_equal(2, function.apply)
+  end
+
+  def test_until_true_does_not_enter_loop
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::INT,
+          [ ])
+      function = JIT::Function.compile(context, signature) do |f|
+        true_value = f.const(JIT::Type::INT, 1)
+        false_value = f.const(JIT::Type::INT, 0)
+        f.until(proc { true_value }) {
+          f.insn_return true_value
+        }.end
+        f.insn_return false_value
+      end
+    end
+
+      assert_equal(0, function.apply)
+  end
+
+  # TODO: while/break
+  # TODO: while/redo
+  # TODO: until/break
+  # TODO: until/redo
+  # TODO: unless
+  # TODO: elsunless
+
+  def test_define_jit_method
+    function = nil
+    JIT::Context.build do |context|
+      signature = JIT::Type.create_signature(
+          JIT::ABI::CDECL,
+          JIT::Type::OBJECT,
+          [ JIT::Type::OBJECT ])
+      function = JIT::Function.compile(context, signature) do |f|
+        f.insn_return(f.const(JIT::Type::OBJECT, 42))
+      end
+    end
+
+    c = Class.new
+    c.instance_eval do
+      define_jit_method('foo', function)
+    end
+
+    o = c.new
+    assert_equal 42, o.foo
+  end
+
+  def test_define_jit_method_non_object_param
+    # TODO: should raise an exception
+  end
+
+  # TODO: get_param
+  # TODO: insn_call
+  # TODO: insn_call_native
+  # TODO: insn_return
+  # TODO: apply
+  # TODO: value
+  # TODO: const
+  # TODO: optimization_level
+  # TODO: optimization_level=
+  # TODO: max_optimization_level
+  # TODO: dump
+  # TODO: to_closure
+  # TODO: context
+  # TODO: compiled?
+end
+

data/test/test_jit_struct.rb

@@ -0,0 +1,111 @@
+require 'jit/array'
+require 'jit/function'
+require 'test/unit'
+require 'assertions'
+
+class TestJitStruct < Test::Unit::TestCase
+  include JitAssertions
+
+  def test_new_struct
+    s_type = JIT::Struct.new(
+        [ :foo, JIT::Type::INT ],
+        [ :bar, JIT::Type::VOID_PTR ],
+        [ :baz, JIT::Type::FLOAT32 ])
+    assert_equal [ :foo, :bar, :baz ], s_type.members
+  end
+
+  def test_create
+    p = proc { |f|
+      s_type = JIT::Struct.new(
+          [ :foo, JIT::Type::INT ],
+          [ :bar, JIT::Type::VOID_PTR ],
+          [ :baz, JIT::Type::FLOAT32 ])
+      s = s_type.create(f)
+      f.return f.const(JIT::Type::INT, 0)
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+  end
+
+  def test_offset_of
+    s_type = JIT::Struct.new(
+        [ :foo, JIT::Type::INT ],
+        [ :bar, JIT::Type::FLOAT64 ],
+        [ :baz, JIT::Type::VOID_PTR ])
+    assert_equal 0, s_type.offset_of(:foo)
+    assert_equal 4, s_type.offset_of(:bar)
+    assert_equal 12, s_type.offset_of(:baz)
+  end
+
+  def test_type_of
+    s_type = JIT::Struct.new(
+        [ :foo, JIT::Type::INT ],
+        [ :bar, JIT::Type::FLOAT64 ],
+        [ :baz, JIT::Type::VOID_PTR ])
+    assert_equal JIT::Type::INT, s_type.type_of(:foo)
+    assert_equal JIT::Type::FLOAT64, s_type.type_of(:bar)
+    assert_equal JIT::Type::VOID_PTR, s_type.type_of(:baz)
+  end
+
+  def test_instance_bracket
+    p = proc { |f|
+      s_type = JIT::Struct.new(
+          [ :foo, JIT::Type::INT ],
+          [ :bar, JIT::Type::FLOAT64 ],
+          [ :baz, JIT::Type::VOID_PTR ])
+      s = s_type.create(f)
+      f.insn_store_relative(s.ptr, 4, f.const(JIT::Type::FLOAT64, 42.0))
+      f.return s[:bar]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::FLOAT64, 42.0 ],
+        &p)
+  end
+
+  def test_instance_attrget
+    p = proc { |f|
+      s_type = JIT::Struct.new(
+          [ :foo, JIT::Type::INT ],
+          [ :bar, JIT::Type::FLOAT64 ],
+          [ :baz, JIT::Type::VOID_PTR ])
+      s = s_type.create(f)
+      f.insn_store_relative(s.ptr, 4, f.const(JIT::Type::FLOAT64, 42.0))
+      f.return s.bar
+    }
+    assert_function_result(
+        :result => [ JIT::Type::FLOAT64, 42.0 ],
+        &p)
+  end
+
+  def test_instance_bracket_eq
+    p = proc { |f|
+      s_type = JIT::Struct.new(
+          [ :foo, JIT::Type::INT ],
+          [ :bar, JIT::Type::FLOAT64 ],
+          [ :baz, JIT::Type::VOID_PTR ])
+      s = s_type.create(f)
+      s[:bar] = f.const(JIT::Type::FLOAT64, 42.0)
+      f.return s[:bar]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::FLOAT64, 42.0 ],
+        &p)
+  end
+
+  def test_instance_attrset
+    p = proc { |f|
+      s_type = JIT::Struct.new(
+          [ :foo, JIT::Type::INT ],
+          [ :bar, JIT::Type::FLOAT64 ],
+          [ :baz, JIT::Type::VOID_PTR ])
+      s = s_type.create(f)
+      s.bar = f.const(JIT::Type::FLOAT64, 42.0)
+      f.return s.bar
+    }
+    assert_function_result(
+        :result => [ JIT::Type::FLOAT64, 42.0 ],
+        &p)
+  end
+end
+

data/test/test_jit_value.rb

@@ -0,0 +1,258 @@
+require 'jit/value'
+require 'jit/function'
+require 'test/unit'
+require 'assertions'
+
+class TestJitValue < Test::Unit::TestCase
+  include JitAssertions
+
+  def test_store
+    p = proc { |f|
+      v = f.value(JIT::Type::INT)
+      v.store(f.const(JIT::Type::INT, 42))
+      f.return v
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 42 ],
+        &p)
+  end
+
+  # TODO: address
+
+  def test_int_plus
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 + v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 3 ],
+        &p)
+  end
+
+  def test_int_minus
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 - v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 3 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+  end
+
+  def test_int_mult
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 * v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 3 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 6 ],
+        &p)
+  end
+
+  def test_int_div
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 / v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 6 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 3 ],
+        &p)
+  end
+
+  def test_int_mod
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 % v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 20 ],
+        :arg1 => [ JIT::Type::INT, 6 ],
+        :result => [ JIT::Type::INT, 2 ],
+        &p)
+  end
+
+  def test_int_and
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 & v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 11 ],
+        :arg1 => [ JIT::Type::INT, 3 ],
+        :result => [ JIT::Type::INT, 3 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 8 ],
+        :arg1 => [ JIT::Type::INT, 3 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+  end
+
+  def test_int_or
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 | v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 10 ],
+        :arg1 => [ JIT::Type::INT, 3 ],
+        :result => [ JIT::Type::INT, 11 ],
+        &p)
+  end
+
+  def test_int_xor
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 ^ v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 10 ],
+        :arg1 => [ JIT::Type::INT, 3 ],
+        :result => [ JIT::Type::INT, 9 ],
+        &p)
+  end
+
+  def test_int_lt
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 < v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 2 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+  end
+
+  def test_int_gt
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 > v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 2 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+  end
+
+  def test_int_eq
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 == v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+  end
+
+  def test_int_le
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 <= v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 2 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+  end
+
+  def test_int_ge
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 >= v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 0 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 2 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 1 ],
+        :arg1 => [ JIT::Type::INT, 1 ],
+        :result => [ JIT::Type::INT, 1 ],
+        &p)
+  end
+
+  def test_int_lshift
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 << v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 31 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 124 ],
+        &p)
+  end
+
+  def test_int_rshift
+    p = proc { |f|
+      v1 = f.get_param(0)
+      v2 = f.get_param(1)
+      f.return v1 >> v2
+    }
+    assert_function_result(
+        :arg0 => [ JIT::Type::INT, 31 ],
+        :arg1 => [ JIT::Type::INT, 2 ],
+        :result => [ JIT::Type::INT, 7 ],
+        &p)
+  end
+end
+
+