ytljit 0.0.8 → 0.0.9

data/lib/ytljit/vm_codegen.rb

@@ -131,7 +131,7 @@ LO        |                       |   |  |
           if @current_method[i] == offset then
             offset = i
           else
-            # This is legal this TopNode has only one signature 
+            # This is legal if this TopNode has only one signature 
             sigc = offset.signature_cache
             if sigc.size == 1 then
               return sigc[0]
@@ -148,6 +148,14 @@ LO        |                       |   |  |
 
         cursignode = @current_method_signature_node[offset]
         curmethod = @current_method[offset]
+        if curmethod == nil then
+          return nil
+        end
+
+        cursig = curmethod.current_signature
+        if cursig then
+          return cursig
+        end
 
         sigc = curmethod.signature_cache
         if sigc.size == 1 then
@@ -188,8 +196,9 @@ LO        |                       |   |  |
       end
 
       def to_signature_aux(cursignode, offset, cache)
+        sig = to_signature(offset - 1, cache)
         res = cursignode.map { |enode|
-          enode.decide_type_once(to_signature(offset - 1, cache))
+          enode.decide_type_once(sig)
         }
         
         res
@@ -198,20 +207,33 @@ LO        |                       |   |  |
       def to_signature_aux2(mt, args, cursig, offset, cache)
         res = []
         args.each do |ele|
-          ele.decide_type_once(cursig)
-          res.push ele.type
+          res.push ele.decide_type_once(cursig)
+        end
+
+        if !args[1].is_a?(Node::BlockTopNode) then
+          return res
         end
 
         ynode = mt.yield_node[0]
-        if ynode then
+        if ynode and false then
           yargs = ynode.arguments
-          push_signature(yargs, ynode.frame_info.parent)
+          push_signature(yargs, mt)
           ysig = to_signature_aux3(yargs, -1, cache)
+          # inherit self and block from caller node
+          ysig[1] = cursig[1]
+          ysig[2] = cursig[2]
+
           args[1].type = nil
           res[1] = args[1].decide_type_once(ysig)
-#          p res
-#          p res[1]
+          #p res
+          #p res[1]
           pop_signature
+        else
+          sig =  args[1].search_valid_signature
+          if sig then
+            args[1].type = nil
+            res[1] = args[1].decide_type_once(sig)
+          end
         end
         
         res
@@ -231,6 +253,7 @@ LO        |                       |   |  |
           res = cursignode.map { |enode|
             enode.decide_type_once(sig)
           }
+
           cache[cursignode] = res
           res
         end
@@ -248,6 +271,7 @@ LO        |                       |   |  |
 
       attr          :top_node
       attr          :current_method_signature_node
+      attr          :current_method
       attr_accessor :convergent
       attr_accessor :visited_top_node
       attr_accessor :options
@@ -272,13 +296,16 @@ LO        |                       |   |  |
         @depth_reg = Hash.new(0)
         @stack_content = []
         @reg_content = Hash.new(true)
-        @reg_history = Hash.new {|hash, key| hash[key] = []}
+        @reg_history = Hash.new
 
         # Use only type inference compile mode
         @slf = nil
 
         # Options from user
         @options = {}
+
+        # Comment of type inference
+        @comment = {}
       end
 
       attr          :top_node
@@ -298,6 +325,7 @@ LO        |                       |   |  |
       attr_accessor :slf
 
       attr_accessor :options
+      attr_accessor :comment
 
       def set_reg_content(dst, val)
         if dst.is_a?(FunctionArgument) then
@@ -313,13 +341,14 @@ LO        |                       |   |  |
           wsiz = AsmType::MACHINE_WORD.size
           if dst.reg == SPR then
             if val.is_a?(OpRegistor) and @reg_content[val] then
-              cpustack_setn(dst.disp.value / wsiz, @reg_content[val])
+              cpustack_setn(-dst.disp.value / wsiz - 1, @reg_content[val])
             else
-              cpustack_setn(dst.disp.value / wsiz, val)
+              cpustack_setn(-dst.disp.value / wsiz - 1, val)
             end
