ytljit 0.0.8 → 0.0.9

data/lib/ytljit/vm_sendnode.rb

@@ -99,6 +99,20 @@ module YTLJit
                   argruby = ele.to_ruby(ToRubyContext.new).ret_code.last
                   args.push eval(argruby)
                 end
+
+                # define used methods in macro
+                @@macro_tab.each do |name, val|
+                  val.each do |rec, proc|
+                    if rec.is_a?(Module) then
+                      name1 = ("ytl__eval_" + name.to_s).to_sym
+                      if proc.is_a?(Proc)
+                        rec.class_eval {define_method(name1, &proc)}
+                      end
+                    end
+                  end
+                end
+
+                # call eval included method
                 return mproc.call(*args)
               end
             end
@@ -140,6 +154,7 @@ module YTLJit
 
           @result_cache = nil
           @method_signature = []
+          @yield_signature_cache = {}
 
           @current_exception_table = nil
         end
@@ -154,9 +169,20 @@ module YTLJit
         attr          :modified_instance_var
         attr_accessor :result_cache
         attr          :seq_no
+        attr          :yield_signature_cache
 
         attr_accessor :current_exception_table
 
+        def traverse_node(&blk)
+          @arguments.each_with_index do |arg, i|
+            if arg.is_a?(SendNode) then
+              arg.traverse_node(&blk)
+            else
+              yield(arg, @arguments, i)
+            end
+          end
+        end
+
         def traverse_childlen
           @arguments.each do |arg|
             yield arg
@@ -167,14 +193,20 @@ module YTLJit
 
         def get_send_method_node(cursig)
           mt = nil
-          # @arguments[2].type = nil
-          slf = @arguments[2].decide_type_once(cursig)
+          if @arguments[2].type_list(cursig) != [[], []] then
+            @arguments[2].type = nil
+          end
+          slf = nil
           if is_fcall or is_vcall then
+            slf =  @arguments[2].decide_type_once(cursig)
             mt = @func.method_top_node(@class_top, nil)
-            
           else
+            slf = @arguments[2].decide_type_once(cursig)
             if slf.instance_of?(RubyType::DefaultType0) then
               # Chaos
+              #p debug_info
+              #p cursig
+              #p @arguments[2].instance_eval { @type_list }
               #            raise "chaos"
             end
             
@@ -213,8 +245,8 @@ module YTLJit
             end
           end
 
-          @modified_local_var    = context.modified_local_var.last.dup
-          @modified_instance_var = context.modified_instance_var.dup
+          @modified_local_var    = context.modified_local_var.last
+          @modified_instance_var = context.modified_instance_var
 
           context = fill_result_cache(context)
 
@@ -248,15 +280,105 @@ module YTLJit
           end
         end
 
+        # inherit self/block from caller node
+        def inherit_from_callee(context, cursig, prevsig, signat, args, nest)
+          if context.is_a?(TypeInferenceContext) then
+            (0..2).each do |n|
+              args[n] = context.current_method_signature_node[-2 - nest][n]
+            end
+          end
+          (0..2).each do |n|
+            signat[n] = prevsig[n]
+          end
+
+          if args[2].decide_type_once(cursig).ruby_type == Object then
+            context.current_method_signature_node.reverse.each {|e0| 
+              if e0[2].class == SendNewArenaNode then
+                if args[2].type then
+                  args[2] = e0[2]
+                  signat[2] = args[2].type
+                end
+                break
+              end
+            }
+          end
+        end
+
+        def collect_candidate_type_block(context, blknode, signat, mt, cursig)
+          # traverse a nested block
+          # mt and signat are set corresponding to the nest level of yield
+          if @func.is_a?(YieldNode) and false then
+            level = @depth
+          else
+            level = 0
+          end
+          nest = 0
+          sn = nil
+          while mt.yield_node.size == 0 and
+              mt.send_nodes_with_block.size != 0
+            sn = mt.send_nodes_with_block[0]
+            mt, slf = sn.get_send_method_node(cursig)
+            if mt == nil then
+              return context
+            end
+            args = sn.arguments
+
+            context.push_signature(args, mt)
+
+            nest = nest + 1
+            if mt.yield_node.size == 0 then
+              break
+            end
+            ynode = mt.yield_node[0]
+            yargs = ynode.arguments.dup
+            (0..2).each do |n|
+              cl = nest + level
+              yargs[n] = context.current_method_signature_node[-1 - cl][n]
+            end
+            mt = args[1]
+            context.push_signature(yargs, mt)
+            nest = nest + 1
+          end
+          if sn then
+            signat = sn.signature(context)
+          end
+
+          mt.yield_node.map do |ynode|
+            yargs = ynode.arguments.dup
+            yargs[2.. -1].each do |arg|
+              context = arg.collect_candidate_type(context)
+            end
+            ysignat = ynode.signature(context)
+
+            # inherit self from caller node
+            # notice: this region pushed callee signature_node
+            cl =   nest + level
+            prevsig = context.to_signature(-2 - cl)
+            inherit_from_callee(context, cursig, prevsig, ysignat, yargs, cl)
+#            ysignat[1] = signat[0]
+            
+            # collect candidate type of block and yield
+            context = blknode.collect_candidate_type(context, yargs, ysignat)
+            same_type(ynode, blknode, signat, ysignat, context)
+            @yield_signature_cache[cursig] = ysignat
+            
+            # fill type cache(@type) of block node
+            blknode.type = nil
+            blknode.decide_type_once(ysignat)
+          end
+
+          nest.times do 
+            context.pop_signature
+          end
+          
+          context
+        end
+
         def collect_candidate_type(context)
           cursig = context.to_signature
 
           # get saved original signature
           metsigent = search_signature(cursig)
