ytljit 0.0.7 → 0.0.8

data/lib/ytljit/vm_sendnode.rb

@@ -167,16 +167,17 @@ module YTLJit
 
         def get_send_method_node(cursig)
           mt = nil
+          # @arguments[2].type = nil
           slf = @arguments[2].decide_type_once(cursig)
-          if slf.instance_of?(RubyType::DefaultType0) then
-            # Chaos
-          end
-
           if is_fcall or is_vcall then
             mt = @func.method_top_node(@class_top, nil)
-
+            
           else
-
+            if slf.instance_of?(RubyType::DefaultType0) then
+              # Chaos
+              #            raise "chaos"
+            end
+            
             mt = @func.method_top_node(@class_top, slf)
           end
 
@@ -221,35 +222,27 @@ module YTLJit
         end
 
         def search_signature(cursig)
-          metsigent = nil
           @method_signature.each do |tabent|
             if cursig == tabent[0] then
-              metsigent = tabent
+              return tabent
             end
           end
-          metsigent
+          nil
         end
 
         def check_signature_changed(context, signat, metsigent, cursig)
           if metsigent then
             if metsigent[1][1] != signat[1] then
-              if metsigent[1][1].ruby_type < signat[1].ruby_type then
-                signat[1] = metsigent[1][1]
-                false
-              else
-                type_list(cursig)[1] = []
-                ti_reset
-                ti_del_link
-                context.convergent = false
-                metsigent[1] = signat
-                true
-              end
+              # Why not push, because it excepted type inference about
+              # this signature after. So reduce search loop.
+              @method_signature.unshift [cursig, signat]
+              context.convergent = false
+              signat[1].ruby_type < metsigent[1][1].ruby_type
             else
               false
             end
+
           else
-            # Why not push, because it excepted type inference about
-            # this signature after. So reduce search loop.
             @method_signature.unshift [cursig, signat]
             false
           end
@@ -280,23 +273,50 @@ module YTLJit
           context = @func.collect_candidate_type(context)
 
           signat = signature(context)
-          check_signature_changed(context, signat, metsigent, cursig)
+          changed = check_signature_changed(context, signat, metsigent, cursig)
+=begin
+          if changed then
+            @arguments.each do |arg|
+              arg.type = nil
+            end
+            signat = signature(context)
+          end
+=end
 
           mt, slf = get_send_method_node(cursig)
           if mt then
-            same_type(self, mt, cursig, signat, context)
-            same_type(mt, self, signat, cursig, context)
+            if changed then
+              mt.type_list(metsigent[1])[1] = []
+              mt.ti_reset
+            end
 
             context = mt.collect_candidate_type(context, @arguments, signat)
 
+            same_type(self, mt, cursig, signat, context)
+
             context.push_signature(@arguments, mt)
             if blknode.is_a?(TopNode) then
               # Have block
               mt.yield_node.map do |ynode|
-                yargs = ynode.arguments
+                yargs = ynode.arguments.dup
                 ysignat = ynode.signature(context)
 
                 same_type(ynode, blknode, signat, ysignat, context)
+
+                # inherit self from caller node
+                yargs[2] = context.current_method_signature_node[-2][2]
+                ysignat[2] = cursig[2]
+                if yargs[2].decide_type_once(cursig).ruby_type == Object then
+                  context.current_method_signature_node.reverse.each {|e0| 
+                    if e0[2].class == SendNewArenaNode then
+                      if yargs[2].type then
+                        yargs[2] = e0[2]
+                        ysignat[2] = yargs[2].type
+                      end
+                      break
+                    end
+                  }
+                end
                 context = blknode.collect_candidate_type(context, 
                                                          yargs, ysignat)
 
@@ -507,23 +527,23 @@ module YTLJit
       end
 
       class SendAllocateNode<SendNode
+        include UnboxedObjectUtil
+
         add_special_send_node :allocate
 
         def collect_candidate_type_regident(context, slf)
           slfnode = @arguments[2]
+          cursig = context.to_signature
           if slf.ruby_type.is_a?(Class) then