-          end
-          if dst.reg == BPR then
+          elsif dst.reg == BPR then
             if val.is_a?(OpRegistor) and @reg_content[val] then
+              # 3 means difference of SP(constructed frame) and BP
+              # ref. gen_method_prologue
               cpustack_setn(-dst.disp.value / wsiz + 3, @reg_content[val])
             else
               cpustack_setn(-dst.disp.value / wsiz + 3, val)
@@ -346,6 +375,8 @@ LO        |                       |   |  |
         cont = @stack_content.pop
         if !cont.is_a?(OpRegistor) then
           @reg_content[reg] = cont
+        else
+          @reg_content[reg] = @reg_content[cont]
         end
       end
 
@@ -403,6 +434,7 @@ LO        |                       |   |  |
         else
           @depth_reg[reg] = 0
         end
+        @reg_history[reg] ||= []
         @reg_history[reg].push @reg_content[reg]
         @reg_content[reg] = nil
         @depth_reg[reg] += 1
@@ -529,10 +561,14 @@ LO        |                       |   |  |
             asm.push(BPR)
             asm.mov(BPR, SPR)
           end
+          context.set_reg_content(BPR, :old_ptr)
           context.cpustack_push(BPR)
+          context.set_reg_content(TMPR, :num_of_args)
           context.cpustack_push(TMPR)
+          context.set_reg_content(THEPR, :local_heap)
           context.cpustack_push(THEPR)
-          context.cpustack_push(SPR)
+          context.set_reg_content(BPR, :frame_ptr)
+          context.cpustack_push(BPR)
             
           context
         end
@@ -608,6 +644,7 @@ LO        |                       |   |  |
             asm.mov(TMPR, siz)
             asm.mov(FUNC_ARG[1], TMPR)
           end
+          context = gen_save_thepr(context)
           context = gen_call(context, alloca, 2)
           asm.with_retry do
             asm.mov(THEPR, RETR)
@@ -646,6 +683,7 @@ LO        |                       |   |  |
         end
         cpuinfo.push context.reg_content.dup
         cpuinfo.push context.stack_content.dup
+        cpuinfo.push context.to_signature
         context.top_node.frame_struct_array.push [vretadd, cpuinfo]
         
         if context.options[:dump_context] then
@@ -661,18 +699,30 @@ LO        |                       |   |  |
         end
 
         print "---- Stack map ----\n"
+#=begin
+        if @frame_info then
+          start = @frame_info.argument_num + 1
+          ll = @frame_info.frame_layout.reverse[start..-1]
+          ll.each_with_index do |vinf, i|
+            ro = @frame_info.real_offset(i)
+            print "    #{vinf.name}:#{vinf.size}\n"
 =begin
-        @frame_info.frame_layout.each_with_index do |vinf, i|
-          ro = @frame_info.real_offset(i)
-          if mlv = @modified_local_var.last[0][ro] then
-            print "    #{mlv.class} \n"
-          else
-            print "    #{vinf.class} \n"
+               if mlv = @modified_local_var.last[0][ro] then
+                 print "    #{mlv.class} \n"
+               else
+                 print "    #{vinf.class} \n"
+               end
+=end
           end
         end
-=end
+#=end
+        p "---"
         context.stack_content.each do |value|
-          print "    #{value.class} \n"
+          if value.is_a?(Symbol) then
+            print "    #{value} \n"
+          else
+            print "    #{value.class} \n"
+          end
         end
       end
     end
@@ -701,8 +751,7 @@ LO        |                       |   |  |
             rtype = argcomphook.call(context, arg, i)
           else
             context = arg.compile(context)
-            context.ret_node.decide_type_once(cursig)
-            rtype = context.ret_node.type
+            rtype = context.ret_node.decide_type_once(cursig)
           end
           context = rtype.gen_boxing(context)
           dst = OpIndirect.new(SPR, i * AsmType::MACHINE_WORD.size)

data/lib/ytljit/vm_cruby_obj.rb

@@ -12,16 +12,21 @@ module YTLJit
         end
 
         def compile_main(context)