-          oldsignat = nil
-          if metsigent then
-            oldsignat = metsigent[1]
-          end
 
           # prev env
           context = @arguments[0].collect_candidate_type(context)
@@ -273,7 +395,13 @@ module YTLJit
           context = @func.collect_candidate_type(context)
 
           signat = signature(context)
-          changed = check_signature_changed(context, signat, metsigent, cursig)
+          ysig = @yield_signature_cache[cursig]
+          if ysig then
+            signat[1] = blknode.decide_type_once(ysig)
+          end
+          if @func.is_a?(YieldNode) then
+            signat[1] = cursig[0]
+          end
 =begin
           if changed then
             @arguments.each do |arg|
@@ -285,57 +413,52 @@ module YTLJit
 
           mt, slf = get_send_method_node(cursig)
           if mt then
+=begin
+            changed = check_signature_changed(context, signat, 
+                                              metsigent, cursig)
             if changed then
               mt.type_list(metsigent[1])[1] = []
               mt.ti_reset
             end
+=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
+              context.push_signature(@arguments, mt)
               # Have block
-              mt.yield_node.map do |ynode|
-                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)
-
+              context = collect_candidate_type_block(context, blknode, 
+                                                     signat, mt, cursig)
+              context.pop_signature
+              if signat[1] != blknode.type then
+                signat[1] = blknode.type
+                context = mt.collect_candidate_type(context, 
+                                                    @arguments, signat)
               end
             else
+              context.push_signature(@arguments, mt)
               context = blknode.collect_candidate_type(context)
+              context.pop_signature
             end
-            context.pop_signature
-            
+            same_type(self, mt, cursig, signat, context)
+
           else
             context = collect_candidate_type_regident(context, slf)
           end
 
+          if @func.is_a?(YieldNode) then
+            add_type(cursig, cursig[1])
+            @type = nil
+            decide_type_once(cursig)
+          end
           @body.collect_candidate_type(context)
         end
 
         def compile(context)
           context = super(context)
 
+          @type = nil
+          cursig = context.to_signature
           context.start_using_reg(TMPR2)
           context.start_using_reg(PTMPR)
           callconv = @func.calling_convention(context)
@@ -353,14 +476,29 @@ module YTLJit
           when :ytl
             context = compile_ytl(context)
 
+          when :getter
+            inode = @func.inline_node
+            context = @arguments[2].compile(context)
+            rectype = @arguments[2].decide_type_once(cursig)
+            context = inode.compile_main_aux(context, context.ret_reg, rectype)
+
+          when :setter
+            inode = @func.inline_node
+            context = @arguments[2].compile(context)
+            rectype = @arguments[2].decide_type_once(cursig)
+            context = inode.compile_main_aux(context, context.ret_reg, rectype, 
+                                             @arguments[3], nil)
+
           when nil
 
           else
