ytljit 0.0.1

data/test/cstest.rb

@@ -0,0 +1,61 @@
+require 'ytljit.rb'
+
+include YTLJit
+include AbsArch
+
+# Fib number
+def fib(n)
+  cs0 = CodeSpace.new
+  cs1 = CodeSpace.new
+  cs2 = CodeSpace.new
+  
+  asm = Assembler.new(cs0)
+#  asm.step_mode = true
+  ent = nil
+  asm.with_retry do
+    ent = cs1.var_base_address
+    asm.mov(TMPR, OpImmidiate32.new(n))
+    asm.call(ent)
+    asm.add(TMPR, TMPR)
+    asm.add(TMPR, OpImmidiate8.new(1))
+    asm.ret
+  end
+  
+  asm = Assembler.new(cs1)
+#  asm.step_mode = true
+  asm.with_retry do
+    asm.cmp(TMPR, OpImmidiate32.new(2))
+    asm.jl(cs2.var_base_address)
+    asm.sub(TMPR, OpImmidiate32.new(1))
+    asm.push(TMPR)
+    asm.call(ent)
+    asm.pop(TMPR2)
+    asm.sub(TMPR2, OpImmidiate32.new(1))
+    asm.push(TMPR)
+    asm.mov(TMPR, TMPR2)
+    asm.call(ent)
+    asm.pop(TMPR2)
+    asm.add(TMPR, TMPR2)
+    asm.ret
+  end
+  
+  asm = Assembler.new(cs2)
+#  asm.step_mode = true
+  asm.with_retry do
+    asm.mov(TMPR, OpImmidiate32.new(1))
+    asm.ret
+  end
+
+#  cs0.disassemble
+#  cs1.disassemble
+#  cs2.disassemble
+
+  p cs1.refer_operands
+  ref = cs1.refer_operands
+  p ref[0].refer[0].binding.to_a
+  p ref[0].refer[0].binding.variables
+
+  cs0.call(cs0.base_address)
+end
+
+p fib(2)

data/test/marshaltest.rb

@@ -0,0 +1,27 @@
+require 'ytljit'
+require 'pp'
+
+class Foo
+  def foo
+    x = 10
+    lambda {|y, z|
+      lambda {|c|
+        [1, 2][0] = 2
+        p y
+        p self
+        lambda {
+          a = 1
+          p c + y + z + x + a
+        }.call
+      }
+    }.call(1, 3)
+  end
+end
+
+a = Foo.new
+b = a.foo
+b.call(2)
+
+b = Marshal.load(Marshal.dump(b))
+b.call(2)
+pp b.to_iseq.to_a

data/test/test_assemble.rb

