ytljit 0.0.1

data/lib/ytljit/vm_type.rb

@@ -0,0 +1,299 @@
+module YTLJit
+  module TypeUtil
+    class KlassTree
+      def initialize(defkey = [], defval = [])
+        @node = KlassTreeNode.new(defkey, defval)
+      end
+
+      def add(key, value)
+        cnode = @node
+        snode = @node
+        ocnode = nil
+        while cnode
+          ocnode = cnode
+          if key == cnode.key then
+            return cnode
+          end
+          
+          if key.zip(cnode.key).all? {|k, n| k.is_a?(n.class)}  then
+            cnode = cnode.same_klass
+            if cnode == nil then
+              ocnode.same_klass = KlassTreeNode.new(key, value)
+              return ocnode.same_klass
+            else
+              snode = cnode
+            end
+          else
+            cnode = cnode.next_klass
+            if cnode == nil then
+              ocnode.next_klass = KlassTreeNode.new(key, value)
+              return ocnode.next_klass
+            end
+          end
+        end
+      end
+
+      def search(key)
+        cnode = @node
+
+        while cnode
+          if key == cnode.key then
+            return cnode
+          end
+
+          if key.zip(cnode.key).all? {|a, b| 
+              if a then
+                atype = a.ruby_type
+
+                if b then
+                  btype = b.ruby_type
+                  btype.is_a?(atype.class) 
+                else
+                  nil
+                end
+              else
+                return !b
+              end
+            } then
+            cnode = cnode.same_klass
+          else
+            cnode = cnode.next_klass
+          end
+        end
+        
+        nil
+      end
+    end
+
+    class KlassTreeNode
+      def initialize(key, value)
+        @same_klass = nil
+        @next_klass = nil
+
+        @key = key
+        @value = value
+      end
+
+      attr_accessor :same_klass
+      attr_accessor :next_klass
+      attr          :key
+      attr_accessor :value
+    end
+
+    class TypeContainer
+      def initialize
+        @types_tree = KlassTree.new
+      end
+
+      def to_key(context, offset = -1)
+        context.current_method_signature[offset]
+      end
+
+      def search_types(key)
+        @types_tree.search(key)
+      end
+
+      def add_type(key, type)
+        tvs = @types_tree.search(key)
+        if tvs then
+          tvsv = tvs.value
+          if !tvsv.include? type then
+            tvsv.push type
+          end
+        else
+          # inherit types of most similar signature 
+          ival = []
+          simnode = @types_tree.add(key, ival)
+=begin
+          simnode.value.each do |ele|
+            ival.push ele
+          end
+=end
+
+          if !ival.include? type then
+            ival.push type
+          end
+        end
+      end
+
+      def add_node(key)
+        # inherit types of most similar signature 
+        ival = []
+        simnode = @types_tree.add(key, ival)
+=begin
+        simnode.value.each do |ele|
+          ival.push ele
+        end
+=end
+
+        simnode
+      end
+
+      def type_list(key)
+        res = search_types(key)
+        if res == nil then
+          res = add_node(key)
+        end
+        
+        res
+      end
+    end
+  end
+
+  module RubyType
+    def self.define_wraped_class(klass, base = RubyTypeBoxed)
+      cn = nil
+
+      if klass then
+        cn = klass.name.to_sym
+        basett, boxtt, unboxtt = BaseType.type_tab
+        if boxtt[cn] == nil then
+          BaseType.related_ruby_class(klass, base)
+        end
+
+        boxobj = boxtt[cn]
+        unboxobj = unboxtt[cn]
+        [boxobj, unboxobj]
+      end
+    end
+          
+    class BaseType
+      @@base_type_tab = {}
+      @@boxed_type_tab = {}
+      @@unboxed_type_tab = {}
+
+      def self.type_tab
+        [@@base_type_tab, @@boxed_type_tab, @@unboxed_type_tab]
+      end
+
+      def self.related_ruby_class(klass, base)
+        baseslf = base.new(klass)
+        boxslf = RubyTypeBoxed.new(klass)
+        unboxslf = RubyTypeUnboxed.new(klass)
+
+        klass.ancestors.reverse.each do |curcls|
+          box_unbox = base.name.gsub(/.*::Ruby/, "")
+          mixinname = curcls.name + box_unbox + "CodeGen"
+          begin
+            mixin = VM::TypeCodeGen.const_get(mixinname)
+            baseslf.extend mixin
+          rescue NameError
+          end
+
+          mixinname = curcls.name + "TypeBoxedCodeGen"
+          begin
+            mixin = VM::TypeCodeGen.const_get(mixinname)
+            boxslf.extend mixin
+          rescue NameError
+          end
+
+          mixinname = curcls.name + "TypeUnboxedCodeGen"
+          begin
+            mixin = VM::TypeCodeGen.const_get(mixinname)
+            unboxslf.extend mixin
+          rescue NameError
+          end
+        end
+
+        @@base_type_tab[klass] = baseslf
+        @@boxed_type_tab[klass] = boxslf
+        @@unboxed_type_tab[klass] = unboxslf
+
+        [boxslf, unboxslf]
+      end
+
+      def self.from_object(obj)
+        from_ruby_class(obj.class)
+      end
+
+      def self.from_ruby_class(rcls)
+        tobj =  @@base_type_tab[rcls]
+        if tobj == nil then
+          DefaultType0.new
+        else
+          tobj.instance
+        end
+      end
+
+      def initialize(rtype)
+        @asm_type = AsmType::MACHINE_WORD
+        @ruby_type = rtype
+      end
+
+      attr_accessor :asm_type
+      attr_accessor :ruby_type
+    end
+
+    # Same as VALUE type in MRI
+    # Type0 makes you can define "Defalut" class 
+    class DefaultType0<BaseType
+      def initialize
+        super(Object)
+      end
+
+      def boxed
+        true
+      end
+
+      def to_unbox
+        self
+      end
+
+      def to_box
+        self
+      end
+
+      def ==(other)
+        if other then
+          self.ruby_type == other.ruby_type and 
+            boxed == other.boxed
+        else
+          nil
+        end
+      end
+
+      include VM::TypeCodeGen::DefaultTypeCodeGen
+    end
+
+    class RubyTypeBoxed<BaseType
+      def boxed
+        true
+      end
+
+      def to_unbox
+        @@unboxed_type_tab[@ruby_type].instance
+      end
+
+      def to_box
+        self
+      end
+
+      include VM::TypeCodeGen::DefaultTypeCodeGen
+    end
+
+    class RubyTypeUnboxed<BaseType
+      def boxed
+        false
+      end
+
+      def to_box
+        @@boxed_type_tab[@ruby_type].instance
+      end
+
+      def to_unbox
+        self
+      end
+
+      include VM::TypeCodeGen::DefaultTypeCodeGen
+    end
+
+    YTLJit::RubyType::define_wraped_class(NilClass,  RubyTypeBoxed)
+    YTLJit::RubyType::define_wraped_class(Fixnum, RubyTypeUnboxed)
+    YTLJit::RubyType::define_wraped_class(Float, RubyTypeUnboxed)
+    YTLJit::RubyType::define_wraped_class(TrueClass, RubyTypeBoxed)
+    YTLJit::RubyType::define_wraped_class(FalseClass, RubyTypeBoxed)
+    YTLJit::RubyType::define_wraped_class(String, RubyTypeBoxed)
+    YTLJit::RubyType::define_wraped_class(Array, RubyTypeBoxed)
+    YTLJit::RubyType::define_wraped_class(Hash, RubyTypeBoxed)
+  end
+end