-            raise "Unsupported calling conversion #{callconv}"
+#            p @arguments[2].type_list(context.to_signature)
+#            p @func.name
+#            raise "Unsupported calling conversion #{callconv}"
           end
           
-          decide_type_once(context.to_signature)
-          if @type.is_a?(RubyType::RubyTypeUnboxed) and 
+          decide_type_once(cursig)
+          if !@type.boxed and 
               @type.ruby_type == Float then
             context.ret_reg = XMM0
           else
@@ -496,16 +634,66 @@ module YTLJit
         add_special_send_node :eval
       end
 
+      class SendEvalNode<SendNode
+        add_special_send_node :unpack
+
+        def collect_candidate_type_regident(context, slf)
+          if slf.ruby_type == String
+            cursig = context.to_signature
+            arytype = RubyType::BaseType.from_ruby_class(Array)
+            add_type(cursig, arytype)
+
+            fmt = @arguments[3].get_constant_value
+            if fmt.is_a?(Array) and fmt[0].is_a?(String) then
+              fmt = fmt[0]
+            else
+              fmt = nil
+            end
+            fmt.each_char do |ch|
+              type = nil
+              case ch
+              when 'c', 'C', 's', 'S', 'i', 'I', 'l', 'L', 'n', 'N', 'v', 'V'
+                type = RubyType::BaseType.from_ruby_class(Fixnum)
+
+              when 'a', 'A', 'Z', 'b', 'B', 'h', 'H', 'm', 'M', 'u', 'U', 'w'
+                type = RubyType::BaseType.from_ruby_class(String)
+                
+              when 'f', 'd', 'e', 'E', 'g', 'G'
+                type = RubyType::BaseType.from_ruby_class(Float)
+
+              end
+
+              if type then
+                tnode = TypedDummyNode.instance(cursig, type)
+                add_element_node(arytype, cursig, tnode, nil, context)
+              end
+            end
+          end
+
+          context
+        end
+      end
+
       class SendIncludeCommonNode<SendNode
+        def collect_info(context)
+          slfnode = @arguments[2]
+          modvalue = @arguments[3].value_node
+          modnode = ClassTopNode.get_class_top_node(modvalue.get_constant_value[0])
+          add_search_module(slfnode, modnode)
+          super
+        end
+
         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
+
+        def compile(context)
+          @body.compile(context)
+        end
       end
 
       class SendIncludeNode<SendIncludeCommonNode
@@ -528,6 +716,7 @@ module YTLJit
 
       class SendAllocateNode<SendNode
         include UnboxedObjectUtil
+        include SendSingletonClassUtil
 
         add_special_send_node :allocate
 
@@ -535,25 +724,11 @@ module YTLJit
           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)
-              when LiteralNode
-                tt = RubyType::BaseType.from_ruby_class(clstop.value)
-              else
-                raise "Unkown node type in constant #{slfnode.value_node.class}"
-              end
-
-            else
-              raise "Unkonwn node type #{@arguments[2].class} "
-            end
-
+            tt = get_singleton_class_object(@arguments[2])
             clt =  ClassTopNode.get_class_top_node(tt.ruby_type_raw)
+            @type = nil
             if context.options[:compile_array_as_uboxed] and
+                tt.ruby_type != Array and
                 @is_escape and @is_escape != :global_export and
                 (clt and  !clt.body.is_a?(DummyNode)) then
               tt = tt.to_unbox
@@ -561,6 +736,48 @@ module YTLJit
               type_list(cursig)[0] = []
             end
 
