ytljit 0.0.6 → 0.0.7

data/lib/ytljit/vm_codegen.rb

@@ -79,14 +79,18 @@ LO        |                       |   |  |
         @modified_local_var = []
         @modified_instance_var = Hash.new
         @yield_node = []
+
+        # Options from user
+        @options = {}
       end
 
       attr          :top_node
       attr_accessor :modified_local_var
       attr_accessor :modified_instance_var
       attr_accessor :yield_node
+      attr_accessor :options
 
-      def merge_local_var(lvlist)
+      def marge_local_var(lvlist)
         res = nil
         lvlist.each do |lvs|
           if res then
@@ -112,6 +116,8 @@ LO        |                       |   |  |
         @current_method = [tnode]
         @convergent = false
         @visited_top_node = {}
+        # Options from user
+        @options = {}
       end
 
       def to_signature(offset = -1, cache = {})
@@ -128,6 +134,11 @@ LO        |                       |   |  |
             if sigc.size == 1 then
               return sigc[0]
             else
+              p offset.signature_cache
+              p i
+              p offset.debug_info
+              p @current_method.map {|e| e.debug_info}
+              p @current_method.map {|e| e.class}
               raise "I can't type inference..."
             end
           end
@@ -142,11 +153,14 @@ LO        |                       |   |  |
         end
         
         if rsig = cache[cursignode] then
+          rsig = rsig.map {|e| e.copy_type}
           return rsig
         end
 
         if curmethod.is_a?(Node::ClassTopNode) then
+          # Can't pass block when entering a class definition
           rsig = to_signature_aux(cursignode, offset, cache)
+          rsig = rsig.map {|e| e.copy_type}
           cache[cursignode] = rsig
           rsig
 
@@ -154,6 +168,7 @@ LO        |                       |   |  |
           prevsig = to_signature(offset - 1, cache)
           rsig = to_signature_aux2(curmethod, cursignode, 
                                    prevsig, offset, cache)
+          rsig = rsig.map {|e| e.copy_type}
           cache[cursignode] = rsig
           rsig
           
@@ -185,13 +200,15 @@ LO        |                       |   |  |
           res.push ele.type
         end
 
-        if mt and (ynode = mt.yield_node[0]) then
+        ynode = mt.yield_node[0]
+        if ynode then
           yargs = ynode.arguments
-          push_signature(args, mt)
+          push_signature(yargs, ynode.frame_info.parent)
           ysig = to_signature_aux3(yargs, -1, cache)
           args[1].type = nil
-          args[1].decide_type_once(ysig)
-          res[1] = args[1].type
+          res[1] = args[1].decide_type_once(ysig)
+#          p res
+#          p res[1]
           pop_signature
         end
         
@@ -203,14 +220,18 @@ LO        |                       |   |  |
           return res
         end
 
-        res = cursignode.map { |enode|
-          cursignode = @current_method_signature_node[offset]
-          sig = to_signature_aux3(cursignode, offset - 1, cache)
-          enode.decide_type_once(sig)
-        }
-        cache[cursignode] = res
-        
-        res
+        node = @current_method[offset]
+        if node.is_a?(Node::ClassTopNode) then
+          node.signature_cache[0]
+        else
+          cursignode2 = @current_method_signature_node[offset]
+          sig = to_signature_aux3(cursignode2, offset - 1, cache)
+          res = cursignode.map { |enode|
+            enode.decide_type_once(sig)
+          }
+          cache[cursignode] = res
+          res
+        end
       end
 
       def push_signature(signode, method)
@@ -227,6 +248,7 @@ LO        |                       |   |  |
       attr          :current_method_signature_node
       attr_accessor :convergent
       attr_accessor :visited_top_node
+      attr_accessor :options
     end
 
     class CompileContext
@@ -515,7 +537,7 @@ LO        |                       |   |  |
           asm.with_retry do
             asm.mov(SPR, BPR)
             asm.pop(BPR)