data/lib/ytljit/vm_type_gen.rb

@@ -0,0 +1,158 @@
+module YTLJit
+  module VM
+    module TypeCodeGen
+      module DefaultTypeCodeGen
+        def instance
+          self
+        end
+
+        def init_type
+        end
+
+        def have_element?
+          false
+        end
+
+        def gen_boxing(context)
+          context
+        end
+
+        def gen_unboxing(context)
+          context
+        end
+
+        def gen_copy(context)
+          context
+        end
+
+        def inspect
+          "{ #{boxed ? "BOXED" : "UNBOXED"} #{@ruby_type}}"
+        end
+      end
+
+      module FixnumTypeUnboxedCodeGen
+        include AbsArch
+
+        def gen_boxing(context)
+          asm = context.assembler
+          val = context.ret_reg
+          vnode = context.ret_node
+          asm.with_retry do
+            if val != TMPR then
+              asm.mov(TMPR, val)
+            end
+            asm.add(TMPR, TMPR)
+            asm.add(TMPR, OpImmidiate8.new(1))
+          end
+
+          context.set_reg_content(TMPR, vnode)
+          context.ret_reg = TMPR
+          context
+        end
+
+        def gen_unboxing(context)
+          context
+        end
+      end
+
+      module FixnumTypeBoxedCodeGen
+        include AbsArch
+
+        def gen_boxing(context)
+          context
+        end
+        
+        def gen_unboxing(context)
+          asm = context.assembler
+          val = context.ret_reg
+          vnode = context.ret_node
+          asm.with_retry do
+            if val != TMPR then
+              asm.mov(TMPR, val)
+            end
+            asm.sar(TMPR)
+          end
+          context.set_reg_content(TMPR, vnode)
+          context.ret_reg = TMPR
+          context
+        end
+      end
+
+      module FloatTypeBoxedCodeGen
+        include AbsArch
+
+        def gen_boxing(context)
+          p "boxingaaa"
+          context
+        end
+
+        def gen_unboxing(context)
+          p "inboxing"
+          context
+        end
+      end
+
+      module FloatTypeUnboxedCodeGen
+        include AbsArch
+
+        def gen_boxing(context)
+          asm = context.assembler
+          val = context.ret_reg
+          vnode = context.ret_node
+          context.start_using_reg(FUNC_FLOAT_ARG[0])
+          rbfloatnew = OpMemAddress.new(address_of("rb_float_new"))
+          asm.with_retry do
+            asm.mov(FUNC_FLOAT_ARG[0], val)
+            asm.call_with_arg(rbfloatnew, 1)
+          end
+          context.end_using_reg(FUNC_FLOAT_ARG[0])
+          context.ret_reg = RETR
+          context
+        end
+
+        def gen_unboxing(context)
+          p "unboxing"
+          context
+        end
+      end
+
+      module ArrayTypeBoxedCodeGen
+        include AbsArch
+
+        def instance
+          ni = self.dup
+          ni.instance_eval { extend ArrayTypeBoxedCodeGen }
+          ni.init
+          ni
+        end
+
+        def init
+          @element_type = nil
+        end
+
+        attr_accessor :element_type
+
+        def have_element?
+          true
+        end
+
+        def gen_copy(context)
+          p "copy"
+          context
+        end
+
+        def ==(other)
+          other.is_a?(self.class) and
+          self.class == other.class and
+          @element_type == other.element_type
+        end
+      end
+
+      module ArrayTypeUnboxedCodeGen
+        def have_element?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ytljit/vm_typeinf.rb