+            # set element type
+            parg = @parent.arguments
+            if tt.ruby_type == Range then
+              if @is_escape != :global_export then
+                tt = tt.to_unbox
+              end
+              tt.args = parg[3..-1]
+              add_element_node(tt, cursig, parg[3], [0], context)
+              add_element_node(tt, cursig, parg[4], [1], context)
+              
+            elsif tt.ruby_type == Array then
+              if context.options[:compile_array_as_uboxed] and 
+                  @is_escape and @is_escape != :global_export then
+                if @element_node_list.size > 1 and
+                    @element_node_list[1..-1].all? {|e|
+                    e[3] or e[2].class == BaseNode
+                  } then
+                  tt = tt.to_unbox
+                elsif parg[3] and 
+                    siz0 = parg[3].get_constant_value and 
+                    (siz = siz0[0]) < 10 then
+                  @element_node_list = []
+                  dnode = LiteralNode.new(self, nil)
+                  tt = tt.to_unbox
+                  siz.times do |i|
+                    add_element_node(tt, cursig, dnode, [i], context)
+                  end
+                end
+              end
+              if parg[4] then
+                siz = parg[3].get_constant_value
+                if siz and false then
+                  # Here is buggy yet Fix me
+                  siz[0].times do |i|
+                    add_element_node(tt, cursig, parg[4], [i], context)
+                  end
+                else
+                  add_element_node(tt, cursig, parg[4], nil, context)
+                end
+              end
+            end
+
             add_type(cursig, tt)
           end
           context
@@ -659,67 +876,15 @@ module YTLJit
           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
-              case clstop
-              when ClassTopNode
-                tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                
-              when LiteralNode
-                tt = RubyType::BaseType.from_ruby_class(clstop.value)
-
-              else
-                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, 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]
-                      } and 
-                    @is_escape and @is_escape != :global_export 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, cursig, @arguments[4], [i], context)
-                    end
-                  else
-                    add_element_node(tt, cursig, @arguments[4], nil, context)
-                  end
-                end
-              end
-
-              add_type(cursig, tt)
-            else
-              raise "Unkonwn node type #{@arguments[2].class} "
-            end
+            set_escape_node(@parent.is_escape)
+            @allocmethod.set_escape_node(@is_escape)
+            @initmethod.type = nil
+            context = @initmethod.collect_candidate_type(context)
+            same_type(self, @allocmethod, cursig, cursig, context)
+            context
+          else
+            super
           end
-          context
         end
 
         def compile_range(context)
@@ -744,7 +909,7 @@ module YTLJit
             end
             off = off + AsmType::MACHINE_WORD.size
           end
-          
+
           context.ret_reg = breg
           context.ret_node = self
           context
@@ -752,11 +917,23 @@ module YTLJit
 
         def compile(context)
           rtype = @arguments[2].decide_type_once(context.to_signature)
+          if context.options[:insert_signature_comment] then
+            lineno = debug_info[3]
+            fname = debug_info[0]
+            context.comment[fname] ||= {}
+            context.comment[fname][lineno] ||= []
+            ent = []
+            ent.push 2
+            ent.push is_escape
+            ent.push rtype
+            context.comment[fname][lineno].push ent
+          end
+
           rrtype = rtype.ruby_type
           if rrtype.is_a?(Class) then
             ctype = decide_type_once(context.to_signature)
             crtype = ctype.ruby_type
-            if @is_escape != :global_export and 
+            if !ctype.boxed and 
                 crtype == Range then
               return compile_range(context)
               
@@ -786,11 +963,13 @@ module YTLJit
         add_special_send_node :+
 
         def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
           case [slf.ruby_type]
           when [Fixnum], [Float], [String], [Array]
-            cursig = context.to_signature
             same_type(self, @arguments[2], cursig, cursig, context)
             same_type(self, @arguments[3], cursig, cursig, context)
+          else
+            same_type(self, @arguments[2], cursig, cursig, context)
           end
 
           context
@@ -803,6 +982,7 @@ module YTLJit
           rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
               rrtype == Array or
+              rrtype == String or
               @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
@@ -877,6 +1057,11 @@ module YTLJit
             same_type(self, @arguments[2], cursig, cursig, context)
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             @arguments[3].add_type(context.to_signature, fixtype)
+
+          when [Array]
+            same_type(self, @arguments[2], cursig, cursig, context)
+            fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
+            @arguments[3].add_type(context.to_signature, fixtype)
           end
 
           context
@@ -887,6 +1072,8 @@ module YTLJit
           rtype = decide_type_once(context.to_signature)
           rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
+              rrtype == String or
+              rrtype == Array or
              @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
@@ -1069,7 +1256,6 @@ module YTLJit
       end
 
       class SendLtLtNode<SendNode
-        include ArithmeticOperationUtil
         include SendUtil
         add_special_send_node :<<
 