-            asm.pop(THEPR)
+            asm.pop(THEPR) if @is_escape != :export_object
             asm.mov(SPR, BPR)
             asm.pop(BPR)
           end
@@ -559,14 +581,38 @@ LO        |                       |   |  |
 
       def gen_alloca(context, siz)
         asm = context.assembler
-        siz = siz * AsmType::MACHINE_WORD.size
-        asm.with_retry do
-          asm.sub(THEPR, siz)
+        case siz
+        when Integer
+          add = lambda { 
+            address_of("ytl_arena_alloca")
+          }
+          alloca = OpVarMemAddress.new(add)
+          asm.with_retry do
+            asm.mov(FUNC_ARG[0], THEPR)
+            asm.mov(TMPR, siz)
+            asm.mov(FUNC_ARG[1], TMPR)
+          end
+          context = gen_call(context, alloca, 2)
+          asm.with_retry do
+            asm.mov(THEPR, RETR)
+          end
+        else
+          raise "Not implemented yet variable alloca"
         end
         context.ret_reg = THEPR
         context
       end
 
+      def gen_save_thepr(context)
+        casm = context.assembler
+        arenaaddr = context.top_node.get_arena_address
+        casm.with_retry do
+          casm.mov(TMPR, arenaaddr)
+          casm.mov(INDIRECT_TMPR, THEPR)
+        end
+        context
+      end
+
       def gen_call(context, fnc, numarg, slf = nil)
         casm = context.assembler
 
@@ -619,12 +665,14 @@ LO        |                       |   |  |
       include AbsArch
       include CommonCodeGen
 
-      def gen_make_argv(context)
+      def gen_make_argv(context, rarg = nil, argcomphook = nil)
         casm = context.assembler
-        rarg = @arguments[3..-1]
+        if rarg == nil then
+          rarg = @arguments[3..-1]
+        end
+        cursig = context.to_signature
 
         # make argv
-        casm = context.assembler
         argbyte = rarg.size * AsmType::MACHINE_WORD.size
         casm.with_retry do
           casm.sub(SPR, argbyte)
@@ -632,11 +680,15 @@ LO        |                       |   |  |
         context.cpustack_pushn(argbyte)
 
         rarg.each_with_index do |arg, i|
-          context = arg.compile(context)
-          context.ret_node.decide_type_once(context.to_signature)
-          rtype = context.ret_node.type
+          rtype = nil
+          if argcomphook then
+            rtype = argcomphook.call(context, arg, i)
+          else
+            context = arg.compile(context)
+            context.ret_node.decide_type_once(cursig)
+            rtype = context.ret_node.type
+          end
           context = rtype.gen_boxing(context)
-          casm = context.assembler
           dst = OpIndirect.new(SPR, i * AsmType::MACHINE_WORD.size)
           if context.ret_reg.is_a?(OpRegistor) or 
               context.ret_reg.is_a?(OpImmidiate32) or 
@@ -666,7 +718,6 @@ LO        |                       |   |  |
         context = yield(context, rarg)
 
         # adjust stack
-        casm = context.assembler
         casm.with_retry do
           casm.add(SPR, argbyte)
         end

data/lib/ytljit/vm_cruby_obj.rb

@@ -3,25 +3,33 @@ module YTLJit
     module Node
       class CRubyInstanceVarRefNode<InstanceVarRefNode
         include TypeListWithoutSignature
+        include CommonCodeGen
 
-        def initialize(parent, name)
+        def initialize(parent, name, mnode)
           super
           @current_frame_info = search_frame_info
         end
 
         def compile_main(context)
           slfoff = @current_frame_info.offset_arg(2, BPR)
-          ivid = ((@name.object_id << 1) / InternalRubyType::RObject.size)
-          ivarget = OpMemAddress.new(address_of("rb_ivar_get"))
+          mivl = @class_top.end_nodes[0].modified_instance_var.keys
+          off = mivl.index(@name)
+          addr = lambda {
+            address_of("ytl_ivar_get_boxing")
+          }
+          ivarget = OpVarMemAddress.new(addr)
           context.start_arg_reg
           asm = context.assembler
           asm.with_retry do
             asm.mov(FUNC_ARG[0], slfoff)