@@ -0,0 +1,148 @@
+require 'test/unit'
+require 'ytljit.rb'
+
+include YTLJit
+class InstructionTests < Test::Unit::TestCase
+  def setup
+    @cs = CodeSpace.new
+    @asm = Assembler.new(@cs, GeneratorExtend)
+    @eax = OpEAX.instance
+    @ecx = OpECX.instance
+    @esp = OpESP.instance
+    @lit32 = OpImmidiate32.new(0x12345678)
+    @in_eax = OpIndirect.new(@eax)
+    @in_eax_125 = OpIndirect.new(@eax, OpImmidiate8.new(125))
+    @in_eax_4096 = OpIndirect.new(@eax, OpImmidiate32.new(4096))
+    @in_esp_0 = OpIndirect.new(@esp)
+    @in_esp_10 = OpIndirect.new(@esp, OpImmidiate8.new(-10))
+  end
+
+  def test_add
+
+    assert_equal(@asm.add(@eax, @lit32), [5, 0x12345678].pack("CL"))
+    assert_equal(@asm.add(@ecx, @lit32), [0x81, 0xC1, 0x12345678].pack("CCL"))
+    assert_equal(@asm.add(@ecx, @eax), [3, 0xC8].pack("CC"))
+    assert_equal(@asm.add(@eax, @in_eax), [3, 0].pack("CC"))
+    assert_equal(@asm.add(@eax, @in_eax_125), [3, 0x40, 125].pack("C3"))
+    assert_equal(@asm.add(@in_eax_4096, @eax), [1, 0x80, 0, 0x10, 0, 0].pack("C*"))
+    assert_equal(@asm.imul(@eax, @lit32), "i\xC0xV4\x12")
+    assert_equal(@asm.imul(@eax, @ecx, @lit32), "i\xC1xV4\x12")
+    assert_equal(@asm.imul(@eax, @in_eax_4096, @lit32), "i\x80\x00\x10\x00\x00xV4\x12")
+#    @cs.disassemble
+  end
+
+  def test_mov
+    assert_equal(@asm.mov(@eax, @lit32), [0xB8, 0x12345678].pack("CL"))
+    assert_equal(@asm.mov(@eax, @in_eax_125), [0x8B, 0x40, 0x7d].pack("C3"))
+    assert_equal(@asm.mov(@in_eax_125, @eax), [0x89, 0x40, 0x7d].pack("C3"))
+    File.open("foo.bin", "w") {|fp|
+=begin
+      lab = @asm.current_address
+      fp.write @asm.add(@eax, @in_eax_125)
+      fp.write @asm.add(@in_eax_125, @eax)
+      fp.write @asm.add(@in_eax_4096, @eax)
+      fp.write @asm.sub(@eax, @in_eax_125)
+      fp.write @asm.and(@in_eax_125, @eax)
+      fp.write @asm.or(@in_eax_4096, @eax)
+      lab2 = @asm.current_address
+      fp.write @asm.xor(@in_eax_4096, @eax)
+      fp.write @asm.cmp(@in_eax_4096, @eax)
+      fp.write @asm.mov(@eax, @lit32)
+      fp.write @asm.mov(@eax, @in_eax_125)
+      fp.write @asm.mov(@in_eax_125, @eax)
+      fp.write @asm.mov(@in_esp_0, @eax)
+      fp.write @asm.mov(@in_esp_10, @eax)
+      fp.write @asm.push(@eax)
+      fp.write @asm.pop(@in_eax_125)
+      fp.write @asm.call(lab)
+      fp.write @asm.jo(lab)
+      fp.write @asm.jl(lab2)
+      fp.write @asm.lea(@eax, @in_esp_0)
+      fp.write @asm.lea(@eax, @in_esp_10)
+      fp.write @asm.sal(@eax)
+      fp.write @asm.sar(@eax)
+      fp.write @asm.shl(@eax)
+      fp.write @asm.shr(@eax)
+      fp.write @asm.sal(@eax, 2)
+      fp.write @asm.sar(@eax, 2)
+      fp.write @asm.shl(@eax, 2)
+      fp.write @asm.shr(@eax, 2)
+
+      fp.write @asm.rcl(@eax)
+      fp.write @asm.rcr(@eax)
+      fp.write @asm.rol(@eax)
+      fp.write @asm.ror(@eax)
+      fp.write @asm.rcl(@eax, 2)
+      fp.write @asm.rcr(@eax, 2)
+      fp.write @asm.rol(@eax, 2)
+      fp.write @asm.ror(@eax, 2)
+      st = AsmType::Struct.new(
+                          AsmType::INT32, :foo,
+                          AsmType::INT32, :bar,
+                          AsmType::Struct.new(
+                                 AsmType::INT32, :kkk,
+                                 AsmType::INT32, :ass,
+                                 AsmType::INT32, :baz,
+                                            ), :aaa,
+                           AsmType::INT32, :baz
+                          )
+      foo = TypedData.new(st, X86::EAX)
+      cd, foo = @asm.mov(X86::EAX, foo[:baz])
+      fp.write cd
+=end
+    hello = OpImmidiate32.new("Hello World".address)
+    rshello = TypedData.new(InternalRubyType::RString, hello)
+      cd, foo = @asm.mov(X86::EAX, rshello[:as][:heap][:ptr])
+    fp.write cd
+    fp.write @asm.push(X86::EAX)
+    rbp = address_of("puts")
+    fp.write @asm.call(rbp)
+    fp.write @asm.add(X86::ESP, OpImmidiate8.new(4))
+    fp.write @asm.ret
+    }
+  end
+
+  def test_struct
+    st = AsmType::Struct.new(
+                          AsmType::INT32, :foo,
+                          AsmType::INT32, :bar,
+                          AsmType::INT32, :baz
+                          )
+    foo = TypedData.new(st, X86::EAX)
+    cd, type = @asm.mov(X86::EAX, foo[:baz])
+    assert_equal(cd, 
+                 [0x8b, 0x80, 0x8, 0x0, 0x0, 0x0].pack("C*"))
+
+     st = AsmType::Struct.new(
+                          AsmType::INT32, :foo,
+                          AsmType::INT32, :bar,
+                          AsmType::Struct.new(
+                                 AsmType::INT32, :kkk,
+                                 AsmType::INT32, :ass,
+                                 AsmType::INT32, :baz,
+                                            ), :aaa,
+                           AsmType::INT32, :baz
+                          )
+    foo = TypedData.new(st, X86::EBX)
+    cd, type = @asm.mov(X86::EDX, foo[:aaa][:baz])
+    assert_equal(cd, 
+                 [0x89, 0xd8, 0x8b, 0x80, 0x10, 0x0, 0x0, 0x0, 0x89, 0xc2].pack("C*"))
+   end
+
+  def test_callseq_macro
+    @asm.mov(AbsArch::FUNC_ARG[0], OpImmidiate32.new(1))
+    @asm.call_with_arg(OpImmidiate32.new(0), 1)
+    @cs.disassemble
+  end
+
+  include X86
+  def test_movss
+    @asm.movss(XMM0, @in_esp_0)
+    @asm.movss(XMM7, @in_esp_10)
+    @asm.movss(@in_esp_10, XMM0)
+    @asm.movsd(XMM0, @in_esp_0)
+    @asm.movsd(XMM7, @in_esp_10)
+    @asm.movsd(@in_esp_10, XMM0)
+    @cs.disassemble
+  end
+end