@@ -1082,9 +1268,19 @@ module YTLJit
 
           when [Array]
             val = @arguments[3]
+            if slf.boxed and val.is_escape != :global_export then
+              val.set_escape_node_backward(:global_export)
+              context = val.collect_candidate_type(context)
+            else
+              val.set_escape_node_backward(:local_export)
+            end
             arg = [slf, cursig, val, nil, context]
             @arguments[2].add_element_node_backward(arg)
             same_type(self, val, cursig, cursig, context)
+
+          when [String]
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
           end
 
           context
@@ -1092,7 +1288,6 @@ module YTLJit
       end
 
       class SendGtGtNode<SendNode
-        include ArithmeticOperationUtil
         include SendUtil
         add_special_send_node :>>
 
@@ -1109,7 +1304,6 @@ module YTLJit
       end
 
       class SendAndNode<SendNode
-        include ArithmeticOperationUtil
         include SendUtil
         add_special_send_node :&
 
@@ -1126,7 +1320,6 @@ module YTLJit
       end
 
       class SendOrNode<SendNode
-        include ArithmeticOperationUtil
         include SendUtil
         add_special_send_node :|
 
@@ -1143,7 +1336,6 @@ module YTLJit
       end
 
       class SendXorNode<SendNode
-        include ArithmeticOperationUtil
         include SendUtil
         add_special_send_node :^
 
@@ -1160,14 +1352,13 @@ module YTLJit
       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]
+          when [Array], [String]
             tt = RubyType::BaseType.from_ruby_class(Fixnum)
             add_type(cursig, tt)
           end
@@ -1176,6 +1367,117 @@ module YTLJit
         end
       end
 
+      class SendCountNode<SendNode
+        include SendUtil
+        add_special_send_node :count
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [String]
+            tt = RubyType::BaseType.from_ruby_class(Fixnum)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
+      class SendStripExNode<SendNode
+        include SendUtil
+        add_special_send_node :strip!
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [String]
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
+            tt = RubyType::BaseType.from_ruby_class(NilClass)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
+      class SendTrExNode<SendNode
+        include SendUtil
+        add_special_send_node :tr!
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [String]
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
+      class SendOpenNode<SendNode
+        include SendUtil
+        include SendSingletonClassUtil
+        add_special_send_node :open
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [NilClass], [Object]
+            tt = RubyType::BaseType.from_ruby_class(IO)
+            add_type(cursig, tt)
+          when [Class]
+            clsobj = get_singleton_class_object(@arguments[2])
+            if clsobj.ruby_type <= IO then
+              tt = RubyType::BaseType.from_ruby_class(IO)
+              add_type(cursig, tt)
+            end
+          end
+
+          context
+        end
+      end
+
+      class SendReadNode<SendNode
+        include SendUtil
+        add_special_send_node :read
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          case [slf.ruby_type]
+          when [IO], [NilClass], [Object]
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
+      class SendGetsNode<SendReadNode
+        add_special_send_node :gets
+      end
+
+      class SendDirnameNode<SendNode
+        include SendUtil
+        include SendSingletonClassUtil
+        add_special_send_node :dirname
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          if slf.ruby_type == Class and
+              clsobj = get_singleton_class_object(@arguments[2])  and
+              clsobj.ruby_type <= File then
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
+          end
+
+          context
+        end
+      end
+
       class SendCompareNode<SendNode
         include SendUtil
         include CompareOperationUtil
@@ -1205,7 +1507,9 @@ module YTLJit
         end
 
         def compile(context)
-          rtype = @arguments[2].decide_type_once(context.to_signature)
+          cursig = context.to_signature
+          @arguments[2].type = nil
+          rtype = @arguments[2].decide_type_once(cursig)
           rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
              @class_top.search_method_with_super(@func.name, rrtype)[0] then
@@ -1215,7 +1519,7 @@ module YTLJit
           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)
+            srtype = context.ret_node.decide_type_once(cursig)
             context = srtype.gen_unboxing(context)
             context = compile_compare(context, rtype)
             
@@ -1308,7 +1612,8 @@ module YTLJit
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             idxtype = @arguments[3].decide_type_once(cursig)
-            if idxtype.ruby_type == Range then
+            if idxtype.ruby_type == Range or 
+                @arguments[4] then
               same_type(self, @arguments[2], cursig, cursig, context)
               return context
             end
