ytljit 0.0.6 → 0.0.7

data/lib/ytljit/vm_sendnode.rb

@@ -48,6 +48,7 @@ module YTLJit
         @@current_node = nil
         @@special_node_tab = {}
         @@macro_tab = {}
+        @@user_defined_method_tab = {}
         
         def self.node
           @@current_node
@@ -57,6 +58,10 @@ module YTLJit
           @@macro_tab
         end
 
+        def self.get_user_defined_method_tab
+          @@user_defined_method_tab
+        end
+
         def self.add_special_send_node(name)
           oldcls = @@special_node_tab[name]
           if oldcls == nil or self < oldcls then
@@ -67,16 +72,42 @@ module YTLJit
           end
         end
 
-        def self.make_send_node(parent, func, arguments, op_flag, seqno)
-          if mproc = @@macro_tab[func.name] then
-            args = []
-            arguments[3..-1].each do |ele|
-              args.push eval(ele.to_ruby(ToRubyContext.new).ret_code.last)
+        def self.macro_expand(context, func, arguments, op_flag, seqno)
+          if @@macro_tab[func.name] and 
+              (op_flag & (0b11 << 3)) != 0 then
+            cclsnode = context.current_class_node
+            if context.current_method_node == nil then
+              cclsnode = cclsnode.make_klassclass_node
+            end
+
+            cclsnode.klass_object.ancestors.each do |ccls|
+              cnode = ClassTopNode.get_class_top_node(ccls)
+              cobj = nil
+              if cnode then
+                cobj = cnode.klass_object
+              end
+
+              if @@user_defined_method_tab[func.name] and
+                  @@user_defined_method_tab[func.name].include?(cobj) then
+                return nil
+              end
+
+              mproc = @@macro_tab[func.name][cobj]
+              if mproc then
+                args = []
+                arguments[3..-1].each do |ele|
+                  argruby = ele.to_ruby(ToRubyContext.new).ret_code.last
+                  args.push eval(argruby)
+                end
+                return mproc.call(*args)
+              end
             end
-            res = mproc.call(*args)
-            return res
           end
 
+          nil
+        end
+
+        def self.make_send_node(parent, func, arguments, op_flag, seqno)
           spcl = @@special_node_tab[func.name]
           newobj = nil
           if spcl then
@@ -109,6 +140,8 @@ module YTLJit
 
           @result_cache = nil
           @method_signature = []
+
+          @current_exception_table = nil
         end
 
         attr_accessor :func
@@ -122,6 +155,8 @@ module YTLJit
         attr_accessor :result_cache
         attr          :seq_no
 
+        attr_accessor :current_exception_table
+
         def traverse_childlen
           @arguments.each do |arg|
             yield arg
@@ -132,8 +167,7 @@ module YTLJit
 
         def get_send_method_node(cursig)
           mt = nil
-          @arguments[2].decide_type_once(cursig)
-          slf = @arguments[2].type
+          slf = @arguments[2].decide_type_once(cursig)
           if slf.instance_of?(RubyType::DefaultType0) then
             # Chaos
           end
@@ -299,6 +333,8 @@ module YTLJit
           when :ytl
             context = compile_ytl(context)
 
+          when nil
+
           else
             raise "Unsupported calling conversion #{callconv}"
           end
@@ -333,8 +369,16 @@ module YTLJit
           super
           @new_method = arguments[5]
           if arguments[4].is_a?(LiteralNode) then
-            @new_method.name = arguments[4].value
-            @class_top.get_method_tab[arguments[4].value] = @new_method
+            fname = arguments[4].value
+            @new_method.name = fname
+            @class_top.get_method_tab[fname] = @new_method
+            if @@macro_tab[fname] and 
+                @@macro_tab[fname][:last] then
+              # This function is macro
+              proc = @@macro_tab[fname][:last]
+              @@macro_tab[fname][:last] = nil
+              @@macro_tab[fname][@class_top.klass_object] = proc
+            end
           else
             raise "Not supported not literal method name"
           end
