ytljit 0.0.1

data/lib/ytljit/asmext_x64.rb

@@ -0,0 +1,212 @@
+module YTLJit
+  module FuncArgX64CommonMixin
+    include AbsArch
+    include X64
+    ARGPOS2REG = [RDI, RSI, RDX, RCX, R8, R9]
+    ARGPOS2FREG = [XMM0, XMM1, XMM2, XMM3]
+  end
+
+  module FunctionArgumentX64MixinInt
+    include FuncArgX64CommonMixin
+
+    def argpos2reg
+      case @abi_kind
+      when :c
+        ARGPOS2REG
+
+      when :ytl
+        []
+
+      else
+        raise "#{@abi_kind}"
+      end
+    end
+  end
+
+  module FunctionArgumentX64MixinFloat
+    include FuncArgX64CommonMixin
+
+    def argpos2reg
+      case @abi_kind
+      when :c
+        ARGPOS2FREG
+
+      when :ytl
+        []
+
+      else
+        raise "#{@abi_kind}"
+      end
+    end
+  end
+
+  module FunctionArgumentX64MixinCommon
+    include FuncArgX64CommonMixin
+
+    def dst_opecode
+      if @no < argpos2reg.size then
+        argpos2reg[@no]
+      else
+        spos = @no - argpos2reg.size
+        OpIndirect.new(SPR, OpImmidiate8.new(spos * 8))
+      end
+    end
+
+    def src_opecode
+      if @no < argpos2reg.size then
+        argpos2reg[@no]
+      else
+        # +1 means return address slot
+        spos = @no - argpos2reg.size + 1
+        OpIndirect.new(SPR, OpImmidiate8.new(spos * 8))
+      end
+    end
+
+    def gen_access_dst(gen, inst, dst, src, src2)
+      code = ""
+      asm = gen.asm
+      fainfo = gen.funcarg_info
+
+      if @no == 0 then
+        fainfo.area_allocate_pos.push nil
+        fainfo.used_arg_tab.push Hash.new
+      end
+
+      # It can be argpos2reg.size == 0, so this "if" isn't "elsif"
+      if @no == argpos2reg.size then
+        offset = asm.offset
+        code += asm.update_state(gen.sub(SPR, 0))
+        fainfo.area_allocate_pos[-1] = offset
+      end
+
+      if @no < argpos2reg.size then
+        argreg = argpos2reg[@no]
+        
+        # for nested function call. need save previous reg.
+        if asm.retry_mode != :change_op and 
+            fainfo.used_arg_tab.last[@no] then
+          asm.update_state(gen.push(argreg))
+          fainfo.push argreg
+        end
+        code += asm.update_state(gen.mov(argreg, src))
+      else
+        # spilled reg 
+        spos = @no - argpos2reg.size
+        argdst = OpIndirect.new(SPR, OpImmidiate8.new(spos * 8))
+
+        if src.is_a?(OpRegXMM) then
+          code += asm.update_state(gen.movsd(argdst, src))
+        else
+          if inst == :mov and !src.is_a?(OpRegistor) then
+            code += asm.update_state(gen.send(inst, TMPR, src))
+            code += asm.update_state(gen.mov(argdst, TMPR))
+          else
+            code += asm.update_state(gen.mov(argdst, src))
+          end
+        end
+      end
+
+      if asm.retry_mode != :change_op then
+        # if retry mode fainfo.used_arg_tab is deleted
+        fainfo.used_arg_tab.last[@no] = @size
+      end
+      code
+    end
+
+    # Access the passing argument from caller
+    #
+    def gen_access_src(gen, inst, dst, src, src2)
+      asm = gen.asm
+      fainfo = gen.funcarg_info
+      code = ""
+      if @no < argpos2reg.size then
+        code += asm.update_state(gen.mov(TMPR, argpos2reg[@no]))
+      else
+        spos = @no - argpos2reg.size
+        offset = 8 + spos * 8
+        code += asm.update_state(gen.mov(TMPR, OpIndirect.new(SPR, offset)))
+      end
+      code += asm.update_state(gen.send(inst, src, TMPR))
+      code
+    end
+  end
+
+  module GeneratorExtendX64Mixin
+    include FuncArgX64CommonMixin
+
+    def mov64(dst, src)
+      case dst
+      when OpIndirect
+        case src
+        when Integer
+          disp = dst.disp
+          dst2 = dst.class.new(dst.reg, disp + 4)
+          bit32val = 1 << 32
+          code = mov(dst2, src / bit32val)
+          code += mov(dst, src % bit32val)
+          code
+        else
+          nosupported_addressing_mode(:mov64, dst, src)
+        end
+      else
+        nosupported_addressing_mode(:mov64, dst, src)
+      end
+    end
+
+    def call_with_arg_get_argsize(addr, argnum)
+      argnum * 8
+    end
+
+    def call_with_arg(addr, argnum, argsize)
+      fainfo = funcarg_info
+
+      orgaddress = @asm.current_address
+      code = ""
+      code += @asm.update_state(mov(RAX, OpImmidiate32.new(argnum)))
+      code += @asm.update_state(call(addr))
+      callpos = @asm.current_address - @asm.output_stream.base_address
+      if @asm.retry_mode != :change_op then
+        return [code, callpos]
+      end
+
+      offset = @funcarg_info.area_allocate_pos.pop
+      if offset then
+        imm = OpImmidiate8.new(argsize)
+        code += @asm.update_state(add(SPR, imm))
+        alloc_argument_area = lambda {
+          @asm.with_current_address(@asm.output_stream.base_address + offset) {
+            @asm.output_stream[offset] = sub(SPR, argsize)
+          }
+        }
+        @asm.after_patch_tab.push alloc_argument_area
+      end
+
+      @funcarg_info.update_maxargs(argnum)
+      @funcarg_info.used_arg_tab.pop
+
+=begin
+      # Save already stored restorer
+      uat = @funcarg_info.used_arg_tab.last
+      while !fainfo.empty? do
+        nreg = fainfo.pop
+        if argpos = ARGPOS2REG.index(nreg) then
+          if uat[argpos] then
+            fainfo.push nreg
+            break
+          else
+            code += @asm.update_state(pop(nreg))
+            uat[argpos] = true
+          end
+        else
+          fainfo.push nreg
+          break
+        end
+      end
+=end
+
+      @asm.current_address = orgaddress
+
+      [code, callpos]
+    end
+  end  
+end