data/test/test_assemble2.rb

@@ -0,0 +1,286 @@
+require 'test/unit'
+require 'ytljit.rb'
+
+include YTLJit
+
+class Integer
+  def to_as
+    "$0X#{self.to_s(16)}"
+  end
+end
+
+class InstructionTests < Test::Unit::TestCase
+  include X86
+  include X64
+
+  def setup
+    @cs = CodeSpace.new
+    @asm = Assembler.new(@cs, GeneratorExtend)
+    @asout = ""
+    @regs = [EAX, ECX, EDX, EBX, EBP, EDI, ESI, ESP]
+    @regs8 = [AL, CL, DL, BL]
+#    @regs = [RAX, RCX, RDX, RBX, RBP, RDI, RSI, RSP, R8, R9, R10,
+#             R11, R12, R13, R14, R15]
+
+    @xmmregs = [XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7]
+    @lits = [OpImmidiate32.new(0x0), OpImmidiate32.new(0x92),
+             OpImmidiate32.new(0x8212), OpImmidiate32.new(0x12345678),
+             0, 0x92, 0x8212, 0x12345678]# , 0xffffffff]
+    @indirects = []
+    [EBP, EDI, ESI, ESP].each do |reg|
+#    [RBP, RDI, RSI, RSP].each do |reg|
+      [0, 12, 255, 8192, 65535].each do |offset|
+        @indirects.push OpIndirect.new(reg, offset)
+      end
+    end
+  end
+
+  def asm_ytljit(nm, dst, src)
+    @asm.with_retry do
+      if src then
+        @asm.send(nm, dst, src)
+      else
+        @asm.send(nm, dst)
+      end
+    end
+  end
+
+  def disasm_ytljit(cs)
+    tmpfp = Tempfile.open("ytljitcode")
+    tmpfp.write cs.code
+    tmpfp.close(false)
+    # quick dirty hack to work on Cygwin & Mac OS X/Core2Duo
+    # TODO: bdf and instruction set architecture should be automatically selected
+    case $ruby_platform
+    when /x86_64-darwin/
+      objcopy_cmd = "gobjcopy -I binary -O mach-o-i386 -B i386 --adjust-vma=#{cs.base_address} #{tmpfp.path}"
+      objdump_cmd = "gobjdump -M x86-64 -D #{tmpfp.path}"
+      
+    when /x86_64/
+      objcopy_cmd = "objcopy -I binary -O elf64-x86-64 -B i386 --adjust-vma=#{cs.base_address} #{tmpfp.path}"
+      objdump_cmd = "objdump -M x86-64 -D #{tmpfp.path}"
+      
+    when /i.86/
+      objcopy_cmd = "objcopy -I binary -O elf32-i386 -B i386 --adjust-vma=#{cs.base_address} #{tmpfp.path}"
+      objdump_cmd = "objdump -M i386 -D #{tmpfp.path}"
+    end
+    system(objcopy_cmd)
+    res = []
+    File.popen(objdump_cmd, "r") {|fp|
+      fp.readlines.each do |lin|
+        if /([0-9a-f]*):(\t[0-9a-f ]+? *\t.*)/ =~ lin then
+          res.push lin
+        end
+      end
+    }
+
+    res
+  end
+
+  def asm_gas(nm, dst, src)
+    if dst then
+      if src then
+        @asout += "\t#{nm}\t#{src.to_as}, #{dst.to_as}\n"
+      else
+        @asout += "\t#{nm}\t#{dst.to_as}\n"
+      end
+    else
+      if src then
+        @asout += "\t#{nm}\t#{src.to_as}\n"
+      else
+        @asout += "\t#{nm}\n"
+      end
+    end
+  end
+
+  def disasm_gas(cs)
+    tmpfp = Tempfile.open("gascode")
+    tmpfp.write @asout
+    tmpfp.close(false)
+    system("as #{tmpfp.path}")
+
+    case $ruby_platform
+    when /x86_64-darwin/
+      objdump_cmd = "gobjdump -M x86-64 -D --adjust-vma=#{cs.base_address} a.out"
+      
+    when /x86_64/
+      objdump_cmd = "objdump -M x86-64 -D --adjust-vma=#{cs.base_address} a.out"
+      
+    when /i.86/
+      objdump_cmd = "objdump -M i386 -D --adjust-vma=#{cs.base_address} a.out"
+    end
+
+    res = []
+    File.popen(objdump_cmd, "r") {|fp|
+      fp.readlines.each do |lin|
+        if /([0-9a-f]*):(\t[0-9a-f ]+? *\t.*)/ =~ lin then
+          res.push lin
+        end
+      end
+    }
+
+    res
+  end
+
+  def test_asm
+    [:mov, :add, :or, :adc, :sbb, :and, :sub, :xor, :cmp].each do |mnm|
+      # Pattern reg, immidiate
+      @regs.each do |reg|
+        @lits.each do |src|
+          asm_ytljit(mnm, reg, src)
+          asm_gas(mnm, reg, src)
+        end
+      end
+
+      # Pattern reg, reg
+      @regs.each do |reg|
+        @regs.each do |src|
+          asm_ytljit(mnm, reg, src)
+          asm_gas(mnm, reg, src)
+        end
+      end
+
+      # Pattern indirect, reg
+      @indirects.each do |dst|
+        #      asm_ytljit(mnm, dst, @lits[0])
+        #      asm_gas(mnm, dst, @lits[0])
+        @regs.each do |src|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+
+      # Pattern reg, indirect
+      @indirects.each do |src|
+        @regs.each do |dst|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+      
+      ytlres = disasm_ytljit(@cs)
+      gasres = disasm_gas(@cs)
+#      print @asout
+      ytlres.each_with_index do |lin, i|
+        assert_equal(gasres[i], lin)
+      end
+      @cs.reset
+      @asout = ""
+    end
+  end
+
+  def test_lea
+    [:lea].each do |mnm|
+      @indirects.each do |src|
+        #      asm_ytljit(mnm, dst, @lits[0])
+        #      asm_gas(mnm, dst, @lits[0])
+        @regs.each do |dst|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+      
+      ytlres = disasm_ytljit(@cs)
+      gasres = disasm_gas(@cs)
+      ytlres.each_with_index do |lin, i|
+        assert_equal(gasres[i], lin)
+      end
+      @cs.reset
+      @asout = ""
+    end
+  end
+
+  def test_setcc
+    [:seta, :setae, :setb, :setbe, :setg, :setge, :setl, :setle, 
+     :setna, :setnae, :setnb, :setnle, :setno, :seto, 
+     :setz, :setnz].each do |mnm|
+      @indirects.each do |dst|
+        asm_ytljit(mnm, dst, nil)
+        asm_gas(mnm, dst, nil)
+      end
+
+      @regs8.each do |dst|
+        asm_ytljit(mnm, dst, nil)
+        asm_gas(mnm, dst, nil)
+      end
+      
+      ytlres = disasm_ytljit(@cs)
+      gasres = disasm_gas(@cs)
+      ytlres.each_with_index do |lin, i|
+        assert_equal(gasres[i], lin)
+      end
+      @cs.reset
+      @asout = ""
+    end
+  end
+
+  def test_xmm_mov
+    [:movss, :movsd].each do |mnm|
+
+      # Pattern reg, reg
+      @xmmregs.each do |reg|
+        @xmmregs.each do |src|
+          asm_ytljit(mnm, reg, src)
+          asm_gas(mnm, reg, src)
+        end
+      end
+
+      # Pattern indirect, reg
+      @indirects.each do |dst|
+        #      asm_ytljit(mnm, dst, @lits[0])
+        #      asm_gas(mnm, dst, @lits[0])
+        @xmmregs.each do |src|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+
+      # Pattern reg, indirect
+      @indirects.each do |src|
+        @xmmregs.each do |dst|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+      
+      ytlres = disasm_ytljit(@cs)
+      gasres = disasm_gas(@cs)
+#      print @asout
+      ytlres.each_with_index do |lin, i|
+        assert_equal(gasres[i], lin)
+      end
+      @cs.reset
+      @asout = ""
+    end
+  end
+
+  def test_xmm_arith
+    [:addss, :addsd, :subss, :subsd, 
+     :mulss, :mulsd, :divss, :divsd].each do |mnm|
+
+      # Pattern reg, reg
+      @xmmregs.each do |reg|
+        @xmmregs.each do |src|
+          asm_ytljit(mnm, reg, src)
+          asm_gas(mnm, reg, src)
+        end
+      end
+
+      # Pattern reg, indirect
+      @indirects.each do |src|
+        @xmmregs.each do |dst|
+          asm_ytljit(mnm, dst, src)
+          asm_gas(mnm, dst, src)
+        end
+      end
+      
+      ytlres = disasm_ytljit(@cs)
+      gasres = disasm_gas(@cs)
+      ytlres.each_with_index do |lin, i|
+        assert_equal(gasres[i], lin)
+      end
+      @cs.reset
+      @asout = ""
+    end
+  end
+end