@@ -377,8 +421,15 @@ module YTLJit
           super
           @new_method = arguments[5]
           if arguments[4].is_a?(LiteralNode) then
-            @new_method.name = arguments[4].value
-            @class_top.make_klassclass_node
+            fname = arguments[4].value
+            @new_method.name = fname
+            klassclass_node = @class_top.make_klassclass_node
+            if @@macro_tab[fname] and 
+                @@macro_tab[fname][:last] then
+              proc = @@macro_tab[fname][:last]
+              @@macro_tab[fname][:last] = nil
+              @@macro_tab[fname][klassclass_node.klass_object] = proc
+            end
           else
             raise "Not supported not literal method name"
           end
@@ -425,6 +476,36 @@ module YTLJit
         add_special_send_node :eval
       end
 
+      class SendIncludeCommonNode<SendNode
+        def collect_candidate_type_regident(context, slf)
+          slfnode = @arguments[2]
+          rtype = slfnode.decide_type_once(context.to_signature)
+          add_type(context.to_signature, rtype)
+          modnode = @arguments[3].value_node
+
+          add_search_module(slfnode, modnode)
+          context
+        end
+      end
+
+      class SendIncludeNode<SendIncludeCommonNode
+        add_special_send_node :include
+
+        def add_search_module(slfnode, modnode)
+          clstop =  slfnode.search_class_top
+          clstop.add_after_search_module(:parm, modnode)
+        end
+      end
+
+      class SendExtendNode<SendIncludeCommonNode
+        add_special_send_node :extend
+
+        def add_search_module(slfnode, modnode)
+          clsclstop =  slfnode.search_class_top.make_klassclass_node
+          clsclstop.add_after_search_module(:parm, modnode)
+        end
+      end
+
       class SendAllocateNode<SendNode
         add_special_send_node :allocate
 
@@ -437,9 +518,11 @@ module YTLJit
               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}"
@@ -538,11 +621,9 @@ module YTLJit
               case clstop
               when ClassTopNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                add_type(sig, tt)
                 
               when LiteralNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.value)
-                add_type(sig, tt)
 
               else
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
@@ -551,49 +632,94 @@ module YTLJit
               # set element type
               if tt.ruby_type == Range then
                 tt.args = @arguments[3..-1]
-                add_element_node(sig, @arguments[3], [0], context)
-              end
-
-              if tt.ruby_type == Array then
-                @arguments[3..-1].each_with_index do |anode, idx|
-                  add_element_node(sig, anode, [idx - 3], context)
+                add_element_node(tt, sig, @arguments[3], [0], context)
+                add_element_node(tt, sig, @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
+                  tt = tt.to_unbox
+                end
+                if @arguments[4] then
+                  siz = @arguments[3].get_constant_value
+                  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)
+                    end
+                  else
+                    add_element_node(tt, sig, @arguments[4], nil, context)
+                  end
                 end
               end
+
+              add_type(sig, tt)
             else
               raise "Unkonwn node type #{@arguments[2].class} "
             end
           end
           context
         end
-        
+
+        def compile_range(context)
+          context = gen_alloca(context, 3)
+          asm = context.assembler
+          breg = context.ret_reg
+          
+          off = 0
+          sig = context.to_signature
+          [3, 4, 5].each do |no|
+            context = @arguments[no].compile(context)
+            rtype = @arguments[no].decide_type_once(sig)
+            context = rtype.gen_unboxing(context)
+            dst = OpIndirect.new(breg, off)
+            asm.with_retry do
+              if context.ret_reg.is_a?(OpRegistor) then
+                asm.mov(dst, context.ret_reg)
+              else
+                asm.mov(TMPR, context.ret_reg)
+                asm.mov(dst, TMPR)
+              end
+            end
+            off = off + AsmType::MACHINE_WORD.size
+          end
+          
+          context.ret_reg = breg
+          context.ret_node = self
+          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
           rrtype = rtype.ruby_type
           if rrtype.is_a?(Class) then
