ytljit 0.0.1

data/lib/ytljit/instruction_x64.rb

@@ -0,0 +1,41 @@
+module YTLJit
+  module AssemblerUtilX64
+    def rex(dst, src)
+      rrex = 0
+      if dst.is_a?(OpReg64) then
+        rrex |= 0b1000
+        if dst.reg_no >= 8 then
+          rrex |= 0b1
+        end
+      end
+
+      if src.is_a?(OpReg64) then
+        rrex |= 0b1000
+        if src.reg_no >= 8 then
+          rrex |= 0b100
+        end
+      end
+
+      if src.is_a?(OpImmidiate64) then
+        rrex |= 0b1000
+      end
+
+      if rrex != 0 then
+        [[0x40 + rrex], "C"]
+      else
+        [[], ""]
+      end
+    end
+
+    def immidiate_call(addr, offset)
+      if offset.abs > 0x7fff_ffff then
+        addrent = @asm.add_value_entry(addr)
+        offset = addrent.value - @asm.current_address - 7
+        modseq, modfmt = modrm(:call, 2, offset, nil, addr)
+        [0x48, 0xff, *modseq, offset].pack("CC#{modfmt}L")
+      else
+        [0xe8, offset].pack("CL")
+      end
+    end
+  end
+end

data/lib/ytljit/instruction_x86.rb

@@ -0,0 +1,11 @@
+module YTLJit
+  module AssemblerUtilX86
+    def rex(dst, src)
+      [[], ""]
+    end
+
+    def immidiate_call(addr, offset)
+      [0xe8, offset].pack("CL")
+    end
+  end
+end

data/lib/ytljit/marshal.rb

@@ -0,0 +1,133 @@
+class Proc
+  @@iseq_cache = {}
+  
+  def self._alloc
+    Proc.new {}
+  end
+
+  def _dump_data
+    orgiseq = self.to_iseq
+    piseq = @@iseq_cache[orgiseq]
+    if !piseq then
+      piseq = @@iseq_cache[orgiseq] = patch_iseq(orgiseq.to_a)
+    end
+      
+    [piseq, self.binding.to_a]
+  end
+
+  def _load_data(obj)
+    iseq, env = obj
+    slf = env[0][0]
+    $_proc_para = [env, slf]
+    prc = lambda {
+      $_proc_para[1].instance_eval {
+        lambda {|env|
+          _lambda_replace
+        }
+      }.call($_proc_para[0].map {|ele| ele.reverse})
+    }
+    
+    prc2 =  VMLib::InstSeqTree.new(nil, prc.to_iseq.to_a)
+    iv = VMLib::InstSeqTree.new(nil, prc2.body[7][3])
+    lam = VMLib::InstSeqTree.new(nil, iv.body[5][3])
+    lam.body[4][1] = :lambda
+    lam.body[4][3] = iseq
+    
+    prc2.header['type'] = :top
+      
+    self.copy(ISeq.load(prc2.to_a).eval)
+  end
+
+  def patch_iseq(iseq, dbase = 0)
+    rbody = []
+    iseq2 = VMLib::InstSeqTree.new(nil, iseq)
+    
+    iseq2.body.each do |ele|
+      rbody.push ele
+      if ele.is_a?(Array) then
+        case ele[0]
+        when :send
+          if ele[3] then
+            ele[3] = patch_iseq(VMLib::InstSeqTree.new(iseq, ele[3]), dbase + 1)
+          end
+                       
+        when :getdynamic
+          off = ele[1]
+          dep = ele[2]
+          if dep > dbase then
+            rbody.pop
+            rbody.push [:getdynamic, 3, 1 + dbase]
+            rbody.push [:putobject, dep - 1 - dbase]
+            rbody.push [:opt_aref, 0]
+            rbody.push [:putobject, off]
+            rbody.push [:opt_aref, 0]
+          end
+          
+        when :setdynamic
+          off = ele[1]
+          dep = ele[2]
+          if dep > dbase then
+            rbody.pop
+            rbody.push [:getdynamic, 3, 1 + dbase]
+            rbody.push [:putobject, dep - 1 - dbase]
+            rbody.push [:opt_aref, 0]
+            rbody.push [:putobject, off]
+            rbody.push [:topn, 2]
+            rbody.push [:send, :[]=, 2, nil, 0, 0]
+            rbody.push [:swap]
+            rbody.push [:pop]
+          end
+          
+        when :getlocal
+          off = ele[1]
+          rbody.pop 
+          rbody.push [:getdynamic, 2, 1 + dbase]
+          rbody.push [:dup]
+          rbody.push [:opt_length]
+          rbody.push [:putobject, 1]
+          rbody.push [:opt_sub]
+          rbody.push [:putobject, dbase]
+          rbody.push [:opt_add]
+          rbody.push [:opt_aref, 0]
+          rbody.push [:putobject, off]
+          rbody.push [:opt_aref, 0]
+          
+        when :setlocal
+          off = ele[1]
+          rbody.pop 
+          rbody.push [:getdynamic, 2, 1 + dbase]
+          rbody.push [:dup]
+          rbody.push [:opt_length]
+          rbody.push [:putobject, 1]
+          rbody.push [:opt_sub]
+          rbody.push [:putobject, dbase]
+          rbody.push [:opt_add]
+          rbody.push [:opt_aref, 0]
+          rbody.push [:putobject, off]
+          rbody.push [:topn, 2]
+          rbody.push [:send, :[]=, 2, nil, 0, 0]
+          rbody.push [:swap]
+          rbody.push [:pop]
+        end
+      end
+    end
+    
+    iseq2.body = rbody
+    iseq2.to_a
+  end
+end
+
+module YTLJit
+  class CodeSpace
+    def _dump_data
+      [@refer_operands, current_pos, code]
+    end
+
+    def _load_data(obj)
+      self[0] = obj.pop
+      current_pos = obj.pop
+      @org_base_address = base_address
+      @refer_operands = obj.pop
+    end
+  end
+end