@@ -1318,6 +1623,8 @@ module YTLJit
             # decide type again
             @arguments[2].type = nil
             slf = @arguments[2].decide_type_once(cursig)
+#            p debug_info
+#            p @arguments[2].type_list(cursig)
 
             epare = nil
 
@@ -1327,7 +1634,7 @@ module YTLJit
                 epare2 = ele
                 esig = epare2[1]
                 enode = epare2[2]
-                if enode.type_list(esig) != [[], []] then
+                if enode.decide_type_once(esig).ruby_type != Object  then
                   epare = epare2
                   same_type(self, enode, cursig, esig, context)
                 end
@@ -1341,7 +1648,7 @@ module YTLJit
                   epare2 = ele
                   esig = epare2[1]
                   enode = epare2[2]
-                  if enode.type_list(esig) != [[], []] then
+                  if enode.decide_type_once(esig).ruby_type != Object then
                     epare = epare2
                     same_type(self, enode, cursig, esig, context)
                   end
@@ -1351,16 +1658,15 @@ module YTLJit
 
 =begin
             if epare == nil then
-              @arguments[2].element_node_list.reverse.each do |ele|
+              @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) == [[], []]
+                  if enode.decide_type_once(esig).ruby_type != Object then
                     epare = epare2
                     same_type(self, enode, cursig, esig, context)
-                    break
                   end
                 end
               end
@@ -1369,7 +1675,7 @@ module YTLJit
             if epare == nil then
               nele = @arguments[2].element_node_list.select {|e| e[3] == nil}
               if nele.size == 1 then
-                epare = @arguments[2].element_node_list[0]
+                epare = nele[0]
                 esig = epare[1]
                 enode = epare[2]
                 same_type(self, enode, cursig, esig, context)
@@ -1378,11 +1684,15 @@ module YTLJit
 =end
 
             if epare == nil then
-              if slf.have_element? and slf.element_type then
+              if slf.have_element? and 
+                  slf.element_type and 
+                  slf.element_type[nil] and 
+                  slf.element_type[nil][0] then
                 add_type(cursig, slf.element_type[nil][0])
+              else
+                p "foo"
               end
             end
-
             @type = nil
             
           when [Hash]
@@ -1392,6 +1702,10 @@ module YTLJit
             @arguments[3].type = nil
             @arguments[3].add_type(cursig, niltype)
             @arguments[2].add_element_node(rtype, cursig, self, cidx, context)
+
+          when [String]
+            tt = RubyType::BaseType.from_ruby_class(String)
+            add_type(cursig, tt)
           end
 
           context
@@ -1400,13 +1714,14 @@ module YTLJit
         def compile(context)
           sig = context.to_signature
           asm = context.assembler
-          @arguments[2].type = nil
+#          @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 != :global_export then
             context = gen_ref_element(context, @arguments[2], @arguments[3])
+#            @type = nil
             rtype = decide_type_once(sig)
             if rtype.ruby_type == Float and !rtype.boxed then
               asm.with_retry do
@@ -1441,47 +1756,26 @@ module YTLJit
         add_special_send_node :[]=
         def collect_candidate_type_regident(context, slf)
           cursig = context.to_signature
-          rtype = nil
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
             val = @arguments[4]
-            val.is_escape = :local_export
             @arguments[3].add_type(cursig, fixtype)
             cidx = @arguments[3].get_constant_value
             @arguments[2].type = nil
             slf = @arguments[2].decide_type_once(cursig)
 
+            val.type = nil
+            if slf.boxed and val.is_escape != :global_export then
+              val.set_escape_node_backward(:global_export)
+              context = val.collect_candidate_type(context)
+            else
+              val.set_escape_node_backward(:local_export)
+            end
             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, cursig, esig, context)
-            end
-            if slf.boxed then
-              @arguments[4].set_escape_node_backward(:global_export)
-            else
-              @arguments[4].set_escape_node_backward(:local_export)
-            end
+            same_type(self, val, cursig, cursig, context)
 
           when [Hash]
             cidx = @arguments[3].get_constant_value
@@ -1515,6 +1809,17 @@ module YTLJit
         end
       end
 