data/test/test_codespace.rb

@@ -0,0 +1,102 @@
+require 'test/unit'
+require 'ytljit.rb'
+
+class CodeSpaceTests < Test::Unit::TestCase
+  include YTLJit
+
+  def test_emit
+    cs = CodeSpace.new
+    cs[0] = "Hello"
+    assert_equal(cs.code, "Hello")
+    cs.emit("World")
+    assert_equal(cs.code, "HelloWorld")
+  end
+
+  def test_ref
+    cs = CodeSpace.new
+    cs[0] = "Hello"
+    assert_equal(cs[1], 'e'.ord)
+    # p cs.base_address.to_s(16)
+  end
+
+  def test_withasm
+    asm = Assembler.new(cs = CodeSpace.new)
+  
+    # registor definition
+    eax = OpEAX.instance
+    esp = OpESP.instance
+    hello = OpImmidiate32.new("Hello World".address)
+    asm.mov(eax, hello)
+    asm.push(eax)
+    rbp = address_of("rb_p")
+    asm.call(rbp)
+    asm.add(esp, OpImmidiate8.new(4))
+    asm.ret
+#    cs.call(cs.base_address)
+  end
+
+  def test_resize
+    cs = CodeSpace.new
+
+    cs[0] = "Hello"
+    assert_equal(cs[0], 'H'.ord)
+
+    cs[32] = "Hello"
+    assert_equal(cs[1], 'e'.ord)
+
+    cs[64] = "Hello"
+    assert_equal(cs[2], 'l'.ord)
+
+    cs[128] = "Hello"
+    assert_equal(cs[3], 'l'.ord)
+
+    cs[256] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[768] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[2000] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[4096] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[8155] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+=begin
+#Large Memory area not support
+    cs[10920] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[32768] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+
+    cs[65520] = "Hello"
+    assert_equal(cs[4], 'o'.ord)
+=end
+  end
+
+  def test_manyspace
+    cs = []
+    100.times do 
+      cs = []
+      100.times do |i|
+        cs.push CodeSpace.new
+        cs.last[4090] = "Hello"
+        cs.push CodeSpace.new
+        cs.last[90] = "Hello"
+      end
+      GC.start
+
+      321.times do |i|
+        cs.push CodeSpace.new
+        cs.last[18] = "Hello"
+        cs.push CodeSpace.new
+        cs.last[289] = "Hello"
+      end
+    end
+    assert_equal(cs.last[293], 'o'.ord)
+  end
+end