-            if !@is_escape and rrtype.to_s == '#<Class:Range>' then
-              context = gen_alloca(context, 3)
-              asm = context.assembler
-              breg = context.ret_reg
-
-              off = 0
-              [3, 4, 5].each do |no|
-                context = @arguments[no].compile(context)
-                dst = OpIndirect.new(breg, off)
-                asm.with_retry do
-                  if context.ret_reg.is_a?(OpRegistor) then
-                    asm.mov(dst, context.ret_reg)
-                  else
-                    asm.mov(TMPR, context.ret_reg)
-                    asm.mov(dst, TMPR)
-                  end
-                end
-                off = off + AsmType::MACHINE_WORD.size
-              end
+            ctype = decide_type_once(context.to_signature)
+            crtype = ctype.ruby_type
+            if @is_escape != true and crtype == Range then
+              return compile_range(context)
               
-              context.ret_reg = breg
-              context.ret_node = self
-              context
+            elsif crtype == Array and
+                !ctype.boxed and @is_escape != true then
+              return compile_array_unboxed(context)
 
             elsif @initmethod.func.calling_convention(context) then
               context = @initmethod.compile(context)
@@ -602,6 +728,7 @@ module YTLJit
               # initialize method not defined
               context = @allocmethod.compile(context)
             end
+            context.ret_node = self
             @body.compile(context)
           else
             super
@@ -619,7 +746,7 @@ module YTLJit
           when [Fixnum], [Float], [String], [Array]
             cursig = context.to_signature
             same_type(self, @arguments[2], cursig, cursig, context)