@@ -0,0 +1,98 @@
+module YTLJit
+  module VM
+    module Node
+      class TISelfRefNode<SelfRefNode
+        def initialize(parent)
+          super(parent)
+        end
+
+        def compile_main(context)
+          slf = context.slf
+          slfval = lambda { slf.address }
+          slfadd = OpVarImmdiateAddress.new(slfval)
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(RETR, slfadd)
+          end
+
+          context.ret_reg = RETR
+          context
+        end
+      end
+
+      class TIInstanceVarRefNode<InstanceVarRefNode
+        def initialize(parent, name)
+          super(parent, name)
+        end
+
+        def compile_main(context)
+          slf = context.slf
+          ivval = lambda { slf.instance_var_address_of(@name) }
+          ivadd = OpVarImmidiateAddress.new(ivval)
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(TMPR, ivadd)
+            asm.mov(RETR, INDIRECT_TMPR)
+          end
+
+          context.ret_reg = RETR
+          context
+        end
+      end
+
+      class TIInstanceVarAssignNode<InstanceVarAssignNode
+        def initialize(parent, name, val)
+          super(parent, name, val)
+        end
+
+        def compile_main(context)
+          context = @val.compile(context)
+          valr = context.ret_reg
+          slf = context.slf
+          ivval = lambda { slf.instance_var_address_of(@name) }
+          ivadd = OpVarImmdiateAddress.new(ivval)
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(TMPR, ivadd)
+            asm.mov(INDIRECT_TMPR, valr)
+          end
+
+          context.ret_reg = RETR
+          context
+        end
+      end
+    end
+
+    module YARVTranslatorTypeInferenceMixin
+      include Node
+
+      def initialize(parent)
+        super(parent)
+      end
+
+      def visit_putself(code, ins, context)
+        curnode = context.current_node
+        nnode = TISelfRefNode.new(curnode)
+        context.expstack.push nnode
+      end
+
+      def visit_getinstancevariable(code, ins, context)
+        curnode = context.current_node
+        node = TIInstanceVarRefNode.new(curnode, ins[1])
+        context.expstack.push node
+      end
+
+      def visit_setinstancevariable(code, ins, context)
+        val = context.expstack.pop
+        curnode = context.current_node
+        node = TiInstanceVarAssignNode.new(curnode, ins[1], val)
+        curnode.body = node
+        context.current_node = node
+      end
+    end
+
+    class YARVTranslatorTypeInference<YARVTranslatorSimple
+      include YARVTranslatorTypeInferenceMixin
+    end
+  end
+end