+      class Send__ID__Node<SendNode
+        add_special_send_node :__id__
+
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          fixnumtype = RubyType::BaseType.from_ruby_class(Fixnum)
+          add_type(sig, fixnumtype)
+          context
+        end
+      end
+
       class SendToFNode<SendNode
         include AbsArch
 
@@ -1528,6 +1833,7 @@ module YTLJit
         end
 
         def compile(context)
+#          @arguments[2].type = nil
           @arguments[2].decide_type_once(context.to_signature)
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
@@ -1565,6 +1871,7 @@ module YTLJit
         end
 
         def compile(context)
+#          @arguments[2].type = nil
           @arguments[2].decide_type_once(context.to_signature)
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
@@ -1612,6 +1919,7 @@ module YTLJit
         end
 
         def compile(context)
+#          @arguments[2].type = nil
           @arguments[2].decide_type_once(context.to_signature)
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
@@ -1653,9 +1961,16 @@ module YTLJit
       class SendRandNode<SendNode
         add_special_send_node :rand
         def collect_candidate_type_regident(context, slf)
-          sig = context.to_signature
-          floattype = RubyType::BaseType.from_ruby_class(Float)
-          add_type(sig, floattype)
+          cursig = context.to_signature
+          if @arguments[3] then
+            # when argument is 0, type is Float
+            # but ignor it by current version
+            context = @arguments[3].collect_candidate_type(context)
+            tt = RubyType::BaseType.from_ruby_class(Fixnum)
+          else
+            tt = RubyType::BaseType.from_ruby_class(Float)
+          end
+          add_type(cursig, tt)
           context
         end
       end
@@ -1679,12 +1994,12 @@ module YTLJit
         end
 
         def compile(context)
-          sig = context.to_signature
-          rtype = @arguments[2].decide_type_once(sig)
+          cursig = context.to_signature
+          @arguments[2].type = nil
+          rtype = @arguments[2].decide_type_once(cursig)
           rrtype = rtype.ruby_type
-          decide_type_once(sig)
-          if rrtype == Range and !rtype.boxed and 
-              @arguments[2].is_escape != :global_export then
+          decide_type_once(cursig)
+          if rrtype == Range and !rtype.boxed then
             context = @arguments[2].compile(context)
             slotoff = OpIndirect.new(TMPR, arg_offset)
             asm = context.assembler
@@ -1740,6 +2055,8 @@ module YTLJit
       end
 
       class SendSizeNode<SendNode
+        include SendUtil
+        include UnboxedArrayUtil
         add_special_send_node :size
         def collect_candidate_type_regident(context, slf)
           cursig = context.to_signature
@@ -1747,6 +2064,25 @@ module YTLJit
           add_type(cursig, tt)
           context
         end
+
+        def compile(context)
+          sig = context.to_signature
+          asm = context.assembler
+          rtype = @arguments[2].decide_type_once(sig)
+          rrtype = rtype.ruby_type
+          if rrtype == Array and !rtype.boxed and 
+              @arguments[2].is_escape != :global_export then
+            context = gen_ref_element(context, @arguments[2], -1)
+            asm.with_retry do
+              asm.mov(RETR, context.ret_reg)
+            end
+            context.ret_reg = RETR
+            context.set_reg_content(RETR, self)
+            @body.compile(context)
+          else
+            super
+          end
+        end
       end
 
       class SendSameArgTypeNode<SendNode
@@ -1764,16 +2100,67 @@ module YTLJit
      class SendDispTypeNode<SendNode
         add_special_send_node :disp_type
         def collect_candidate_type_regident(context, slf)
+#=begin
           sig = context.to_signature
           p debug_info
           p sig
           p @arguments[2].type_list(sig)
-#          p @arguments[2].instance_eval {@type_list}
+          @arguments[2].type = nil
+          p @arguments[2].decide_type_once(sig)
+          #          p @arguments[2].instance_eval {@type_list}
+          p @arguments[2].is_escape
           p @arguments[2].class
+#=end
           context
         end
 
        def compile(context)