+            tt = nil
             case slfnode
             when ConstantRefNode
               clstop = slfnode.value_node
               case clstop
               when ClassTopNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                tt = tt.to_box
-                add_type(context.to_signature, tt)
               when LiteralNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.value)
-                tt = tt.to_box
-                add_type(context.to_signature, tt)
               else
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
               end
@@ -531,9 +551,32 @@ module YTLJit
             else
               raise "Unkonwn node type #{@arguments[2].class} "
             end
+
+            clt =  ClassTopNode.get_class_top_node(tt.ruby_type_raw)
+            if context.options[:compile_array_as_uboxed] and
+                @is_escape and @is_escape != :global_export and
+                (clt and  !clt.body.is_a?(DummyNode)) then
+              tt = tt.to_unbox
+            elsif type_list(cursig)[0].include?(tt.to_unbox) then
+              type_list(cursig)[0] = []
+            end
+
+            add_type(cursig, tt)
           end
           context
         end
+
+        def compile(context)
+          rtype = decide_type_once(context.to_signature)
+          rrtype = rtype.ruby_type
+          if !rtype.boxed then
+            clt =  ClassTopNode.get_class_top_node(rrtype)
+            mivl = clt.end_nodes[0].modified_instance_var.keys
+            compile_object_unboxed(context, mivl.size)
+          else
+            super
+          end
+        end
       end
 
       class SendInitializeNode<SendNode
@@ -564,6 +607,7 @@ module YTLJit
           end
 
           context.ret_reg = RETR
+          context.set_reg_content(RETR, self)
           context.ret_node = self
           context.end_using_reg(PTMPR)
           context.end_using_reg(TMPR2)
@@ -574,6 +618,8 @@ module YTLJit
       end
 
       class SendNewNode<SendNode
+        include UnboxedArrayUtil
+
         add_special_send_node :new
 
         def initialize(parent, func, arguments, op_flag, seqno)
@@ -610,14 +656,16 @@ module YTLJit
 
         def collect_candidate_type_regident(context, slf)
           slfnode = @arguments[2]
+          cursig = context.to_signature
 
           if slf.ruby_type.is_a?(Class) then
+            @is_escape = search_class_top.is_escape
+            @allocmethod.is_escape = @is_escape
             case slfnode
             when ConstantRefNode
               context = @initmethod.collect_candidate_type(context)
               clstop = slfnode.value_node
               tt = nil
-              sig = context.to_signature
               case clstop
               when ClassTopNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
@@ -629,18 +677,28 @@ module YTLJit
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
               end
 
+              clt =  ClassTopNode.get_class_top_node(tt.ruby_type_raw)
+              if context.options[:compile_array_as_uboxed] and
+                  @is_escape and @is_escape != :global_export and
+                  (clt and  !clt.body.is_a?(DummyNode)) then
+                tt = tt.to_unbox
+              elsif type_list(cursig)[0].include?(tt.to_unbox) then
+                type_list(cursig)[0] = []
+              end
+
               # set element type
               if tt.ruby_type == Range then
                 tt.args = @arguments[3..-1]
-                add_element_node(tt, sig, @arguments[3], [0], context)
-                add_element_node(tt, sig, @arguments[4], [1], context)
+                add_element_node(tt, cursig, @arguments[3], [0], context)
+                add_element_node(tt, cursig, @arguments[4], [1], context)
 
               elsif tt.ruby_type == Array then
                 if context.options[:compile_array_as_uboxed] and
                     @element_node_list.size > 1 and
                       @element_node_list[1..-1].all? {|e|
                         e[3]
-                      } then
+                      } and 
+                    @is_escape and @is_escape != :global_export then
                   tt = tt.to_unbox
                 end
                 if @arguments[4] then
@@ -648,15 +706,15 @@ module YTLJit
                   if siz and false then
                     # Here is buggy yet Fix me
                     siz[0].times do |i|
-                      add_element_node(tt, sig, @arguments[4], [i], context)
+                      add_element_node(tt, cursig, @arguments[4], [i], context)
                     end
                   else