-            same_type(@arguments[2], self, cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
           end
 
           context
@@ -627,8 +754,8 @@ module YTLJit
 
 #=begin
         def compile(context)
-          @arguments[2].decide_type_once(context.to_signature)
-          rtype = @arguments[2].type
+          @type = nil
+          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
@@ -658,15 +785,15 @@ module YTLJit
           when [Fixnum], [Float], [Array]
             cursig = context.to_signature
             same_type(self, @arguments[2], cursig, cursig, context)
-            same_type(@arguments[2], self, cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
           end
 
           context
         end
 
         def compile(context)
-          @arguments[2].decide_type_once(context.to_signature)
-          rtype = @arguments[2].type
+          @type = nil
+          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
@@ -696,11 +823,11 @@ module YTLJit
           case [slf.ruby_type]
           when [Fixnum], [Float]
             same_type(self, @arguments[2], cursig, cursig, context)
-            same_type(@arguments[2], self, cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
 
           when [String]
             same_type(self, @arguments[2], cursig, cursig, context)
-            same_type(@arguments[2], self, cursig, cursig, context)
+            fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             @arguments[3].add_type(context.to_signature, fixtype)
           end
 
@@ -708,9 +835,8 @@ module YTLJit
         end
 
         def compile(context)
-          @arguments[2].type = nil
-          @arguments[2].decide_type_once(context.to_signature)
-          rtype = @arguments[2].type
+          @type = nil
+          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
@@ -765,16 +891,15 @@ module YTLJit
           when [Fixnum], [Float]
             cursig = context.to_signature
             same_type(self, @arguments[2], cursig, cursig, context)
-            same_type(@arguments[2], self, cursig, cursig, context)
+            same_type(self, @arguments[3], cursig, cursig, context)
           end
 
           context
         end
 
         def compile(context)
-          @arguments[2].type = nil
-          @arguments[2].decide_type_once(context.to_signature)
-          rtype = @arguments[2].type
+          @type = nil
+          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
@@ -789,19 +914,22 @@ module YTLJit
                 if context.ret_reg == TMPR then
                   asm.push(TMPR)
                   asm.mov(DBLLOR, TMPR2)
-                  asm.cdq
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
                   asm.idiv(INDIRECT_SPR)
                   asm.add(SPR, AsmType::MACHINE_WORD.size)
                 elsif context.ret_reg.is_a?(OpImmidiateMachineWord) then
                   asm.mov(TMPR, context.ret_reg)
                   asm.push(TMPR)
                   asm.mov(DBLLOR, TMPR2)
-                  asm.cdq
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
                   asm.idiv(INDIRECT_SPR)
                   asm.add(SPR, AsmType::MACHINE_WORD.size)
                 else
                   asm.mov(DBLLOR, TMPR2)
-                  asm.cdq
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
                   asm.idiv(context.ret_reg)
                 end
                 asm.and(DBLHIR, DBLHIR)
@@ -824,13 +952,125 @@ module YTLJit
         end
       end
 
+      class SendModNode<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
+
+        def compile(context)
+          @type = nil
+          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
+            return super(context)
+          end
+
+          if rrtype == Fixnum then
+            context = gen_arithmetic_operation(context, nil, TMPR2, 
+                                               TMPR) do |context|
+              asm = context.assembler
+              asm.with_retry do
+                if context.ret_reg == TMPR then
+                  asm.push(TMPR)
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
+                  asm.idiv(INDIRECT_SPR)
+                  asm.add(SPR, AsmType::MACHINE_WORD.size)
+                elsif context.ret_reg.is_a?(OpImmidiateMachineWord) then
+                  asm.mov(TMPR, context.ret_reg)
+                  asm.push(TMPR)
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
+                  asm.idiv(INDIRECT_SPR)
+                  asm.add(SPR, AsmType::MACHINE_WORD.size)
+                else
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.mov(DBLHIR, DBLLOR)
+                  asm.sar(DBLHIR, AsmType::MACHINE_WORD.size * 8 - 1)
+                  asm.idiv(context.ret_reg)
+                end
+                asm.mov(DBLLOR, DBLHIR)
+                context.end_using_reg(context.ret_reg)
+              end
+            end
+          else
+            raise "Unkown method #{rtype.ruby_type}##{@func.name}"
+          end
+
+          @body.compile(context)
+        end
+      end
+
+      class SendLtLtNode<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 SendGtGtNode<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 SendAndNode<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 SendCompareNode<SendNode
         include SendUtil
         include CompareOperationUtil
         def collect_candidate_type_regident(context, slf)
           cursig = context.to_signature
-          same_type(@arguments[3], @arguments[2], cursig, cursig, context)
-          same_type(@arguments[2], @arguments[3], cursig, cursig, context)
           tt = RubyType::BaseType.from_object(true)
           add_type(cursig, tt)
           tt = RubyType::BaseType.from_object(false)
@@ -839,7 +1079,7 @@ module YTLJit
           context
         end
 
-        def commmon_compile_compare(context, rtype, fixcmp, flocmp)
+        def common_compile_compare(context, rtype, fixcmp, flocmp)
           rrtype = rtype.ruby_type
           if rrtype == Fixnum then
             context = gen_compare_operation(context, :cmp, fixcmp, 
@@ -855,136 +1095,300 @@ module YTLJit
         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 rtype.ruby_type.is_a?(RubyType::DefaultType0) or
+          if rtype.is_a?(RubyType::DefaultType0) or
              @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
 
-          context = gen_eval_self(context)
-          context.ret_node.type = nil
-          srtype = context.ret_node.decide_type_once(context.to_signature)
-          context = srtype.gen_unboxing(context)
-          if rrtype == Fixnum then
-            context = compile_compare(context, rtype)
-
-          elsif rrtype == Float then
+          if rrtype == Fixnum or rrtype == Float then
+            context = gen_eval_self(context)
+            context.ret_node.type = nil
+            srtype = context.ret_node.decide_type_once(context.to_signature)
+            context = srtype.gen_unboxing(context)
             context = compile_compare(context, rtype)
-
+            
           else
-            raise "Unkown method #{rtype.ruby_type} #{@func.name}"
+            tcon = compile_compare_nonnum(context, rtype)
+            if tcon then
+              context = tcon
+            else
+              context = super(context)
+            end
           end
 
           @body.compile(context)
         end
       end
 
+      def compile_compare_nonnum(context, rtype)
+        nil
+      end
+
       class SendGtNode<SendCompareNode
         add_special_send_node :<
         def compile_compare(context, rtype)
-          commmon_compile_compare(context, rtype, :setg, :seta)
+          common_compile_compare(context, rtype, :setg, :seta)
         end
       end
 
       class SendGeNode<SendCompareNode
         add_special_send_node :<=
         def compile_compare(context, rtype)
-          commmon_compile_compare(context, rtype, :setge, :setae)
+          common_compile_compare(context, rtype, :setge, :setae)
         end
       end
 
       class SendLtNode<SendCompareNode
         add_special_send_node :>
         def compile_compare(context, rtype)
-          commmon_compile_compare(context, rtype, :setl, :setb)
+          common_compile_compare(context, rtype, :setl, :setb)
         end
       end
 
       class SendLeNode<SendCompareNode
         add_special_send_node :>=
         def compile_compare(context, rtype)
-          commmon_compile_compare(context, rtype, :setle, :setbe)
+          common_compile_compare(context, rtype, :setle, :setbe)
+        end
+      end
+
+      class SendEqNode<SendCompareNode
+        add_special_send_node :==
+        def compile_compare(context, rtype)
+          common_compile_compare(context, rtype, :setz, :setz)
+        end
+
+        def compile_compare_nonnum(context, rtype)
+          if rtype.include_nil? then
+            context = gen_eval_self(context)
+            gen_compare_operation(context, :cmp, :setz, 
+                                  TMPR2, TMPR, RETR, false)
+          else
+            nil
+          end
+        end
+      end
+
+      class SendNeqNode<SendCompareNode
+        add_special_send_node :!=
+        def compile_compare(context, rtype)
+          common_compile_compare(context, rtype, :setnz, :setnz)
+        end
+
+        def compile_compare_nonnum(context, rtype)
+          if rtype.include_nil? then
+            context = gen_eval_self(context)
+            gen_compare_operation(context, :cmp, :setnz,
+                                  TMPR2, TMPR, RETR, false)
+          else
+            nil
+          end
         end
       end
 
       class SendElementRefNode<SendNode
         include SendUtil
+        include UnboxedArrayUtil
         add_special_send_node :[]
         def collect_candidate_type_regident(context, slf)
-          sig = context.to_signature
+          cursig = context.to_signature
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
-            @arguments[3].add_type(sig, fixtype)
+            @arguments[3].add_type(cursig, fixtype)
             cidx = @arguments[3].get_constant_value
-            @arguments[2].add_element_node(sig, self, cidx, context)
-            decide_type_once(sig)
+
+            # decide type again
             @arguments[2].type = nil
-            @arguments[2].decide_type_once(sig)
-            epare = @arguments[2].element_node_list[0]
+            slf = @arguments[2].decide_type_once(cursig)
+
+            epare = nil
+=begin
             @arguments[2].element_node_list.each do |ele|
-              if ele[2] == cidx and ele[1] != self then
-                epare = ele
-                break
+              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) == [[], []]
+                  epare = epare2
+                  same_type(self, enode, cursig, esig, context)
+                end
               end
             end
-            esig = epare[0]
-            enode = epare[1]
-            if enode != self then
-              same_type(self, enode, sig, esig, context)
+=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
+                  epare2 = ele
+                  esig = epare2[1]
+                  enode = epare2[2]
+                  unless enode.type_list(esig) == [[], []]
+                    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] == cidx and ele[2] != self and 
+                    ele[0].ruby_type == slf.ruby_type then
+                  epare2 = ele
+                  esig = epare2[1]
+                  enode = epare2[2]
+                  unless enode.type_list(esig) == [[], []]
+                    epare = epare2
+                    same_type(self, enode, cursig, esig, context)
+                  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)
             end
 
+            @type = nil
+            
           when [Hash]
             cidx = @arguments[3].get_constant_value
-            @arguments[2].add_element_node(sig, self, cidx, context)
+            rtype = @arguments[2].decide_type_once(sig)
+            @arguments[2].add_element_node(rtype, cursig, self, cidx, context)
           end
 
           context
         end
+
+        def compile(context)
+          sig = context.to_signature
+          rtype = @arguments[2].decide_type_once(sig)
+          rrtype = rtype.ruby_type
+
+          if rrtype == Array and !rtype.boxed and 
+              @arguments[2].is_escape != true then
+            context = gen_ref_element(context, @arguments[2], @arguments[3])
+            @body.compile(context)
+          else
+            super
+          end
+        end
       end
 
       class SendElementAssignNode<SendNode
         include SendUtil
+        include UnboxedArrayUtil
         add_special_send_node :[]=
         def collect_candidate_type_regident(context, slf)
-          sig = context.to_signature
+          cursig = context.to_signature
+          rtype = nil
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             val = @arguments[4]
-            @arguments[3].add_type(sig, fixtype)
+            val.is_escape = :export_object
+            @arguments[3].add_type(cursig, fixtype)
             cidx = @arguments[3].get_constant_value
-            @arguments[2].add_element_node(sig, val, cidx, context)
-            decide_type_once(sig)
             @arguments[2].type = nil
-            @arguments[2].decide_type_once(sig)
-            epare = @arguments[2].element_node_list[0]
-            esig = epare[0]
-            enode = epare[1]
+            slf = @arguments[2].decide_type_once(cursig)
+
+            arg = [slf, cursig, val, cidx, context]
+            @arguments[2].add_element_node_backward(arg)
+
+            epare = nil
+            @arguments[2].element_node_list.each do |ele|
+              if ele[3] == cidx and ele[2] != self then
+                epare = ele
+                break
+              end
+            end
+            if epare == nil then
+              epare = @arguments[2].element_node_list[0]
+              @arguments[2].element_node_list.each do |ele|
+                if ele[3] == nil and ele[2] != self and ele[0] == slf then
+                  epare = ele
+                  break
+                end
+              end
+            end
+
+            esig = epare[1]
+            enode = epare[2]
             if enode != self then
-              same_type(self, enode, sig, esig, context)
-              same_type(enode, self, esig, sig, context)
+              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)
             end
 
           when [Hash]
             cidx = @arguments[3].get_constant_value