data/lib/ytljit/asmext_x86.rb

@@ -0,0 +1,128 @@
+module YTLJit
+  module FunctionArgumentX86Mixin
+    include AbsArch
+
+    def size
+      case @abi_kind
+      when :c 
+        AsmType::MACHINE_WORD.size
+
+      when :ytl
+        8
+      end
+    end
+
+    def dst_opecode
+      OpIndirect.new(SPR, OpImmidiate8.new(@no * size))
+    end
+
+
+    def src_opecode
+      # AsmType::MACHINE_WORD.size is return address slot
+      offset = AsmType::MACHINE_WORD.size + @no * size
+      OpIndirect.new(SPR, offset)
+    end
+
+    def gen_access_dst(gen, inst, dst, src, src2)
+      argdst =  dst_opecode
+      code = ""
+      asm = gen.asm
+      fainfo = gen.funcarg_info
+      if @no == 0 then
+        offset = asm.offset
+        code += asm.update_state(gen.sub(SPR, fainfo.maxargs * size))
+        fainfo.area_allocate_pos.push offset
+        fainfo.used_arg_tab.push Hash.new
+      end
+
+      if asm.retry_mode != :change_op then
+        # if retry mode fainfo.used_arg_tab is deleted
+        fainfo.used_arg_tab.last[@no] = size
+      end
+      if src.is_a?(OpRegXMM) then
+        code += asm.update_state(gen.movsd(argdst, src))
+      else
+        if inst == :mov and !src.is_a?(OpRegistor) then
+          code += asm.update_state(gen.send(inst, TMPR, src))
+          code += asm.update_state(gen.mov(argdst, TMPR))
+        else
+          code += asm.update_state(gen.mov(argdst, src))
+        end
+      end
+      code
+    end
+
+    # Access the passing argument from caller
+    # You can use only between entering the function and change value of
+    #  stack pointer.
+    #
+    def gen_access_src(gen, inst, dst, src, src2)
+      asm = gen.asm
+      fainfo = gen.funcarg_info
+      code = ""
+      code += asm.update_state(gen.mov(TMPR, src_opecode))
+      code += asm.update_state(gen.send(inst, src, TMPR))
+      code
+    end
+  end
+
+  module GeneratorExtendX86Mixin
+    include AbsArch
+
+    def mov64(dst, src)
+      case dst
+      when OpIndirect
+        case src
+          when Integer
+          disp = dst.disp
+          dst2 = dst.class.new(dst.reg, disp + 4)
+          bit32val = 1 << 32
+          code = mov(dst2, src / bit32val)
+          code += mov(dst, src % bit32val)
+          code
+        else
+          nosupported_addressing_mode(:mov64, dst, src)
+        end
+      else
+        nosupported_addressing_mode(:mov64, dst, src)
+      end
+    end
+
+    def call_with_arg_get_argsize(addr, argnum)
+      argsize = 0
+      argnum.times do |i| 
+        if @funcarg_info.used_arg_tab.last[i] then
+          argsize += @funcarg_info.used_arg_tab.last[i]
+        else
+          STDERR.print "Wanrnning arg not initialized -- #{i}\n"
+          argsize += 4
+        end
+      end
+      argsize
+    end
+
+    def call_with_arg(addr, argnum, argsize)
+      orgaddress = @asm.current_address
+      code = @asm.update_state(call(addr))
+      callpos = @asm.current_address - @asm.output_stream.base_address
+      if @asm.retry_mode == :change_op then
+        return [code, callpos]
+      end
+
+      code += @asm.update_state(add(SPR, OpImmidiate8.new(argsize)))
+      offset = @funcarg_info.area_allocate_pos.pop
+      alloc_argument_area = lambda {
+        asm.with_current_address(asm.output_stream.base_address + offset) {
+          asm.output_stream[offset] = sub(SPR, argsize)
+        }
+      }
+      asm.after_patch_tab.push alloc_argument_area
+
+      @funcarg_info.update_maxargs(argnum)
+      @funcarg_info.used_arg_tab.pop
+      @asm.current_address = orgaddress
+      
+      [code, callpos]
+    end
+  end
+end  