-            asm.mov(FUNC_ARG[1], ivid)
+            asm.mov(FUNC_ARG[1], off)
+          end
+          context = gen_save_thepr(context)
+          asm.with_retry do
             asm.call_with_arg(ivarget, 2)
           end
+
           context.end_arg_reg
-          
           context.ret_reg = RETR
           context.ret_node = self
           decide_type_once(context.to_signature)
@@ -34,19 +42,26 @@ module YTLJit
 
       class CRubyInstanceVarAssignNode<InstanceVarAssignNode
         include TypeListWithoutSignature
+        include CommonCodeGen
 
-        def initialize(parent, name, val)
+        def initialize(parent, name, mnode, val)
           super
           @current_frame_info = search_frame_info
         end
 
         def compile_main(context)
           slfoff = @current_frame_info.offset_arg(2, BPR)
-          ivid = ((@name.object_id << 1) / InternalRubyType::RObject.size)
-          ivarset = OpMemAddress.new(address_of("rb_ivar_set"))
+          mivl = @class_top.end_nodes[0].modified_instance_var.keys
+          off = mivl.index(@name)
+          addr = lambda {
+            address_of("ytl_ivar_set_boxing")
+          }
+          ivarset = OpVarMemAddress.new(addr)
           context = @val.compile(context)
           rtype = @val.decide_type_once(context.to_signature)
-          context = rtype.gen_boxing(context)
+          if @val.is_escape != true then
+            context = rtype.gen_boxing(context)
+          end
 
           context.start_arg_reg
           asm = context.assembler
@@ -54,8 +69,11 @@ module YTLJit
             asm.push(TMPR2)
             asm.mov(TMPR2, context.ret_reg)
             asm.mov(FUNC_ARG[0], slfoff)
-            asm.mov(FUNC_ARG[1], ivid)
+            asm.mov(FUNC_ARG[1], off)
             asm.mov(FUNC_ARG[2], TMPR2)
+          end
+          context = gen_save_thepr(context)
+          asm.with_retry do
             asm.call_with_arg(ivarset, 3)
             asm.pop(TMPR2)
           end
@@ -74,7 +92,8 @@ module YTLJit
       def visit_getinstancevariable(code, ins, context)
         context.macro_method = false
         curnode = context.current_node
-        node = CRubyInstanceVarRefNode.new(curnode, ins[1])
+        mnode = context.current_method_node
+        node = CRubyInstanceVarRefNode.new(curnode, ins[1], mnode)
         node.debug_info = context.debug_info
         context.expstack.push node
       end
@@ -83,10 +102,12 @@ module YTLJit
         context.macro_method = false
         val = context.expstack.pop
         curnode = context.current_node
-        node = CRubyInstanceVarAssignNode.new(curnode, ins[1], val)
+        mnode = context.current_method_node
+        node = CRubyInstanceVarAssignNode.new(curnode, ins[1], mnode, val)
         node.debug_info = context.debug_info
         if context.expstack[-1] == val then
-          context.expstack[-1] = CRubyInstanceVarRefNode.new(curnode, ins[1])
+          ivr = CRubyInstanceVarRefNode.new(curnode, ins[1], mnode)
+          context.expstack[-1] = ivr
         end
         curnode.body = node
         context.current_node = node

data/lib/ytljit/vm_inline_method.rb

@@ -2,6 +2,7 @@ module YTLJit
   module VM
     module ArithmeticOperationUtil
       include AbsArch
+=begin
       def decide_type_core_local(tlist, sig, local_cache = {})
         tlist = tlist.select {|e| e.class != RubyType::DefaultType0 }
         if tlist.size < 2 then
@@ -29,6 +30,63 @@ module YTLJit
         
         @type
       end