-            @arguments[2].add_element_node(sig, self, cidx, context)
+            @arguments[2].add_element_node(slf, sig, self, cidx, context)
+            @arguments[3].set_escape_node_backward(true)
           end
 
           context
         end
+
+        def compile(context)
+          sig = context.to_signature
+          rtype = @arguments[2].decide_type_once(sig)
+          rrtype = rtype.ruby_type
+          if rrtype == Array and !rtype.boxed and 
+              @arguments[2].is_escape != true then
+            context = gen_set_element(context, 
+                                      @arguments[2], 
+                                      @arguments[3], 
+                                      @arguments[4])
+            @body.compile(context)
+          else
+            super
+          end
+        end
       end
 
       class SendToFNode<SendNode
+        include AbsArch
+
         add_special_send_node :to_f
+
         def collect_candidate_type_regident(context, slf)
           sig = context.to_signature
           floattype = RubyType::BaseType.from_ruby_class(Float)
           add_type(sig, floattype)
           context
         end
+
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rrtype == Fixnum 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.cvtsi2sd(XMM0, context.ret_reg)
+              end
+            else
+              asm.with_retry do
+                asm.mov(TMPR, context.ret_reg)
+                asm.cvtsi2sd(XMM0, TMPR)
+              end
+            end
+            context.ret_node = self
+            context.ret_reg = XMM0
+            context
+          else
+            super(context)
+          end
+        end
       end
 
       class SendToINode<SendNode