+          slfoff = @current_frame_info.offset_arg(2, BPR)
           cursig = context.to_signature
-          asm = context.assembler
+          compile_main_aux(context, slfoff, cursig[2])
+        end
+
+        def compile_main_aux(context, slfcont, slftype)
           mivl = @class_top.end_nodes[0].modified_instance_var.keys
           off = mivl.index(@name)
-          slfoff = @current_frame_info.offset_arg(2, BPR)
+          cursig = context.to_signature
+          asm = context.assembler
 
-          if !cursig[2].boxed then
+          if !slftype.boxed then
             context.start_using_reg(TMPR2)
             asm.with_retry do
-              asm.mov(TMPR2, slfoff)
+              asm.mov(TMPR2, slfcont)
             end
             context = gen_ref_element(context, nil, off)
             context.end_using_reg(TMPR2)
@@ -48,13 +53,11 @@ module YTLJit
           ivarget = OpVarMemAddress.new(addr)
           context.start_arg_reg
           asm.with_retry do
-            asm.mov(FUNC_ARG[0], slfoff)
+            asm.mov(FUNC_ARG[0], slfcont)
             asm.mov(FUNC_ARG[1], off)
           end
           context = gen_save_thepr(context)
-          asm.with_retry do
-            asm.call_with_arg(ivarget, 2)
-          end
+          context = gen_call(context, ivarget, 2)
 
           context.end_arg_reg
           context.ret_reg = RETR
@@ -78,19 +81,28 @@ module YTLJit
         end
 
         def compile_main(context)
-          cursig = context.to_signature
           slfoff = @current_frame_info.offset_arg(2, BPR)
+          cursig = context.to_signature
+          compile_main_aux(context, slfoff, cursig[2], @val, @body)
+        end
+
+        def compile_main_aux(context, slfcont, slftype, val, body)
+          cursig = context.to_signature
           mivl = @class_top.end_nodes[0].modified_instance_var.keys
           off = mivl.index(@name)
-          rtype = @val.decide_type_once(cursig)
+          rtype = val.decide_type_once(cursig)
 
-          if !cursig[2].boxed then
+          if !slftype.boxed then
             asm = context.assembler
             asm.with_retry do
-              asm.mov(TMPR2, slfoff)
+              asm.mov(TMPR2, slfcont)
+            end
+            context = gen_set_element(context, nil, off, val)
+            if body then
+              return body.compile(context)
+            else
+              return context
             end
-            context = gen_set_element(context, nil, off, @val)
-            return @body.compile(context)
           end
 
           addr = lambda {
@@ -100,30 +112,34 @@ module YTLJit
           }
           ivarset = OpVarMemAddress.new(addr)
 
-          context = @val.compile(context)
-          if @val.is_escape != :global_export then
-            context = rtype.gen_boxing(context)
-          end
-
+          context.start_using_reg(TMPR2)
           context.start_arg_reg
           asm = context.assembler
           asm.with_retry do
-            asm.push(TMPR2)
+            asm.mov(FUNC_ARG[0], slfcont)
+          end
+
+          context = val.compile(context)
+          context = rtype.gen_boxing(context)
+
+          asm.with_retry do
             asm.mov(TMPR2, context.ret_reg)
-            asm.mov(FUNC_ARG[0], slfoff)
             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
+          context = gen_call(context, ivarset, 3)
+
           context.end_arg_reg
+          context.end_using_reg(TMPR2)
           
           context.ret_reg = RETR
           context.ret_node = self
-          @body.compile(context)
+          if body then
+            body.compile(context)
+          else
+            context
+          end
         end
       end
     end
@@ -147,10 +163,6 @@ module YTLJit
         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
-          ivr = CRubyInstanceVarRefNode.new(curnode, ins[1], mnode)
-          context.expstack[-1] = ivr
-        end
         curnode.body = node
         context.current_node = node
       end

data/lib/ytljit/vm_inline_method.rb

@@ -153,11 +153,25 @@ module YTLJit
         end
           
         asm = context.assembler