+=end
+
+      def gen_inst_with_conversion(context, dst, inst)
+        asm = context.assembler
+        src = context.ret_reg
+        if dst.is_a?(OpRegXMM) then
+          # Float
+          if src.is_a?(OpRegistor) and
+              !src.is_a?(OpRegXMM) then
+            asm.with_retry do
+              asm.cvtsi2sd(XMM0, src)
+            end
+            context.end_using_reg(src)
+            asm.with_retry do
+              asm.send(inst, dst, XMM0)
+            end
+          elsif src.using(dst) then
+            asm.with_retry do
+              asm.mov(XMM0, src)
+            end
+            context.end_using_reg(src)
+            asm.with_retry do
+              asm.send(inst, dst, XMM0)
+            end
+          elsif src.is_a?(OpImmidiateMachineWord) then
+            asm.with_retry do
+              asm.mov(TMPR, src)
+            end
+            context.end_using_reg(src)
+            asm.with_retry do
+              asm.cvtsi2sd(XMM0, TMPR)
+              asm.send(inst, dst, XMM0)
+            end
+          else
+            asm.with_retry do
+              asm.send(inst, dst, src)
+            end
+            context.end_using_reg(src)
+          end
+        else
+          # Fixnum
+          if src.using(dst) then
+            asm.with_retry do
+              asm.mov(TMPR, src)
+            end
+            context.end_using_reg(src)
+            asm.with_retry do
+              asm.send(inst, dst, TMPR)
+            end
+          else
+            asm.with_retry do
+              asm.send(inst, dst, src)
+            end
+            context.end_using_reg(src)
+          end
+        end
+      end
 
       def gen_arithmetic_operation(context, inst, tempreg, resreg)
         context.start_using_reg(tempreg)
@@ -36,21 +94,7 @@ module YTLJit
         context.ret_node.type = nil
         rtype = context.ret_node.decide_type_once(context.to_signature)
         context = rtype.gen_unboxing(context)
-        asm = context.assembler
-        if context.ret_reg.using(tempreg) then
-          asm.with_retry do
-            asm.mov(TMPR, context.ret_reg)
-          end
-          context.end_using_reg(context.ret_reg)
-          asm.with_retry do
-            asm.mov(tempreg, TMPR)
-          end
-        else
-          asm.with_retry do
-            asm.mov(tempreg, context.ret_reg)
-          end
-          context.end_using_reg(context.ret_reg)
-        end
+        gen_inst_with_conversion(context, tempreg, :mov)
         context.set_reg_content(tempreg, context.ret_node)
         
         # @argunents[1] is block
@@ -61,21 +105,14 @@ module YTLJit
         context.ret_node.type = nil
         rtype = context.ret_node.decide_type_once(context.to_signature)
         context = rtype.gen_unboxing(context)
-          
-        asm = context.assembler
+
         if block_given? then
           yield(context)
         else
+          # default code
+          gen_inst_with_conversion(context, tempreg, inst)
+          asm = context.assembler
           asm.with_retry do
-            # default code
-            if context.ret_reg.using(tempreg) then
-              asm.mov(TMPR, context.ret_reg)
-              context.end_using_reg(context.ret_reg)
-              asm.send(inst, tempreg, TMPR)
-            else
-              asm.send(inst, tempreg, context.ret_reg)
-              context.end_using_reg(context.ret_reg)
-            end
             asm.mov(resreg, tempreg)
           end
         end
@@ -87,7 +124,7 @@ module YTLJit
         
         decide_type_once(context.to_signature)
         if @type.boxed then
-          context = @type.gen_boxing(context)
+          context = @type.to_unbox.gen_boxing(context)
         end
         
         context
@@ -96,14 +133,13 @@ module YTLJit
 
     module CompareOperationUtil
       def gen_compare_operation(context, cinst, sinst, 
-                                tempreg, tempreg2, resreg)
+                                tempreg, tempreg2, resreg, dounbox = true)
         context.start_using_reg(tempreg)
         asm = context.assembler
         asm.with_retry do
           asm.mov(tempreg, context.ret_reg)
         end
         context.set_reg_content(tempreg, context.ret_node)