@@ -997,6 +1401,16 @@ module YTLJit
         end
       end
 
+      class SendChrNode<SendNode
+        add_special_send_node :chr
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          strtype = RubyType::BaseType.from_ruby_class(String)
+          add_type(sig, strtype)
+          context
+        end
+      end
+
       class SendAMNode<SendNode
         add_special_send_node :-@
         def collect_candidate_type_regident(context, slf)
@@ -1035,6 +1449,9 @@ module YTLJit
           end
           context.ret_node = self
 
+          if rtype.boxed then
+            context = rtype.to_unbox.gen_boxing(context)
+          end
           @body.compile(context)
         end
       end
@@ -1056,8 +1473,8 @@ module YTLJit
           cursig = context.to_signature
           if slf.ruby_type == Range then
             epare = @arguments[2].element_node_list[0]
-            esig = epare[0]
-            enode = epare[1]
+            esig = epare[1]
+            enode = epare[2]
             tt = enode.decide_type_once(esig)
             add_type(cursig, tt)
           else
@@ -1068,9 +1485,12 @@ module YTLJit
         end
 
         def compile(context)
-          rtype = @arguments[2].decide_type_once(context.to_signature)
+          sig = context.to_signature
+          rtype = @arguments[2].decide_type_once(sig)
           rrtype = rtype.ruby_type