-        asm.with_retry do
-          if context.ret_reg != tempreg2 then
-            asm.mov(tempreg2, context.ret_reg)
+        if context.ret_reg != tempreg2 then
+          if tempreg2.is_a?(OpRegXMM) and 
+              !context.ret_reg.is_a?(OpRegXMM) then
+            asm.with_retry do
+              asm.cvtsi2sd(tempreg2, context.ret_reg)
+            end
+          elsif !tempreg2.is_a?(OpRegXMM) and 
+              context.ret_reg.is_a?(OpRegXMM) then
+            asm.with_retry do
+              asm.cvtsd2si(tempreg2, context.ret_reg)
+            end
+          else
+            asm.with_retry do
+              asm.mov(tempreg2, context.ret_reg)
+            end
           end
-          context.set_reg_content(tempreg2, context.ret_node)
+        end
+        context.set_reg_content(tempreg2, context.ret_node)
+        asm.with_retry do
           asm.send(cinst, tempreg2, tempreg)
           asm.send(sinst, resreg)
           asm.add(resreg, resreg)
@@ -196,24 +210,30 @@ module YTLJit
       include UnboxedObjectUtil
 
       def compile_array_unboxed(context)
-        siz = ((@element_node_list[1..-1].max_by {|a| a[3][0]})[3][0]) + 1
+        sizent = @element_node_list[1..-1].max_by {|a| a[3] ? a[3][0] : -1}
+        siz = sizent[3][0] + 1
         compile_object_unboxed(context, siz)
       end
 
       def gen_ref_element(context, slf, idx)
+        context.start_using_reg(TMPR2)
         asm = context.assembler
         if slf then
-          context.start_using_reg(TMPR2)
           context = slf.compile(context)
           asm.with_retry do
             asm.mov(TMPR2, context.ret_reg)
           end
         end
+        context.set_reg_content(TMPR2, context.ret_node)
 
         if idx.is_a?(Fixnum) then
           idxval = idx
         else
           context = idx.compile(context)
+          itype = idx.decide_type_once(context.to_signature)
+          if itype.boxed then
+            context = itype.gen_unboxing(context)
+          end
           idxval = context.ret_reg
         end
         asm.with_retry do
@@ -232,9 +252,7 @@ module YTLJit
           asm.add(TMPR, TMPR2)
         end
 
-        if slf then
-          context.end_using_reg(TMPR2)
-        end
+        context.end_using_reg(TMPR2)
         context.ret_reg = INDIRECT_TMPR
         context.ret_node = self
 
@@ -242,18 +260,23 @@ module YTLJit
       end
 
       def gen_set_element(context, slf, idx, val)
+        context.start_using_reg(TMPR2)
         asm = context.assembler
         if slf then
-          context.start_using_reg(TMPR2)
           context = slf.compile(context)
           asm.with_retry do
             asm.mov(TMPR2, context.ret_reg)
           end
         end
+        idxval = nil
         if idx.is_a?(Fixnum) then
           idxval = idx
         else
           context = idx.compile(context)
+          itype = idx.decide_type_once(context.to_signature)
+          if itype.boxed then
+            context = itype.gen_unboxing(context)
+          end
           idxval = context.ret_reg
         end
 
@@ -263,17 +286,22 @@ module YTLJit
           elsif idxval.is_a?(OpImmidiate)
             asm.mov(TMPR, idxval.value * 8)
           else
-            asm.mov(TMPR, idxval)
+            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.push(TMPR2)
         end
+        context.set_reg_content(TMPR2, :refer_of_static_heap)
         context = val.compile(context)
 
         valreg = context.ret_reg
         asm.with_retry do
+          asm.pop(TMPR2)
           if !valreg.is_a?(OpRegistor) then
             asm.mov(RETR, valreg)
             valreg = RETR
@@ -282,9 +310,7 @@ module YTLJit
           asm.mov(INDIRECT_TMPR2, valreg)
         end
 
-        if slf then
-          context.end_using_reg(TMPR2)
-        end
+        context.end_using_reg(TMPR2)
         context.ret_reg = valreg
         context.ret_node = self
         context