-                    add_element_node(tt, sig, @arguments[4], nil, context)
+                    add_element_node(tt, cursig, @arguments[4], nil, context)
                   end
                 end
               end
 
-              add_type(sig, tt)
+              add_type(cursig, tt)
             else
               raise "Unkonwn node type #{@arguments[2].class} "
             end
@@ -692,33 +750,19 @@ module YTLJit
           context
         end
 
-        def compile_array_unboxed(context)
-          siz = ((@element_node_list[1..-1].max_by {|a| a[3][0]})[3][0]) + 1
-          context = gen_alloca(context, siz)
-          asm = context.assembler
-          asm.with_retry do
-            (siz - 1).times do |i|
-              off = OpIndirect.new(THEPR, i * 8)
-              asm.mov(TMPR, OpImmidiateMachineWord.new(4))
-              asm.mov(off, TMPR)
-            end
-          end
-          context.ret_node = self
-          context
-        end
-
         def compile(context)
-          @arguments[2].decide_type_once(context.to_signature)
-          rtype = @arguments[2].type
+          rtype = @arguments[2].decide_type_once(context.to_signature)
           rrtype = rtype.ruby_type
           if rrtype.is_a?(Class) then
             ctype = decide_type_once(context.to_signature)
             crtype = ctype.ruby_type
-            if @is_escape != true and crtype == Range then
+            if @is_escape != :global_export and 
+                crtype == Range then
               return compile_range(context)
               
             elsif crtype == Array and
-                !ctype.boxed and @is_escape != true then
+                !ctype.boxed and 
+                @is_escape != :global_export then
               return compile_array_unboxed(context)
 
             elsif @initmethod.func.calling_convention(context) then
@@ -758,7 +802,8 @@ module YTLJit
           rtype = decide_type_once(context.to_signature)
           rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
-             @class_top.search_method_with_super(@func.name, rrtype)[0] then
+              rrtype == Array or
+              @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
 
@@ -796,6 +841,7 @@ module YTLJit
           rtype = decide_type_once(context.to_signature)
           rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
+              rrtype == Array or
               @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
@@ -804,8 +850,10 @@ module YTLJit
             context = gen_arithmetic_operation(context, :sub, TMPR2, TMPR)
           elsif rrtype == Float then
             context = gen_arithmetic_operation(context, :subsd, XMM4, XMM0)
+
           else
             p debug_info
+            p rtype
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
 
@@ -1003,6 +1051,11 @@ module YTLJit
                   asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
                   asm.idiv(context.ret_reg)
                 end
+                asm.and(DBLLOR, DBLLOR)
+                asm.setl(DBLLOR)
+                asm.neg(DBLLOR)
+                asm.xor(DBLHIR, DBLLOR)
+                asm.sub(DBLHIR, DBLLOR)
                 asm.mov(DBLLOR, DBLHIR)
                 context.end_using_reg(context.ret_reg)
               end
@@ -1021,11 +1074,17 @@ module YTLJit
         add_special_send_node :<<
 
         def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
           case [slf.ruby_type]
           when [Fixnum]
-            cursig = context.to_signature
             same_type(self, @arguments[2], cursig, cursig, context)
             same_type(self, @arguments[3], cursig, cursig, context)
+
+          when [Array]
+            val = @arguments[3]
+            arg = [slf, cursig, val, nil, context]
+            @arguments[2].add_element_node_backward(arg)
+            same_type(self, val, cursig, cursig, context)
           end
 
           context
@@ -1066,6 +1125,57 @@ module YTLJit
         end
       end
 
+      class SendOrNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :|
+
+        def collect_candidate_type_regident(context, slf)
+          case [slf.ruby_type]
+          when [Fixnum]
+            cursig = context.to_signature
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
+          end
+
+          context
+        end
+      end
+
+      class SendXorNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :^
+
+        def collect_candidate_type_regident(context, slf)
+          case [slf.ruby_type]
+          when [Fixnum]
+            cursig = context.to_signature
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
+          end
+
+          context
+        end
+      end
+
+      class SendLengthNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :length
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [Array]
+            tt = RubyType::BaseType.from_ruby_class(Fixnum)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
       class SendCompareNode<SendNode
         include SendUtil
         include CompareOperationUtil