-          if rrtype == Range and !rtype.boxed then
+          decide_type_once(sig)
+          if rrtype == Range and !rtype.boxed and 
+              @arguments[2].is_escape != true then
             context = @arguments[2].compile(context)
             slotoff = OpIndirect.new(TMPR, arg_offset)
             asm = context.assembler
@@ -1145,6 +1565,27 @@ module YTLJit
       class SendPNode<SendSameArgTypeNode
         add_special_send_node :p
       end
+ 
+      class SendSameSelfTypeNode<SendNode
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          same_type(self, @arguments[2], sig, sig, context)
+          context
+        end
+      end
+
+     class SendDupNode<SendSameSelfTypeNode
+        add_special_send_node :dup
+       
+       def compile(context)
+         sig = context.to_signature
+         rtype = @arguments[2].decide_type_once(sig)
+         rrtype = rtype.ruby_type
+         context = @arguments[2].compile(context)
+         context = rtype.gen_copy(context)
+         @body.compile(context)
+       end
+      end
 
       class SendMathFuncNode<SendNode
         include SendUtil
@@ -1257,17 +1698,61 @@ module YTLJit
       end
 
       class RetArraySendNode<RawSendNode
+        include AbsArch
+        include UnboxedArrayUtil
+
         def collect_candidate_type_body(context)
           sig = context.to_signature
           tt = RubyType::BaseType.from_ruby_class(Array)
+          if context.options[:compile_array_as_uboxed] and
+              @element_node_list.size > 1 and 
+                @element_node_list[1..-1].all? {|e|
+                  e[3]
+                } then
+            tt = tt.to_unbox
+          end
+
           add_type(sig, tt)
+          @type = nil
+          tt = decide_type_once(sig)
 
           @arguments[1..-1].each_with_index do |anode, idx|
-            add_element_node(sig, anode, [idx], context)
+            add_element_node(tt, sig, anode, [idx], context)
           end
 
           context
         end
+
+        def compile(context)
+          sig = context.to_signature
+          rtype = decide_type_once(sig)
+          rrtype = rtype.ruby_type
+          if rrtype == Array and !rtype.boxed and @is_escape != true 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)
+            asm = context.assembler
+            asm.with_retry do
+              asm.mov(TMPR2, THEPR)
+            end
+
+            @arguments[1..-1].each_with_index do |anode, idx|
+              context = gen_set_element(context, nil, idx, anode)
+            end
+
+            asm.with_retry do
+              asm.mov(RETR, TMPR2)
+            end
+            context.end_arg_reg(TMPR2)
+
+            context.ret_reg = RETR
+            context.ret_node = self
+            @body.compile(context)
+          else
+            super
+          end
+        end
       end
     end
   end