+=begin
+         sig = context.to_signature
+         p debug_info
+         p sig
+         p @arguments[2].type_list(sig)
+         @arguments[2].type = nil
+         p @arguments[2].decide_type_once(sig)
+         #          p @arguments[2].instance_eval {@type_list}
+         p @arguments[2].is_escape
+         p @arguments[2].class
+=end
+         @body.compile(context)
+       end
+     end
+
+     class SendSelfOfCallerTypeNode<SendNode
+       include NodeUtil
+       add_special_send_node :self_of_caller
+       
+       def initialize(parent, func, arguments, op_flag, seqno)
+         super
+         @frame_info = search_frame_info
+       end
+       
+       def collect_candidate_type_regident(context, slf)
+         cursig = context.to_signature
+         callersig = context.to_signature(-2)
+         tt = callersig[2]
+         add_type(cursig, tt)
+         context
+       end
+       
+       def compile(context)
+         asm = context.assembler
+         prevenv = @frame_info.offset_arg(0, BPR)
+         # offset of self is common, so it no nessery traverse 
+         # prev frame for @frame_info.
+         slfarg = @frame_info.offset_arg(2, TMPR2)
+         context.start_using_reg(TMPR2)
+         asm.with_retry do
+           asm.mov(TMPR2, prevenv)
+           asm.mov(RETR, slfarg)
+         end
+         context.end_using_reg(TMPR2)
+         context.ret_reg = RETR
+         context.ret_node = self
          @body.compile(context)
        end
      end
@@ -1799,13 +2186,25 @@ module YTLJit
        end
       end
 
+      class SendCloneNode<SendDupNode
+        add_special_send_node :clone
+      end
+
       class SendSortNode<SendSameSelfTypeNode
         add_special_send_node :sort
       end
 
-      class SendSortNode<SendSameSelfTypeNode
+      class SendUniqExNode<SendSameSelfTypeNode
         add_special_send_node :uniq!
       end
+
+      class SendSliceExNode<SendSameSelfTypeNode
+        add_special_send_node :slice!
+      end
+
+      class SendReverseNode<SendSameSelfTypeNode
+        add_special_send_node :reverse
+      end
  
       class SendMathFuncNode<SendNode
         include SendUtil
@@ -1831,11 +2230,19 @@ module YTLJit
           end
           context.set_reg_content(FUNC_FLOAT_ARG[0].dst_opecode, 
                                   context.ret_node)
-          asm.with_retry do
-            asm.call_with_arg(fadd, 1)
-            asm.sub(SPR, 8)
-            asm.fstpl(INDIRECT_SPR)
-            asm.pop(XMM0)
+          case $ruby_platform
+          when /x86_64/
+            asm.with_retry do
+              asm.call_with_arg(fadd, 1)
+            end
+
+          when /i.86/
+            asm.with_retry do
+              asm.call_with_arg(fadd, 1)
+              asm.sub(SPR, 8)
+              asm.fstpl(INDIRECT_SPR)
+              asm.pop(XMM0)
+            end
           end
           context.end_arg_reg
           context.end_arg_reg(FUNC_FLOAT_ARG)
@@ -1901,6 +2308,16 @@ module YTLJit
         end
       end
 
+      class SendLogNode<SendMathFuncNode
+        add_special_send_node :log
+        def compile_main(context)
+          context = compile_call_func(context, "log")
+          context.ret_node = self
+          context.ret_reg = XMM0
+          context
+        end
+      end
+
       class RawSendNode<SendNode
         def collect_candidate_type(context)
           @arguments.each do |arg|
@@ -1933,7 +2350,7 @@ module YTLJit
           if context.options[:compile_array_as_uboxed] and
               @element_node_list.size > 1 and 
                 @element_node_list[1..-1].all? {|e|
-                  e[3]
+                  e[3] or e[2].class == BaseNode
                 } then
             tt = tt.to_unbox
           end
@@ -1956,19 +2373,21 @@ module YTLJit
           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
+            sizent = @element_node_list[1..-1].max_by {|a| a[3] ? a[3][0] : -1}
+            siz = sizent[3][0] + 1
             context = gen_alloca(context, siz)
 
             context.start_using_reg(TMPR2)
             asm = context.assembler
             asm.with_retry do
               asm.mov(TMPR2, THEPR)
+              asm.mov(INDIRECT_TMPR2, siz)
+              asm.add(TMPR2, 8)
             end
+            context.set_reg_content(TMPR2, THEPR)
 
             @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