data/lib/ytljit.rb

@@ -0,0 +1,46 @@
+require "rubygems"
+
+require 'tempfile'
+require 'rbconfig'
+require 'pp'
+if $ruby_platform == nil then
+  $ruby_platform = RUBY_PLATFORM
+end
+# $ruby_platform = "x86_64" #  You can select CPU type for debug.
+
+require 'iseq'
+
+require "ytljit_ext"
+
+require 'ytljit/codespace'
+
+require 'ytljit/marshal'
+require 'ytljit/util'
+require 'ytljit/error'
+
+require 'ytljit/asm'
+require 'ytljit/instruction'
+require 'ytljit/instruction_x86'
+require 'ytljit/instruction_x64'
+require 'ytljit/instruction_ia'
+require 'ytljit/type'
+require 'ytljit/struct'
+require 'ytljit/asmutil'
+require 'ytljit/asmext_x86'
+require 'ytljit/asmext_x64'
+require 'ytljit/asmext'
+
+require 'ytljit/rubyvm'
+
+require 'ytljit/vm_codegen'
+require 'ytljit/vm_inspect'
+require 'ytljit/vm'
+
+require 'ytljit/vm_inline_method'
+require 'ytljit/vm_sendnode'
+
+require 'ytljit/vm_trans'
+require 'ytljit/vm_type_gen'
+require 'ytljit/vm_type'
+
+require 'ytljit/vm_typeinf'

data/test/asmsample.rb

@@ -0,0 +1,117 @@
+require 'ytljit.rb'
+
+include YTLJit
+
+# sample for file output
+def file_output
+  File.open("foo.bin", "w") {|fp|
+    asm = Assembler.new(FileOutputStream.new(fp))
+    
+    # registor definition
+    eax = OpEAX.instance
+    ecx = OpECX.instance
+    
+    asm.mov(eax, OpImmidiate32.new(0))
+    loop = asm.var_current_address
+    asm.add(eax, OpImmidiate8.new(1))
+    asm.jo(loop)
+    arynew = address_of("rb_ary_new")
+    asm.call(arynew)
+    asm.ret
+  }
+end
+
+# Hello World
+include AbsArch
+def hello
+  asm = Assembler.new(cs = CodeSpace.new)
+  
+  # registor definition
+  hello = "Hello World".address
+  asm.step_mode = true
+  asm.with_retry do
+    asm.mov(FUNC_ARG[0], hello)
+    rbp = address_of("rb_p")
+    asm.call_with_arg(rbp, 1)
+    asm.ret
+  end
+  cs.fill_disasm_cache
+  cs.disassemble
+  cs.call(cs.base_address)
+end
+hello
+
+# Hello World (Use puts)
+def hello2
+  csentry = CodeSpace.new
+  asm = Assembler.new(cs = CodeSpace.new)
+  
+  # registor definition
+  hello ="Hello World11234".address
+#  asm.step_mode = true
+  InternalRubyType::rstring_ptr(hello, csentry, cs)
+  asm.with_retry do
+    asm.mov(FUNC_ARG[0], TMPR)
+    rbp = address_of("puts")
+    asm.call_with_arg(rbp, 1)
+    asm.ret
+  end
+  cs.disassemble
+  csentry.disassemble
+  csentry.call(csentry.base_address)
+end
+hello2
+
+# 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
+
+  cs0.call(cs0.base_address)
+end
+
+(1..20).each do |i|
+  p fib(i)
+end