data/lib/ytljit/asmutil.rb

@@ -0,0 +1,182 @@
+module YTLJit
+  module SSE
+    XMM0 = OpRXMM0.instance
+    XMM1 = OpRXMM1.instance
+    XMM2 = OpRXMM2.instance
+    XMM3 = OpRXMM3.instance
+    XMM4 = OpRXMM4.instance
+    XMM5 = OpRXMM5.instance
+    XMM6 = OpRXMM6.instance
+    XMM7 = OpRXMM7.instance
+  end
+
+  module SSE64
+    XMM8 = OpRXMM8.instance
+    XMM9 = OpRXMM9.instance
+    XMM10 = OpRXMM10.instance
+    XMM11 = OpRXMM11.instance
+    XMM12 = OpRXMM12.instance
+    XMM13 = OpRXMM13.instance
+    XMM14 = OpRXMM14.instance
+    XMM15 = OpRXMM15.instance
+  end
+
+  module X86
+    EAX = OpEAX.instance
+    EDX = OpEDX.instance
+    ECX = OpECX.instance
+    EBX = OpEBX.instance
+    ESP = OpESP.instance
+    EBP = OpEBP.instance
+    ESI = OpESI.instance
+    EDI = OpEDI.instance
+
+    AL = OpAL.instance
+    CL = OpCL.instance
+    DL = OpDL.instance
+    BL = OpBL.instance
+
+    INDIRECT_EAX = OpIndirect.new(EAX)
+    INDIRECT_EDX = OpIndirect.new(EDX)
+    INDIRECT_ECX = OpIndirect.new(ECX)
+    INDIRECT_EBX = OpIndirect.new(EBX)
+    INDIRECT_ESP = OpIndirect.new(ESP)
+    INDIRECT_EBP = OpIndirect.new(EBX)
+    INDIRECT_ESI = OpIndirect.new(ESI)
+    INDIRECT_EDI = OpIndirect.new(EDI)
+
+    include SSE
+  end
+
+  module X64
+    RAX = OpRAX.instance
+    RDX = OpRDX.instance
+    RCX = OpRCX.instance
+    RBX = OpRBX.instance
+    RSP = OpRSP.instance
+    RBP = OpRBP.instance
+    RSI = OpRSI.instance
+    RDI = OpRDI.instance
+
+    R8 = OpR8.instance
+    R9 = OpR9.instance
+    R10 = OpR10.instance
+    R11 = OpR11.instance
+    R12 = OpR12.instance
+    R13 = OpR13.instance
+    R14 = OpR14.instance
+    R15 = OpR15.instance
+
+    INDIRECT_RAX = OpIndirect.new(RAX)
+    INDIRECT_RDX = OpIndirect.new(RDX)
+    INDIRECT_RCX = OpIndirect.new(RCX)
+    INDIRECT_RBX = OpIndirect.new(RBX)
+    INDIRECT_RSP = OpIndirect.new(RSP)
+    INDIRECT_RBP = OpIndirect.new(RBX)
+    INDIRECT_RSI = OpIndirect.new(RSI)
+    INDIRECT_RDI = OpIndirect.new(RDI)
+
+    include SSE
+    include SSE64
+  end
+
+  module AbsArch
+    AL = OpAL.instance
+    CL = OpCL.instance
+    DL = OpDL.instance
+    BL = OpBL.instance
+
+    include SSE
+    case $ruby_platform
+    when /i.86/
+      TMPR = OpEAX.instance
+      TMPR2 = OpEDX.instance
+      TMPR3 = OpECX.instance
+      RETR = OpEAX.instance
+      SPR = OpESP.instance
+      BPR = OpEBP.instance
+    when /x86_64/
+      TMPR = OpRAX.instance
+#      TMPR2 = OpRDX.instance
+#      TMPR3 = OpRCX.instance
+      TMPR2 = OpR10.instance
+      TMPR3 = OpR11.instance
+      RETR = OpRAX.instance
+      SPR = OpRSP.instance
+      BPR = OpRBP.instance
+    end
+    INDIRECT_TMPR = OpIndirect.new(TMPR)
+    INDIRECT_TMPR2 = OpIndirect.new(TMPR2)
+    INDIRECT_RETR = OpIndirect.new(RETR)
+    INDIRECT_SPR = OpIndirect.new(SPR)
+    INDIRECT_BPR = OpIndirect.new(BPR)
+    FUNC_ARG = Hash.new {|hash, key| 
+      hash[key] = FunctionArgumentInt.new(key, :c)
+    }
+    FUNC_FLOAT_ARG = Hash.new {|hash, key| 
+      hash[key] = FunctionArgumentFloat.new(key, :c)
+    }
+    FUNC_ARG_YTL = Hash.new {|hash, key| 
+      hash[key] = FunctionArgumentInt.new(key, :ytl)
+    }
+    FUNC_FLOAT_ARG_YTL = Hash.new {|hash, key| 
+      hash[key] = FunctionArgumentFloat.new(key, :ytl)
+    }
+  end
+
+  module InternalRubyType
+    include AbsArch
+    VALUE = AsmType::MACHINE_WORD
+    P_CHAR = AsmType::Pointer.new(AsmType::INT8)
+
+    RBasic = AsmType::Struct.new(
+              VALUE, :flags,
+              VALUE, :klass
+             )
+    RString = AsmType::Struct.new(
+               RBasic, :basic,
+               AsmType::Union.new(
+                AsmType::Struct.new(
+                 AsmType::INT32, :len,
+                 P_CHAR, :ptr,
+                 AsmType::Union.new(
+                   AsmType::INT32, :capa,
+                   VALUE, :shared,
+                 ), :aux
+                ), :heap,
+                AsmType::Array.new(
+                   AsmType::INT8,
+                   24
+                ), :ary
+               ), :as
+              )
+
+    RFloat = AsmType::Struct.new(
+               RBasic, :basic,
+               AsmType::DOUBLE, :float_value
+              )
+
+    EMBEDER_FLAG = (1 << 13)
+    def self.rstring_ptr(str, csstart, cscont)
+      cs_embed = CodeSpace.new
+
+      asm = Assembler.new(csstart)
+      rsstr = TypedData.new(InternalRubyType::RString, str)
+      # asm.step_mode = true
+      asm.with_retry do
+        asm.mov(TMPR, rsstr[:basic][:flags])
+        asm.and(TMPR, EMBEDER_FLAG)
+        asm.jz(cs_embed.var_base_address)
+        asm.mov(TMPR, rsstr[:as][:heap][:ptr])
+        asm.jmp(cscont.var_base_address)
+      end
+
+      asm = Assembler.new(cs_embed)
+      # asm.step_mode = true
+      asm.with_retry do
+        asm.mov(TMPR, rsstr[:as][:ary])
+        asm.jmp(cscont.var_base_address)
+      end
+    end
+  end
+end