-        context.set_reg_content(tempreg, context.ret_node)
         
         # @arguments[1] is block
         # @arguments[2] is self
@@ -112,16 +148,20 @@ module YTLJit
         context = aele.compile(context)
         context.ret_node.type = nil
         rtype = context.ret_node.decide_type_once(context.to_signature)
-        context = rtype.gen_unboxing(context)
+        if dounbox then
+          context = rtype.gen_unboxing(context)
+        end
           
         asm = context.assembler
         asm.with_retry do
           if context.ret_reg != tempreg2 then
             asm.mov(tempreg2, context.ret_reg)
           end
+          context.set_reg_content(tempreg2, context.ret_node)
           asm.send(cinst, tempreg2, tempreg)
           asm.send(sinst, resreg)
           asm.add(resreg, resreg)
+          context.set_reg_content(resreg, context.ret_node)
         end
         context.end_using_reg(tempreg)
         
@@ -129,10 +169,92 @@ module YTLJit
         context.ret_reg = resreg
         
         decide_type_once(context.to_signature)
-        if @type.boxed then
-          context = @type.gen_boxing(context)
+        
+        context
+      end
+    end
+
+    module UnboxedArrayUtil
+      include AbsArch
+      def gen_ref_element(context, slf, idx)
+        context.start_using_reg(TMPR2)
+        context = slf.compile(context)
+        asm = context.assembler
+        asm.with_retry do
+          asm.mov(TMPR2, context.ret_reg)
+        end
+        if idx.is_a?(Fixnum) then
+          idxval = idx
+        else
+          context = idx.compile(context)
+          idxval = context.ret_reg
         end
+        asm.with_retry do
+          if idxval.is_a?(Fixnum) then
+            asm.mov(TMPR, idxval * 8)
+          elsif idxval.is_a?(OpImmidiate)
+            asm.mov(TMPR, idxval.value * 8)
+          else
+            if idxval != TMPR then
+              asm.mov(TMPR, idxval)
+            end
+            asm.add(TMPR, TMPR) # * 2
+            asm.add(TMPR, TMPR) # * 4
+            asm.add(TMPR, TMPR) # * 8
+          end
+          asm.add(TMPR2, TMPR)
+          asm.mov(RETR, INDIRECT_TMPR2)
+        end
+        
+        context.end_using_reg(TMPR2)
+        context.ret_reg = RETR
+        context.ret_node = self
+
+        context
+      end
         
+      def gen_set_element(context, slf, idx, val)
+        context.start_using_reg(TMPR2)
+
+        asm = context.assembler
+        if slf then
+          context = slf.compile(context)
+          asm.with_retry do
+            asm.mov(TMPR2, context.ret_reg)
+          end
+        end
+        if idx.is_a?(Fixnum) then
+          idxval = idx
+        else
+          context = idx.compile(context)
+          idxval = context.ret_reg
+        end
+
+        asm.with_retry do
+          if idxval.is_a?(Fixnum) then
+            asm.mov(TMPR, idxval * 8)
+          elsif idxval.is_a?(OpImmidiate)
+            asm.mov(TMPR, idxval.value * 8)
+          else
+            asm.mov(TMPR, idxval)
+            asm.add(TMPR, TMPR) # * 2
+            asm.add(TMPR, TMPR) # * 4
+            asm.add(TMPR, TMPR) # * 8
+          end
+          asm.add(TMPR2, TMPR)
+        end
+        context = val.compile(context)
+
+        asm.with_retry do
+          if context.ret_reg != RETR then
+            asm.mov(RETR, context.ret_reg)
+          end
+          asm.mov(INDIRECT_TMPR2, RETR)
+        end
+        
+        context.end_using_reg(TMPR2)
+        context.ret_reg = RETR
+        context.ret_node = self
         context
       end
     end