@@ -1197,6 +1307,11 @@ module YTLJit
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
+            idxtype = @arguments[3].decide_type_once(cursig)
+            if idxtype.ruby_type == Range then
+              same_type(self, @arguments[2], cursig, cursig, context)
+              return context
+            end
             @arguments[3].add_type(cursig, fixtype)
             cidx = @arguments[3].get_constant_value
 
@@ -1205,34 +1320,38 @@ module YTLJit
             slf = @arguments[2].decide_type_once(cursig)
 
             epare = nil
-=begin
+
             @arguments[2].element_node_list.each do |ele|
-              if ele[3] == cidx and ele[2] != self and ele[0] == slf then
+              if ele[3] == cidx and ele[2] != self and 
+                  ele[0] == slf then
                 epare2 = ele
                 esig = epare2[1]
                 enode = epare2[2]
-                unless enode.type_list(esig) == [[], []]
+                if enode.type_list(esig) != [[], []] then
                   epare = epare2
                   same_type(self, enode, cursig, esig, context)
                 end
               end
             end
-=end
+
             if epare == nil then
               @arguments[2].element_node_list.each do |ele|
-                if ele[3] == nil and ele[2] != self and ele[0] == slf then
+                if ele[3] == nil and ele[2] != self and 
+                    ele[0] == slf then
                   epare2 = ele
                   esig = epare2[1]
                   enode = epare2[2]
-                  unless enode.type_list(esig) == [[], []]
+                  if enode.type_list(esig) != [[], []] then
                     epare = epare2
                     same_type(self, enode, cursig, esig, context)
                   end
                 end
               end
             end
+
+=begin
             if epare == nil then
-              @arguments[2].element_node_list.each do |ele|
+              @arguments[2].element_node_list.reverse.each do |ele|
                 if ele[3] == cidx and ele[2] != self and 
                     ele[0].ruby_type == slf.ruby_type then
                   epare2 = ele
@@ -1241,22 +1360,37 @@ module YTLJit
                   unless enode.type_list(esig) == [[], []]
                     epare = epare2
                     same_type(self, enode, cursig, esig, context)
+                    break
                   end
                 end
               end
             end
+
             if epare == nil then
-              epare = @arguments[2].element_node_list[0]
-              esig = epare[1]
-              enode = epare[2]
-              same_type(self, enode, cursig, esig, context)
+              nele = @arguments[2].element_node_list.select {|e| e[3] == nil}
+              if nele.size == 1 then
+                epare = @arguments[2].element_node_list[0]
+                esig = epare[1]
+                enode = epare[2]
+                same_type(self, enode, cursig, esig, context)
+              end
+            end
+=end
+
+            if epare == nil then
+              if slf.have_element? and slf.element_type then
+                add_type(cursig, slf.element_type[nil][0])
+              end
             end
 
             @type = nil
             
           when [Hash]
             cidx = @arguments[3].get_constant_value
-            rtype = @arguments[2].decide_type_once(sig)
+            rtype = @arguments[2].decide_type_once(cursig)
+            niltype = RubyType::BaseType.from_ruby_class(NilClass)
+            @arguments[3].type = nil
+            @arguments[3].add_type(cursig, niltype)
             @arguments[2].add_element_node(rtype, cursig, self, cidx, context)
           end
 
@@ -1265,14 +1399,37 @@ module YTLJit
 
         def compile(context)
           sig = context.to_signature
+          asm = context.assembler
+          @arguments[2].type = nil
           rtype = @arguments[2].decide_type_once(sig)
           rrtype = rtype.ruby_type
 
           if rrtype == Array and !rtype.boxed and 
-              @arguments[2].is_escape != true then
+              @arguments[2].is_escape != :global_export then
             context = gen_ref_element(context, @arguments[2], @arguments[3])