data/lib/ytljit/matcher.rb

@@ -0,0 +1,235 @@
+# Pattern matcher
+# Usage
+#     When pattern matched, block is yielded with argument is hash that maps
+#    symbol to value.
+#
+#    mat = Matcher.new
+#    mat.pattern([:a, :b]) {|hash|
+#       p hash
+#    }
+#    mat.match([1, 2])
+#
+#    Output "{:a => 1, :b => 2}"
+#
+#    [Class_Name, Symbol] is special case.
+#    Match when class of corresponding value is Class_Name. And bind
+#    Symbol in argument hash of block.
+#
+#    mat.pattern([:a, [Array, :d]]) {|hash|
+#       p hash
+#    }
+#    mat.match([1, [3, 4, 5]])
+#
+#   Output "{:a=>1, :d=>[3, 4, 5]}"
+#
+#
+#    You can use multiple patterns
+#    When multiple patterns matched execute a block for 1 pattern. But 
+#    execution pattern  is undefined.
+#
+#  mat = Matcher.new
+#  mat.pattern([:a, :b]) {|hash|
+#    p hash
+#  }
+#  mat.pattern(:a) {|hash|
+#    p hash
+#  }
+#  mat.pattern([:a, [:b, :d]]) {|hash|
+#    p hash
+#  }
+#  mat.pattern([:a, [Array, :d], :c]) {|hash|
+#    p hash
+#  }
+#  mat.match([1, [2, 3]])  # => {:a=>1, :b=>[2, 3]}
+#  mat.match([1, [2, 3], 4]) # => {:a=>1, :d=>[2, 3], :c=>4}
+#  mat.match([1, [2, 3], 4, 5]) # => {:a=>[1, [2, 3], 4, 5]}
+#
+
+#
+class QuotedObj
+  def self.quote(obj)
+    self.new(obj)
+  end
+
+  def initialize(obj)
+    @obj = obj
+  end
+
+  attr :obj
+end
+
+class Matcher
+  def initialize
+    @cache = {}
+    @code = nil
+    @pattern = []
+  end
+
+  def match(src)
+    unless @code
+      compile
+    end
+    @src = src
+    @code.eval
+  end
+  
+  def pattern(pat, &block)
+    unless @code
+      @pattern.push [pat, block]
+    end
+  end
+  
+  def compile
+    info = {}
+    @pattern.each do |pat|
+      env = {}
+      cond = compile_aux(pat[0], [], env, [])[0]
+      info[cond] = [env, pat[1]]
+    end
+    @code = code_gen(info)
+  end
+
+  def compile_aux(pat, stack, env, cond)
+    status = :normal
+    case pat
+    when Array
+      if pat[0].is_a?(Class) then
+        cond.push "(#{get_patref(stack)}.is_a?(#{pat[0]}))"
+        env[pat[1]] = "#{get_patref(stack)}"
+      else
+        cond.push "(#{get_patref(stack)}.is_a?(Array))"
+        stack.push 0
+        pat.each_with_index do |ele, i|
+          stack[-1] = i
+          cond, st = compile_aux(ele, stack, env, cond)
+          if st == :return then
+            stack.pop
+            return [cond, status]
+          end
+        end
+        stack[-1] = pat.size
+        cond.push "(#{get_patref(stack)} == nil)"
+        stack.pop
+      end
+      
+    when Symbol
+      patstr = pat.to_s
+      if patstr[0] == '_' then
+        npat = patstr[1..-1].to_sym
+        if env[npat] then
+          cond.push "#{get_patref_rest(stack)} == #{env[npat]}"
+        else
+          env[npat] = get_patref_rest(stack)
+        end
+        status = :return
+      else
+        if env[pat] then
+          cond.push "(#{get_patref(stack)}.is_a?(Symbol) or #{get_patref(stack)} == #{env[pat]})"
+        else
+          env[pat] = get_patref(stack).to_s
+        end
+      end
+
+    when QuotedObj
+      cond.push "(#{get_patref(stack)} == #{pat.obj.inspect})"
+
+    else
+      cond.push "(#{get_patref(stack)} == #{pat})"
+    end
+
+    return [cond, status]
+  end
+
+  def get_patref(stack)
+    code = "@src"
+    stack.each do |n|
+      code += "[#{n}]"
+    end
+    code
+  end
+
+  def get_patref_rest(stack)
+    code = "@src"
+    top = stack.pop
+    stack.each do |n|
+      code += "[#{n}]"
+    end
+    code += "[#{top}.. -1]"
+    stack.push top
+    code
+  end
+
+  def code_gen(info)
+    ct = {}
+    info.each do |carr, val|
+      cursor = ct
+      carr.each do |cele|
+        cursor[cele] ||= {}
+        cursor = cursor[cele]
+      end
+      cursor[nil] = val
+    end
+
+    code = <<-EOS
+    org_self = self
+    ObjectSpace._id2ref(#{self.object_id}).instance_eval do 
+      #{cond_gen(ct, 0)} 
+    end
+EOS
+    RubyVM::InstructionSequence.compile(code)
+  end
+
+  def cond_gen(tr, level)
+    code = ""
+    tr.each do |cond, nxt|
+      if cond then
+        code << "if #{cond} then \n"
+        code << cond_gen(nxt, level + 1)
+        code << "end\n"
+      end
+    end
+    if tr[nil] then
+      code << "#{exec_gen(tr[nil])} \n"
+    end
+    code
+  end
+
+  def exec_gen(para)
+    hash = "{"
+    para[0].each do |key, value|
+      hash << ":#{key} => #{value},"
+    end
+    hash << "}"
+    
+    proc = para[1]
+    "break ObjectSpace._id2ref(#{proc.object_id}).call(#{hash})"
+  end
+end
+
+if __FILE__ == $0 then
+  mat = Matcher.new
+  mat.pattern([:a, :b]) {|hash|
+    p hash
+  }
+  mat.pattern([:a, :_b]) {|hash|
+    p hash
+  }
+  mat.pattern(:a) {|hash|
+    p hash
+  }
+  mat.pattern([:a, [:b, :_c], 1]) {|hash|
+    p hash
+  }
+  mat.pattern([:a, [Array, :d], :c]) {|hash|
+    p hash
+  }
+  mat.pattern([QuotedObj.quote(:a), [Array, :d], :c]) {|hash|
+    p hash
+  }
+  mat.match([1, [2, 3]])
+  mat.match([1, [2, 3, 4], 4, :a])
+  mat.match([1, [2, 3, 4], 1])
+  mat.match([1, [2, 3], 4, 5])
+  mat.match([:a, [2, 3], 2 ])
+end
+

data/lib/ytljit/rubyvm.rb

@@ -0,0 +1,63 @@
+# -*- coding: cp932 -*-
+#
+#  rubyvm.rb - structured bytecode library
+#
+#
+module VMLib
+  class InstSeqTree
+    Headers = %w(magic major_version minor_version format_type
+                 misc name filename filepath line type locals args 
+                 exception_table)
+
+#  call-seq:
+#     VMLib::InstSeqTree.new(parent, iseq)
+#        parent  Partent of InstSeqTree
+#                For example, when you will construct InstSeqTree of
+#                the method body, you must 'parent' is InstSeqTree of definition
+#                code of the method.
+#                If parent is none, 'parent' is nil.
+#        iseq    Instruction Sequence, Normally the result of 
+#                VM::InstructionSequence.compile(...) or 
+#                VM::InstructionSequence.compile_file(...)
+    def initialize(parent = nil, iseq = nil)
+      @lblock = {}
+      @lblock_list = [nil]
+
+      @header = {}
+      @body = nil
+      @parent = parent
+
+      Headers.each do |name|
+        @header[name] = nil
+      end
+      
+      if iseq then
+        init_from_ary(iseq.to_a)
+      end
+    end
+
+    attr          :header
+    attr_accessor :body
+    attr          :parent
+    
+    def init_from_ary(ary)
+      i = 0
+      Headers.each do |name|
+        @header[name] = ary[i]
+        i = i + 1
+      end
+
+      @body = ary[i]
+    end
+
+    def to_a
+      res = []
+      Headers.each do |name|
+        res.push @header[name]
+      end
+      
+      res.push @body
+      res
+    end
+  end
+end

data/lib/ytljit/struct.rb

@@ -0,0 +1,125 @@
+module YTLJit
+  module AsmType
+    class StructMember<TypeCommon
+      def initialize(type, offset)
+        @type = type
+        @offset = offset
+      end
+
+      attr :offset
+
+      def size
+        @type.size
+      end
+
+      def [](name)
+        @type[name, @offset]
+      end
+    end
+
+    class Struct<TypeCommon
+      def initialize(*spec)
+        @member = []
+        @size = nil
+        stat = 0
+        curvar = []
+        spec.each do |token|
+          case stat
+          when 0
+            curvar.push token
+            stat = 1
+            
+          when 1
+            curvar.push token
+            stat = 2
+            
+          when 2
+            if token.is_a?(Integer) then
+              curvar.push token
+              @member.push curvar
+              curvar = []
+              stat = 0
+            else
+              @member.push curvar
+              if token then
+                curvar = [token]
+                stat = 1
+              else
+                curvar = []
+                stat = 0
+              end
+            end
+          end
+          # assert(stat == 0)
+        end
+        @member.push curvar
+      end
+
+      def offset_of(name, base = 0)
+        offset = 0
+        @member.each do |e|
+          if e[1] == name then
+            return offset + base
+          end
+          offset += e[2] ? e[2] : e[0].size
+        end
+        raise "No such member #{name} in #{self}"
+      end
+
+      def type_of(name)
+        offset = 0
+        @member.each do |e|
+          if e[1] == name then
+            return e[0]
+          end
+        end
+        raise "No such member #{name} in #{self}"
+      end
+
+      def size
+        if @size then
+          @size
+        else
+          @size = 0
+          @member.each do |e|
+            @size += e[2] ? e[2] : e[0].size
+          end
+          @size
+        end
+      end
+
+      def [](name, base = 0)
+        offset = 0
+        @member.each do |e|
+          if e[1] == name then
+            return StructMember.new(e[0], offset + base)
+          end
+          offset += e[2] ? e[2] : e[0].size
+        end
+        raise "No such member #{name} in #{self}"
+      end
+    end
+
+    class Union<Struct
+      def offset_of(name, base = 0)
+        base
+      end
+
+      def size
+        if @size then
+          @size
+        else
+          @size = 0
+          @member.each do |e|
+            @size = [@size, e[2] ? e[2] : e[0].size].max
+          end
+          @size
+        end
+      end
+
+      def [](name, base = 0)
+        StructMember.new(type_of(name), base)
+      end
+    end
+  end
+end

data/lib/ytljit/type.rb

@@ -0,0 +1,112 @@
+module YTLJit
+
+  module AsmType
+    class TypeCommon
+      def initialize
+        @type = nil
+        @size = nil
+        @alignment = nil
+      end
+
+      attr :type
+      attr :size
+      attr :alignment
+    end
+
+    class Scalar<TypeCommon
+      def initialize(size, align = 4, kind = :int)
+        @size = size
+        @alignment = align
+        @kind = kind
+      end
+    end
+
+    class PointedData<TypeCommon
+      def initialize(type, index, offset)
+        @type = type
+        @index = index
+        @offset = offset
+      end
+
+      attr :index
+      attr :offset
+
+      def size
+        @reftype.size
+      end
+
+      def alignment
+        @reftype.alignment
+      end
+    end
+    
+    class Pointer<TypeCommon
+      def initialize(type)
+        @type = type
+      end
+      
+      def size
+        MACHINE_WORD.size
+      end
+      
+      def alignment
+        MACHINE_WORD.alignment
+      end
+      
+      def [](n = 0, offset = 0)
+        PointedData.new(@reftype, n, offset)
+      end
+    end
+
+    class Array<TypeCommon
+      def initialize(type, size)
+        @type = type
+        @size = size
+      end
+
+      def size
+        @size * @type.size
+      end
+
+      def alignment
+        @type.alignment
+      end
+      
+      def [](n = 0, offset = 0)
+        PointedData.new(@reftype, n, offset)
+      end
+    end
+    
+    @@type_table = {}
+    def self.deftype(name, tinfo)
+      type = Scalar.new(*tinfo)
+      const_set(name.to_s.upcase, type)
+      @@type_table[name] = type
+    end
+    
+    def self.type_table
+      @@type_table
+    end
+    
+    deftype :void, [0, 1]
+    deftype :int8, [1, 1]
+    deftype :sint8, [1, 1]
+    deftype :uint8, [1, 1]
+    deftype :int16, [2, 2]
+    deftype :uint16, [2, 2]
+    deftype :int32, [4, 4]
+    deftype :uint32, [4, 4]
+    deftype :int64, [8, 8]
+    deftype :uint64, [8, 8]
+    deftype :double, [8, 8]
+    deftype :float, [4, 4]
+
+    case $ruby_platform
+    when /i.86/ 
+      deftype :machine_word, [4, 4]
+
+    when /x86_64/
+      deftype :machine_word, [8, 8]
+    end
+  end
+end