data/test/test_typeinf.rb

@@ -0,0 +1,21 @@
+require 'test/unit'
+require 'lib/ytljit/ytljit.rb'
+
+include YTLJit::TypeUtil
+
+class TreeTests < Test::Unit::TestCase
+
+  def test_tree
+    tree = KlassTree.new
+
+    tree.add([0], :int)
+    tree.add([1.0], :float)
+    tree.add([2], :fixnum)
+    tree.add([[]], :a)
+
+    assert_equal(tree.search([[]]).value, :a)
+    assert_equal(tree.search([2]).value, :fixnum)
+    assert_equal(tree.search([1.0]).value, :float)
+    assert_equal(tree.search([]).value, [])
+  end
+end

data/test/tivmtest.rb

@@ -0,0 +1,54 @@
+# test program
+require 'ytljit'
+require 'pp'
+
+include YTLJit
+is = RubyVM::InstructionSequence.compile(
+#        "def typeinf; p @name; end ; typeinf","", "", 0,
+        "p @name","", "", 0,
+#        "def typeinf; p @name; end ; ","", "", 0,
+              {  :peephole_optimization    => true,
+                 :inline_const_cache       => false,
+                 :specialized_instruction  => false,}
+     ).to_a
+iseq = VMLib::InstSeqTree.new(nil, is)
+pp iseq
+
+tr = VM::YARVTranslatorTypeInference.new([iseq])
+#tr = VM::YARVTranslatorSimple.new([iseq])
+context = VM::YARVContext.new
+class Foo;def initialize;@name = :foo;end;end
+class Bar;def initialize;@name = :bar;end;end
+foo = Foo.new
+bar = Bar.new
+tnode = tr.translate(context)
+tnode.inspect_by_graph
+context = VM::CollectInfoContext.new(tnode)
+context = tnode.collect_info(context)
+
+context = VM::CompileContext.new(tnode)
+context.slf = foo
+context = tnode.compile(context)
+tnode.code_space.call(tnode.code_space.base_address)
+
+context = VM::CompileContext.new(tnode)
+context.slf = bar
+context = tnode.compile(context)
+tnode.code_space.call(tnode.code_space.base_address)
+
+# context.code_space.disassemble
+p tnode.code_space
+# tnode.code_space.disassemble
+=begin
+tnode = Marshal.load(Marshal.dump(tnode))
+asm = Assembler.new(tnode.code_space)
+asm.with_retry do
+end
+tnode.code_space.disassemble
+=end
+tnode.code_space_tab.each do |cs|
+  cs.fill_disasm_cache
+end
+tnode.code_space.disassemble
+
+