+            rtype = decide_type_once(sig)
+            if rtype.ruby_type == Float and !rtype.boxed then
+              asm.with_retry do
+                asm.mov(XMM0, context.ret_reg)
+              end
+              context.ret_reg = XMM0
+              context.set_reg_content(XMM0, self)
+            else
+              asm.with_retry do
+                asm.mov(RETR, context.ret_reg)
+              end
+              context.ret_reg = RETR
+              context.set_reg_content(RETR, self)
+            end
             @body.compile(context)
           else
+=begin
+            p @arguments[2].type
+            p @arguments[2].instance_eval {@type_list}
+              p sig
+            p @arguments[2].is_escape
+            p debug_info
+=end
             super
           end
         end
@@ -1289,7 +1446,7 @@ module YTLJit
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             val = @arguments[4]
-            val.is_escape = :export_object
+            val.is_escape = :local_export
             @arguments[3].add_type(cursig, fixtype)
             cidx = @arguments[3].get_constant_value
             @arguments[2].type = nil
@@ -1319,16 +1476,23 @@ module YTLJit
             enode = epare[2]
             if enode != self then
               same_type(self, enode, cursig, esig, context)
-#              same_type(enode, self, esig, sig, context)
             end
             if slf.boxed then
-              @arguments[3].set_escape_node_backward(true)
+              @arguments[4].set_escape_node_backward(:global_export)
+            else
+              @arguments[4].set_escape_node_backward(:local_export)
             end
 
           when [Hash]
             cidx = @arguments[3].get_constant_value
-            @arguments[2].add_element_node(slf, sig, self, cidx, context)
-            @arguments[3].set_escape_node_backward(true)
+            @arguments[2].add_element_node(slf, cursig, self, cidx, context)
+            niltype = RubyType::BaseType.from_ruby_class(NilClass)
+            @arguments[3].type = nil
+            @arguments[3].add_type(cursig, niltype)
+            @arguments[4].type = nil
+            @arguments[4].add_type(cursig, niltype)
+            @arguments[3].set_escape_node_backward(:global_export)
+            @arguments[4].set_escape_node_backward(:global_export)
           end
 
           context
@@ -1339,7 +1503,7 @@ module YTLJit
           rtype = @arguments[2].decide_type_once(sig)
           rrtype = rtype.ruby_type
           if rrtype == Array and !rtype.boxed and 