data/lib/ytljit/codespace.rb

@@ -0,0 +1,92 @@
+module YTLJit
+  class CodeSpace
+    @@disasm_cache = {}
+    @@disasmed_codespace = {}
+    def self.disasm_cache
+      @@disasm_cache
+    end
+
+    def initialize
+      @refer_operands = []
+      reset
+    end
+
+    attr :disasm_cache
+    attr :refer_operands
+
+    def reset
+      @org_base_address = base_address
+      self.current_pos = 0
+    end
+
+    def emit(code)
+      self[self.current_pos] = code
+    end
+
+    def var_base_address(offset = 0)
+      func = lambda {
+        base_address + offset
+      }
+      ovi32 = OpVarMemAddress.new(func)
+      @refer_operands.push ovi32
+      ovi32
+    end
+
+    def var_base_immidiate_address(offset = 0)
+      func = lambda {
+        base_address + offset
+      }
+      ovi32 = OpVarImmidiateAddress.new(func)
+      @refer_operands.push ovi32
+      ovi32
+    end
+
+    def update_refer
+      @refer_operands.each do |refop|
+        refop.refer.each do |stfn|
+          stfn.call
+        end
+      end
+    end
+
+    def fill_disasm_cache
+      if @@disasmed_codespace[self] then
+        return
+      end
+      @@disasmed_codespace[self] = true
+      tmpfp = Tempfile.open("ytljitcode")
+      tmpfp.write 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=#{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=#{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=#{base_address} #{tmpfp.path}"
+        objdump_cmd = "objdump -M i386 -D #{tmpfp.path}"
+      end
+      system(objcopy_cmd)
+      File.popen(objdump_cmd, "r") {|fp|
+        fp.readlines.each do |lin|
+          if /([0-9a-f]*):(\t[0-9a-f ]+? *\t.*)/ =~ lin then
+            @@disasm_cache[$1] = $2
+          end
+        end
+      }
+    end
+
+    def disassemble
+      fill_disasm_cache
+      @@disasm_cache.each do |add, asm|
+        print "#{add}:  #{asm}\n"
+      end
+    end
+  end
+end

data/lib/ytljit/error.rb

@@ -0,0 +1,7 @@
+module YTLJit
+  class AsmError<RuntimeError
+  end
+
+  class IlligalOperand<AsmError
+  end
+end