-              @arguments[2].is_escape != true then
+              @arguments[2].is_escape != :global_export then
             context = gen_set_element(context, 
                                       @arguments[2], 
                                       @arguments[3], 
@@ -1399,6 +1563,34 @@ module YTLJit
           add_type(sig, fixnumtype)
           context
         end
+
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rrtype == Float then
+            context = gen_eval_self(context)
+            context = rtype.gen_unboxing(context)
+            asm = context.assembler
+            if context.ret_reg.is_a?(OpRegistor) or
+                 context.ret_reg.is_a?(OpIndirect) then
+              asm.with_retry do
+                asm.cvttsd2si(RETR, context.ret_reg)
+              end
+            else
+              asm.with_retry do
+                asm.mov(XMM0, context.ret_reg)
+                asm.cvttsd2si(RETR, XMM0)
+              end
+            end
+            context.set_reg_content(RETR, self)
+            context.ret_node = self
+            context.ret_reg = RETR
+            context
+          else
+            super(context)
+          end
+        end
       end
 
       class SendChrNode<SendNode
@@ -1436,6 +1628,7 @@ module YTLJit
               asm.mov(RETR, context.ret_reg)
               asm.neg(RETR)
             end
+            context.set_reg_content(RETR, self)
             context.ret_reg = RETR
           elsif rrtype == Float then
             context.start_using_reg(XMM4)
@@ -1445,6 +1638,7 @@ module YTLJit
               asm.subsd(XMM0, XMM4)
             end
             context.ret_reg = XMM0
+            context.set_reg_content(XMM0, self)
             context.end_using_reg(XMM4)
           end
           context.ret_node = self
@@ -1490,7 +1684,7 @@ module YTLJit
           rrtype = rtype.ruby_type
           decide_type_once(sig)
           if rrtype == Range and !rtype.boxed and 
-              @arguments[2].is_escape != true then
+              @arguments[2].is_escape != :global_export then
             context = @arguments[2].compile(context)
             slotoff = OpIndirect.new(TMPR, arg_offset)
             asm = context.assembler
@@ -1500,6 +1694,7 @@ module YTLJit
             end
 
             context.ret_reg = RETR
+            context.set_reg_content(RETR, self)
             context.ret_node = self
 
             context
@@ -1565,7 +1760,24 @@ module YTLJit
       class SendPNode<SendSameArgTypeNode
         add_special_send_node :p
       end
- 
+
+     class SendDispTypeNode<SendNode
+        add_special_send_node :disp_type
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          p debug_info
+          p sig
+          p @arguments[2].type_list(sig)
+#          p @arguments[2].instance_eval {@type_list}
+          p @arguments[2].class
+          context
+        end
+
+       def compile(context)
+         @body.compile(context)
+       end
+     end
+
       class SendSameSelfTypeNode<SendNode
         def collect_candidate_type_regident(context, slf)
           sig = context.to_signature
@@ -1587,6 +1799,14 @@ module YTLJit
        end
       end
 
+      class SendSortNode<SendSameSelfTypeNode
+        add_special_send_node :sort
+      end
+
+      class SendSortNode<SendSameSelfTypeNode
+        add_special_send_node :uniq!
+      end
+ 
       class SendMathFuncNode<SendNode
         include SendUtil
         def collect_candidate_type_regident(context, slf)
@@ -1597,7 +1817,12 @@ module YTLJit
         end
 
         def compile_call_func(context, fname)
-          fadd = OpMemAddress.new(address_of(fname))
+          addr = lambda { 
+            a = address_of(fname)
+            $symbol_table[a] = fname
+            a
+          }
+          fadd = OpVarMemAddress.new(addr)
           context.start_arg_reg(FUNC_FLOAT_ARG)
           context.start_arg_reg
           asm = context.assembler
@@ -1617,7 +1842,7 @@ module YTLJit
           context
         end
 
-        def compile2(context)
+        def compile(context)
           @arguments[2].decide_type_once(context.to_signature)
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
@@ -1626,12 +1851,13 @@ module YTLJit
             return super(context)
           end
 
+          context = @arguments[2].compile(context)
           @arguments[3].decide_type_once(context.to_signature)
           rtype = @arguments[3].type
-          rrtype = rtype.ruby_type
           context = @arguments[3].compile(context)
           context = rtype.gen_unboxing(context)
-          compile_main(context)
+          context = compile_main(context)
+          @body.compile(context)
         end
       end
       
@@ -1727,26 +1953,31 @@ module YTLJit
           sig = context.to_signature
           rtype = decide_type_once(sig)
           rrtype = rtype.ruby_type
-          if rrtype == Array and !rtype.boxed and @is_escape != true then
+          if rrtype == Array and 
+              !rtype.boxed and 
+              @is_escape != :global_export then
             siz = ((@element_node_list[1..-1].max_by {|a| a[3][0]})[3][0]) + 1
             context = gen_alloca(context, siz)
 
-            context.start_arg_reg(TMPR2)
+            context.start_using_reg(TMPR2)
             asm = context.assembler
             asm.with_retry do
               asm.mov(TMPR2, THEPR)
             end
 
             @arguments[1..-1].each_with_index do |anode, idx|
+              context.start_using_reg(TMPR2)
               context = gen_set_element(context, nil, idx, anode)
+              context.end_using_reg(TMPR2)
             end
 
             asm.with_retry do
               asm.mov(RETR, TMPR2)
             end
-            context.end_arg_reg(TMPR2)
+            context.end_using_reg(TMPR2)
 
             context.ret_reg = RETR
+            context.set_reg_content(RETR, self)
             context.ret_node = self
             @body.compile(context)
           else