ytljit 0.0.3 → 0.0.4

data/lib/ytljit/instruction_ia.rb

@@ -749,12 +749,20 @@ module YTLJit
         when OpRegXMM
           rexseq, rexfmt = rex(dst, src)
           modseq, modfmt = modrm(inst, dst, src, dst, src)
-          (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+          if op0 then
+            (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+          else
+            (rexseq + [0x0F, op1] + modseq).pack("#{rexfmt}C2#{modfmt}")
+          end
 
         when OpIndirect
           rexseq, rexfmt = rex(dst, src)
           modseq, modfmt = modrm(inst, dst, src, dst, src)
-          (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+          if op0 then
+            (rexseq + [op0, 0x0F, op1] + modseq).pack("#{rexfmt}C3#{modfmt}")
+          else
+            (rexseq + [0x0F, op1] + modseq).pack("#{rexfmt}C2#{modfmt}")
+          end
 
         else
           return nosupported_addressing_mode(inst, dst, src)
@@ -1288,6 +1296,16 @@ module YTLJit
       return nosupported_addressing_mode(:neg, src, nil, nil)
     end
 
+    def fstpl(dst)
+      case dst
+      when OpIndirect
+        modseq, modfmt = modrm(:fstpl, 3, dst, dst, nil)
+        return ([0xDD] + modseq).pack("C#{modfmt}")
+      end
+
+      return nosupported_addressing_mode(:neg, src, nil, nil)
+    end
+
     def cdq
       [0x99].pack("C")
     end
@@ -1333,6 +1351,14 @@ module YTLJit
       common_arithxmm(dst, src, 0xF2, 0x5E, :divsd)
     end
 
+    def comiss(dst, src)
+      common_arithxmm(dst, src, nil, 0x2F, :comiss)
+    end
+
+    def comisd(dst, src)
+      common_arithxmm(dst, src, 0x66, 0x2F, :comisd)
+    end
+
     def int3
       [0xcc].pack("C")
     end

data/lib/ytljit/type.rb

@@ -19,24 +19,30 @@ module YTLJit
         @alignment = align
         @kind = kind
       end
+
+      attr :kind
     end
 
     class PointedData<TypeCommon
       def initialize(type, index, offset)
         @type = type
         @index = index
-        @offset = offset
+        @offset = offset + index * type.size
       end
 
       attr :index
       attr :offset
 
       def size
-        @reftype.size
+        @type.size
+      end
+
+      def [](*args)
+        @type[*args]
       end
 
       def alignment
-        @reftype.alignment
+        @type.alignment
       end
     end
     
@@ -54,7 +60,7 @@ module YTLJit
       end
       
       def [](n = 0, offset = 0)
-        PointedData.new(@reftype, n, offset)
+        PointedData.new(@type, n, offset)
       end
     end
 
@@ -73,7 +79,7 @@ module YTLJit
       end
       
       def [](n = 0, offset = 0)
-        PointedData.new(@reftype, n, offset)
+        PointedData.new(@type, n, offset)
       end
     end
     

data/lib/ytljit/vm.rb

@@ -91,9 +91,61 @@ LocalVarNode
   module VM
     # Expression of VM is a set of Nodes
     module Node
+      module TypeListWithSignature
+        def type_list_initvar
+          TypeUtil::TypeContainer.new
+        end
+        
+        def type_list(sig)
+          @type_list.type_list(sig).value
+        end
+
+        def set_type_list(sig, val, pos = 1)
+          @type_list.type_list(sig).value[pos] = val
+        end
+
+        def add_type(sig, type, pos = 0)
+          @type_list.add_type(sig, type, pos)
+          if type.have_element? then
+            if @my_element_node == nil then
+              @my_element_node = BaseNode.new(self)
+            end
+            @element_node_list = [[sig, @my_element_node]]
+          end
+        end
+      end
+
+      module TypeListWithoutSignature
+        def type_list_initvar
+          [[], []]
+        end
+        
+        def type_list(sig)
+          @type_list
+        end
+
+        def set_type_list(sig, val, pos = 1)
+          @type_list[pos] = val
+        end
+
+        def add_type(sig, type, pos = 0)
+          tvsv = @type_list[pos]
+          if !tvsv.include? type then
+            tvsv.push type
+          end
+          if type.have_element? then
+            if @my_element_node == nil then
+              @my_element_node = BaseNode.new(self)
+            end
+            @element_node_list = [[sig, @my_element_node]]
+          end
+        end
+      end
+      
       class BaseNode
         include Inspect
         include AbsArch
+        include TypeListWithSignature
 
         def initialize(parent)
           cs = CodeSpace.new
@@ -116,12 +168,14 @@ LocalVarNode
 
           # iv for type inference
           @type = nil
-          @type_list = TypeUtil::TypeContainer.new
+          @type_list = type_list_initvar
           @element_node_list = []
+          @my_element_node = nil
           @type_inference_proc = cs
           @type_cache = nil
 
           @ti_observer = {}
+          @ti_observee = []
         end
 
         attr_accessor :parent
@@ -131,17 +185,8 @@ LocalVarNode
         attr_accessor :type
         attr_accessor :element_node_list
 
-        def add_type(sig, type)
-          @type_list.add_type(sig, type)
-        end
-
-        def type_list(sig)
-          @type_list.type_list(sig).value
-        end
-
-        def set_type_list(sig, val)
-          @type_list.type_list(sig).value = val
-        end
+        attr          :ti_observer
+        attr          :ti_observee
 
         def collect_info(context)
           if is_a?(HaveChildlenMixin) then
@@ -156,6 +201,7 @@ LocalVarNode
         def ti_add_observer(dst, dsig, ssig, context)
           if @ti_observer[dst] == nil then
             @ti_observer[dst] = []
+            dst.ti_observee.push self
           end
           
           if @ti_observer[dst].all? {|edsig, essig, eprc| 
@@ -174,10 +220,45 @@ LocalVarNode
           end
         end
 
+        def ti_reset(visitnode = {})
+          if visitnode[self] then
+            return
+          end
+
+          visitnode[self] = true
+          @ti_observer.each do |rec, lst|
+            lst.each do |dsig, ssig, prc|
+              rec.type_list(dsig)[1] = []
+
+              rec.ti_reset(visitnode)
+            end
+          end
+        end
+
+        def ti_del_link(visitnode = {})
+          if visitnode[self] then
+            return
+          end
+
+          visitnode[self] = true
+          @ti_observer.each do |rec, lst|
+            delent = []
+            lst.each do |ent|
+              delent.push ent
+                
+              rec.ti_del_link(visitnode)
+            end
+
+            delent.each do |ent|
+              lst.delete(ent)
+            end
+          end
+        end
+
         def merge_type(dst, src)
           res = dst
           src.each do |sele|
-            if ! dst.include? sele then
+            if !res.include? sele then
               res.push sele
             end
           end
@@ -186,18 +267,22 @@ LocalVarNode
         end
 
         def ti_update(dst, src, dsig, ssig, context)
-          dtlist = dst.type_list(dsig)
-          stlist = src.type_list(ssig)
+          dtlistorg = dst.type_list(dsig)
+          dtlist = dtlistorg.flatten
+          stlist = src.type_list(ssig).flatten
 =begin
-          print dsig.map(&:ruby_type), "\n"
+          print "UPDATE TYPE\n"
+          print "#{src.class} #{ssig.inspect} -> #{dst.class} #{dsig.inspect}\n"
           print dtlist.map(&:ruby_type), "\n"
           print stlist.map(&:ruby_type), "\n"
 =end
           orgsize = dtlist.size
-#          p "#{dst.class} #{src.class} #{dtlist} #{stlist}"
-          dst.set_type_list(dsig, merge_type(dtlist, stlist))
+#          pp "#{dst.class} #{src.class} #{dtlist} #{stlist}"
+          newdt = merge_type(dtlistorg[1], stlist)
+          dst.set_type_list(dsig, newdt)
+          dtsize = dtlistorg[0].size + newdt.size
 
-          if orgsize != dtlist.size then
+          if orgsize != dtsize then
             dst.type = nil
             dst.ti_changed
             context.convergent = false
@@ -222,6 +307,9 @@ LocalVarNode
           if dst.is_a?(LiteralNode) then
             print "#{dst.value.inspect} \n"
           end
+          if dst.is_a?(SendNode) then
+            print "#{dst.func.name} \n"
+          end
 =end
 
           if dst.is_a?(BaseNode) then
@@ -264,17 +352,25 @@ LocalVarNode
               tlist[0].element_type = node.type
             end
             tlist[0]
-            
+
+          when 2
+            if tlist[0].ruby_type == tlist[1].ruby_type and
+                tlist[0].boxed then
+              tlist[0]
+            else
+              tlist[1]
+            end
           else
             RubyType::DefaultType0.new
-
           end
         end
 
         def decide_type_once(sig)
-          if @type.equal?(nil) # or @type.is_a?(RubyType::DefaultType0) then
-            tlist = @type_list.type_list(sig).value
+          if @type.equal?(nil) or @type.is_a?(RubyType::DefaultType0) then
+            tlist = type_list(sig).flatten.uniq
             @type = decide_type_core(tlist)
+          else
+            @type
           end
         end
 
@@ -300,6 +396,10 @@ LocalVarNode
           @code_space = context.code_space
           context
         end
+
+        def get_constant_value
+          nil
+        end
       end
       
       module HaveChildlenMixin
@@ -371,13 +471,35 @@ LocalVarNode
           
           context.ret_node.decide_type_once(context.to_signature)
           rtype = context.ret_node.type
-          rtype.gen_unboxing(context)
+          if !rtype.boxed then
+            context = rtype.gen_unboxing(context)
+          end
+          context
         end
 
-        def signature(context)
+        def signature(context, args = @arguments)
           res = []
-          @arguments.each do |ele|
-            ele.decide_type_once(context.to_signature)
+          cursig = context.to_signature
+          args[0].decide_type_once(cursig)
+          res.push args[0].type
+
+          mt, slf = get_send_method_node(cursig)
+          if mt and (ynode = mt.yield_node[0]) then
+            context.push_signature(args, mt)
+            args[1].type = nil
+            args[1].decide_type_once(ynode.signature(context))
+            res.push args[1].type
+            context.pop_signature
+          else
+            args[1].decide_type_once(cursig)
+            res.push args[1].type
+            args[2].decide_type_once(cursig)
+            slf = args[2].type
+          end
+          res.push slf
+
+          args[3..-1].each do |ele|
+            ele.decide_type_once(cursig)
             res.push ele.type
           end
 
@@ -395,18 +517,21 @@ LocalVarNode
             
             context.cpustack_pushn(3 * AsmType::MACHINE_WORD.size)
             casm = context.assembler
+            casm.with_retry do 
+              casm.mov(FUNC_ARG[0], rarg.size) # argc
+              casm.mov(FUNC_ARG[1], TMPR2)     # argv
+            end
+            context.set_reg_content(FUNC_ARG[0], nil)
+            context.set_reg_content(FUNC_ARG[1], TMPR2)
+
             # Method Select
             # it is legal. use TMPR2 for method select
             # use TMPR3 for store self
             context = @func.compile(context)
             fnc = context.ret_reg
             casm.with_retry do 
-              casm.mov(FUNC_ARG[0], rarg.size) # argc
-              casm.mov(FUNC_ARG[1], TMPR2)     # argv
-              casm.mov(FUNC_ARG[2], TMPR3)     # self
+              casm.mov(FUNC_ARG[2], context.ret_reg2)     # self
             end
-            context.set_reg_content(FUNC_ARG[0], nil)
-            context.set_reg_content(FUNC_ARG[1], TMPR2)
             context.set_reg_content(FUNC_ARG[2], context.ret_node)
             
             context = gen_call(context, fnc, 3)
@@ -420,7 +545,9 @@ LocalVarNode
             context.ret_node = self
             
             decide_type_once(context.to_signature)
-            context = @type.to_box.gen_unboxing(context)
+            if !@type.boxed then 
+              context = @type.to_box.gen_unboxing(context)
+            end
             
             context
           end
@@ -453,7 +580,7 @@ LocalVarNode
               fnc = context.ret_reg
               casm = context.assembler
               casm.with_retry do 
-                casm.mov(FUNC_ARG[0], TMPR3)
+                casm.mov(FUNC_ARG[0], context.ret_reg2)
               end
               context.set_reg_content(FUNC_ARG[0], context.ret_node)
             else
@@ -479,9 +606,14 @@ LocalVarNode
             context.end_using_reg(FUNC_ARG[numarg - i - 1])
           end
           context.end_using_reg(fnc)
+          context.ret_reg = RETR
           
           decide_type_once(context.to_signature)
-          @type.to_box.gen_unboxing(context)
+          if !@type.boxed then 
+            context = @type.to_box.gen_unboxing(context)
+          end
+          
+          context
         end
 
         def compile_ytl(context)
@@ -495,10 +627,19 @@ LocalVarNode
           
           # push prev env
           casm = context.assembler
-          casm.with_retry do 
-            casm.mov(FUNC_ARG_YTL[0], BPR)
+          if @func.is_a?(YieldNode) then
+            prevenv = @frame_info.offset_arg(0, BPR)
+            casm.with_retry do 
+              casm.mov(TMPR, prevenv)
+              casm.mov(FUNC_ARG_YTL[0], TMPR)
+            end
+            context.set_reg_content(FUNC_ARG_YTL[0], prevenv)
+          else
+            casm.with_retry do 
+              casm.mov(FUNC_ARG_YTL[0], BPR)
+            end
+            context.set_reg_content(FUNC_ARG_YTL[0], BPR)
           end
-          context.set_reg_content(FUNC_ARG_YTL[0], BPR)
           
           # block
           # eval block
@@ -509,12 +650,7 @@ LocalVarNode
           @arguments[1].compile(tcontext)
           
           casm = context.assembler
-          casm.with_retry do 
-            entry = @arguments[1].code_space.var_base_immidiate_address
-            casm.mov(FUNC_ARG_YTL[1], entry)
-          end
-          context.set_reg_content(FUNC_ARG_YTL[1], nil)
-          
+
           # other arguments
           @arguments[3..-1].each_with_index do |arg, i|
             context = arg.compile(context)
@@ -525,6 +661,12 @@ LocalVarNode
             context.set_reg_content(FUNC_ARG_YTL[i + 3], context.ret_node)
           end
           
+          casm.with_retry do 
+            entry = @arguments[1].code_space.var_base_immidiate_address
+            casm.mov(FUNC_ARG_YTL[1], entry)
+          end
+          context.set_reg_content(FUNC_ARG_YTL[1], nil)
+
           # self
           # Method Select
           # it is legal. use TMPR2 for method select
@@ -533,10 +675,10 @@ LocalVarNode
           fnc = context.ret_reg
           casm = context.assembler
           casm.with_retry do 
-            casm.mov(FUNC_ARG_YTL[2], TMPR3)
+            casm.mov(FUNC_ARG_YTL[2], context.ret_reg2)
           end
           context.set_reg_content(FUNC_ARG_YTL[2], @arguments[2])
-          
+
           context = gen_call(context, fnc, numarg)
           
           context.cpustack_popn(numarg * 8)
@@ -571,19 +713,24 @@ LocalVarNode
           super(parent)
           @name = name
           @code_spaces = [] # [[nil, CodeSpace.new]]
-          @yield_node = nil
+          @orig_modified_local_var = []
+          @yield_node = []
           if @parent then
             @classtop = search_class_top
           else
             @classtop = self
           end
           @end_nodes = []
+          @signature_cache = []
         end
 
         attr_accessor :name
         attr          :end_nodes
+        attr          :orig_modified_local_var
         attr          :yield_node
 
+        attr          :signature_cache
+
         def modified_instance_var
           search_end.modified_instance_var
         end
@@ -616,9 +763,10 @@ LocalVarNode
 
         def construct_frame_info(locals, argnum)
           finfo = LocalFrameInfoNode.new(self)
+          finfo.system_num = 4         # BP ON Stack, BP, RET
           
           # 3 means BP, BP and SP
-          lsize = locals.size + 3
+          lsize = locals.size + finfo.system_num
           
           # construct frame
           frame_layout = Array.new(lsize)
@@ -630,18 +778,22 @@ LocalVarNode
             i += 1
           end
           
-          frame_layout[fargstart - 1] = SystemValueNode.new(finfo, 
-                                                            :RET_ADDR, 
-                                                            fargstart - 1)
-          frame_layout[fargstart - 2] = SystemValueNode.new(finfo, 
-                                                            :OLD_BP,
-                                                            fargstart - 2)
-          frame_layout[fargstart - 3] = SystemValueNode.new(finfo, 
-                                                            :OLD_BPSTACK,
-                                                            fargstart - 3)
+          curpos = fargstart - 1
+          frame_layout[curpos] = SystemValueNode.new(finfo, 
+                                                     :RET_ADDR, curpos)
+          curpos -= 1
+          frame_layout[curpos] = SystemValueNode.new(finfo, 
+                                                     :OLD_BP, curpos)
+          curpos -= 1
+          frame_layout[curpos] = SystemValueNode.new(finfo, 
+                                                     :FRAME_INFO, curpos)
+          curpos -= 1
+          frame_layout[curpos] = SystemValueNode.new(finfo, 
+                                                     :OLD_BPSTACK, curpos)
 
           j = 0
-          while i < lsize - 3 do
+          lvarnum = lsize - finfo.system_num 
+          while i < lvarnum do
             lnode = LocalVarNode.new(finfo, locals[i], j)
             frame_layout[j] = lnode
             i += 1
@@ -649,7 +801,6 @@ LocalVarNode
           end
           finfo.frame_layout = frame_layout
           finfo.argument_num = argnum
-          finfo.system_num = 3         # BP ON Stack, BP, RET
           
           @body = finfo
           finfo
@@ -657,7 +808,7 @@ LocalVarNode
 
         def collect_info(context)
           context.yield_node.push []
-          @body.collect_info(context)
+          context = @body.collect_info(context)
           @yield_node = context.yield_node.pop
           context
         end
@@ -670,15 +821,18 @@ LocalVarNode
 
           context.visited_top_node[self] = true
 
-          context.current_method_signature_node.push signode
+          if !@signature_cache.include?(sig) then
+            @signature_cache.push sig
+          end
+          
+          context.push_signature(signode, self)
           context = @body.collect_candidate_type(context)
+          context.pop_signature
+
           @end_nodes.each do |enode|
-            same_type(self, enode, 
-                      context.to_signature, context.to_signature, context)
-            same_type(enode, self, 
-                      context.to_signature, context.to_signature, context)
+            same_type(self, enode, sig, sig, context)
+            same_type(enode, self, sig, sig, context)
           end
-          context.current_method_signature_node.pop
           context
         end
 
@@ -687,8 +841,11 @@ LocalVarNode
           print "#{@classtop.klass_object}##{@name} "
           @code_spaces.each do |sig, cs|
             print sig, " -> "
-            tl = @type_list.type_list(sig).value
+            tl = type_list(sig).flatten.uniq
             print decide_type_core(tl).inspect, "\n"
+            pp tl
+#            print "CodeSpace 0x#{cs.base_address.to_s(16)}\n"
+            print "CodeSpace #{cs.inspect}\n"
           end
         end
 
@@ -739,8 +896,11 @@ LocalVarNode
 
       class BlockTopNode<MethodTopNode
         def collect_info(context)
+          @orig_modified_local_var = context.modified_local_var.last.map {|e|
+            e.dup
+          }
           context.modified_local_var.last.push Hash.new
-          context = super
+          context = @body.collect_info(context)
           context.modified_local_var.last.pop
           context
         end
@@ -749,6 +909,7 @@ LocalVarNode
       end
 
       class ClassTopNode<TopNode
+        include SendNodeCodeGen
         include MethodTopCodeGen
         @@class_top_tab = {}
 
@@ -756,43 +917,68 @@ LocalVarNode
           @@class_top_tab[klass]
         end
 
-        def collect_info(context)
-          context.modified_local_var.push [{}]
-          context.modified_instance_var = {}
-          context = super
-          context.modified_local_var.pop
-          context
-        end
-
         def initialize(parent, klassobj, name = nil)
           super(parent, name)
           @constant_tab = {}
           @method_tab = {}
           @klass_object = klassobj
           @klassclass = class << @klass_object; self; end
+          @klassclass_node = nil # Lazy
           RubyType::define_wraped_class(@klassclass, RubyType::RubyTypeBoxed)
           unless @@class_top_tab[klassobj]
             @@class_top_tab[klassobj] = self
           end
         end
 
-        def method_tab(klassobj = nil)
-          if klassobj then
-            ktop =  @@class_top_tab[klassobj]
-            if ktop then
-              ktop.method_tab
-            else
-              {}
-            end
+        def collect_info(context)
+          context.modified_local_var.push [{}]
+          context.modified_instance_var = Hash.new {|hash, key| hash[key] = []}
+          context = super
+          context.modified_local_var.pop
+          if @klassclass_node then
+            @klassclass_node.collect_info(context)
+          end
+          context
+        end
+
+        def collect_candidate_type(context, signode, sig)
+          super
+          if @klassclass_node then
+            context = @klassclass_node.collect_candidate_type(context, 
+                                                              signode, sig)
+          end
+          context
+        end
+
+        def make_klassclass_node
+          clsclsnode = ClassTopNode.new(self, @klassclass, @klassclass.name)
+          clsclsnode.body = DummyNode.new
+          @klassclass_node = clsclsnode
+        end
+
+        def get_method_tab(klassobj = @klass_object)
+          ktop =  @@class_top_tab[klassobj]
+          if ktop then
+            ktop.method_tab
           else
-            @method_tab
+            {}
+          end
+        end
+
+        def get_constant_tab(klassobj = @klass_object)
+          ktop =  @@class_top_tab[klassobj]
+          if ktop then
+            ktop.constant_tab
+          else
+            ktop.constant_tab = {}
+            ktop.constant_tab
           end
         end
 
         def search_method_with_super(name, klassobj = @klass_object)
           clsnode = @@class_top_tab[klassobj]
           if clsnode then
-            mtab = clsnode.method_tab
+            mtab = clsnode.get_method_tab
             if val = mtab[name] then
               return [val, clsnode]
             end
@@ -803,8 +989,23 @@ LocalVarNode
           [nil, nil]
         end
 
-        attr :constant_tab
+        def search_constant_with_super(name, klassobj = @klass_object)
+          clsnode = @@class_top_tab[klassobj]
+          if clsnode then
+            ctab = clsnode.get_constant_tab
+            if val = ctab[name] then
+              return [val, clsnode]
+            end
+            
+            return search_constant_with_super(name, klassobj.superclass)
+          end
+
+          [nil, nil]
+        end
+
         attr :klass_object
+        attr :constant_tab
+        attr :method_tab
 
         def construct_frame_info(locals, argnum)
           locals.unshift :_self
@@ -816,7 +1017,7 @@ LocalVarNode
 
         def collect_candidate_type(context, signode, sig)
           @type = RubyType::BaseType.from_ruby_class(@klassclass)
-          @type_list.add_type(sig, @type)
+          add_type(sig, @type)
 
           if add_cs_for_signature(sig) == nil and  
               context.visited_top_node[self] then
@@ -825,11 +1026,35 @@ LocalVarNode
 
           context.visited_top_node[self] = true
           
-          context.current_method_signature_node.push signode
+          context.push_signature(signode, self)
           context = @body.collect_candidate_type(context)
-          context.current_method_signature_node.pop
+          context.pop_signature
+          context
+        end
+
+        def compile(context)
+          context = super(context)
+
+          cs = self.find_cs_by_signature(context.to_signature)
+          if cs then
+            asm = context.assembler
+            add = lambda { @klassclass.address }
+            var_klassclass = OpVarImmidiateAddress.new(add)
+            asm.with_retry do
+              asm.mov(FUNC_ARG_YTL[0], BPR)
+              asm.mov(FUNC_ARG_YTL[1], 4)
+              asm.mov(FUNC_ARG_YTL[2], var_klassclass)
+            end
+            add = cs.var_base_address
+            context = gen_call(context, add, 3)
+          end
+          
           context
         end
+
+        def get_constant_value
+          [@klass_object]
+        end
       end
 
       class TopTopNode<ClassTopNode
@@ -841,6 +1066,24 @@ LocalVarNode
           @code_space_tab = []
           @asm_tab = {}
           @id.push 0
+
+          @unwind_proc = CodeSpace.new
+          init_unwind_proc
+          add_code_space(nil, @unwind_proc)
+        end
+
+        def init_unwind_proc
+          asm = Assembler.new(@unwind_proc)
+          # Make linkage of frame pointer
+          finfo = OpIndirect.new(TMPR3, AsmType::MACHINE_WORD.size)
+          retadd = OpIndirect.new(TMPR3, AsmType::MACHINE_WORD.size)
+          asm.with_retry do
+            asm.mov(TMPR3, BPR)
+            asm.mov(TMPR3, INDIRECT_TMPR3)
+            asm.mov(TMPR, finfo)
+            asm.mov(TMPR3, INDIRECT_TMPR3)
+            asm.mov(TMPR2, retadd) # Return address store by call inst.
+          end
         end
         
         def add_code_space(oldcs, newcs)
@@ -950,7 +1193,6 @@ LocalVarNode
           traverse_childlen {|rec|
             context = rec.collect_candidate_type(context)
           }
-          @body.collect_candidate_type(context)
         end
 
         def compile(context)
@@ -981,19 +1223,36 @@ LocalVarNode
           8
         end
 
+        def collect_info(context)
+          flay = @parent.frame_layout
+          fragstart = flay.size - @parent.argument_num
+          if fragstart <= @offset then
+            argoff = @offset - fragstart
+          else
+            argoff = @offset + @parent.argument_num
+          end
+=begin
+          # Assertion check for reverse of real_offset
+          unless @offset == @parent.real_offset(argoff)
+            raise
+          end
+=end
+          topnode = @parent.parent
+          context.modified_local_var.last.last[argoff] = [[topnode, self]]
+          context
+        end
+
         def collect_candidate_type(context)
           flay = @parent.frame_layout
           fragstart = flay.size - @parent.argument_num
           if fragstart <= @offset then
             argoff = @offset - fragstart
             tobj = context.current_method_signature_node.last[argoff]
+            cursig = context.to_signature
+            cursig2 = context.to_signature(-2)
             if tobj then
-              same_type(self, tobj, 
-                        context.to_signature, context.to_signature(-2), 
-                        context)
-              same_type(tobj, self, 
-                        context.to_signature(-2), context.to_signature, 
-                        context)
+              same_type(self, tobj, cursig, cursig2, context)
+              same_type(tobj, self, cursig2, cursig, context)
             end
           end
           context
@@ -1050,10 +1309,9 @@ LocalVarNode
         end
 
         def collect_candidate_type(context)
-          same_type(self, @parent, 
-                    context.to_signature, context.to_signature, context)
-          same_type(@parent, self, 
-                    context.to_signature, context.to_signature, context)
+          cursig = context.to_signature
+          same_type(self, @parent, cursig, cursig, context)
+          same_type(@parent, self, cursig, cursig, context)
           context
         end
 
@@ -1085,6 +1343,8 @@ LocalVarNode
           @value_node = valnode
         end
 
+        attr :value_node
+
         def traverse_childlen
           yield @value_node
           yield @body
@@ -1092,10 +1352,9 @@ LocalVarNode
 
         def collect_candidate_type(context)
           context = @value_node.collect_candidate_type(context)
-          same_type(self, @value_node, 
-                    context.to_signature, context.to_signature, context)
-          same_type(@value_node, self, 
-                    context.to_signature, context.to_signature, context)
+          cursig = context.to_signature
+          same_type(self, @value_node, cursig, cursig, context)
+          same_type(@value_node, self, cursig, cursig, context)
           context = @body.collect_candidate_type(context)
           context
         end
@@ -1105,26 +1364,32 @@ LocalVarNode
           context = @value_node.compile(context)
           if context.ret_reg != RETR then
             if context.ret_reg.is_a?(OpRegXMM) then
-              decide_type_once(context.to_signature)
-              context = @type.gen_boxing(context)
-              if context.ret_reg != RETR then
-                curas = context.assembler
-                curas.with_retry do
-                  curas.mov(RETR, context.ret_reg)
-                end
-                
-                context.set_reg_content(RETR, context.ret_node)
-              end
+=begin
+                 decide_type_once(context.to_signature)
+                 context = @type.gen_boxing(context)
+                 if context.ret_reg != RETR then
+                   curas = context.assembler
+                   curas.with_retry do
+                    curas.mov(RETR, context.ret_reg)
+                  end
+                   
+                   context.set_reg_content(RETR, context.ret_node)
+                 end
+=end
+              context.set_reg_content(context.ret_reg, context.ret_node)
             else
               curas = context.assembler
               curas.with_retry do
                 curas.mov(RETR, context.ret_reg)
               end
+              context.set_reg_content(RETR, context.ret_node)
+              context.ret_reg = RETR
             end
-            context.set_reg_content(TMPR, context.ret_node)
+          else
+            context.set_reg_content(RETR, context.ret_node)
+            context.ret_reg = RETR
           end
 
-          context.ret_reg = RETR
           context = @body.compile(context)
 
           context
@@ -1140,10 +1405,9 @@ LocalVarNode
         def collect_candidate_type(context)
           @local_label.come_from.values.each do |vnode|
             if vnode then
-              same_type(self, vnode, 
-                        context.to_signature, context.to_signature, context)
-              same_type(vnode, self, 
-                        context.to_signature, context.to_signature, context)
+              cursig = context.to_signature
+              same_type(self, vnode, cursig, cursig, context)
+              same_type(vnode, self, cursig, cursig, context)
             end
           end
           context
@@ -1168,26 +1432,54 @@ LocalVarNode
           @code_space = CodeSpace.new
           @value_node = PhiNode.new(self)
           @modified_local_var_list = []
-          @modified_instance_var_list = []
         end
 
-        attr :name
-        attr :come_from
-        attr :value_node
+        attr          :name
+        attr          :come_from
+        attr          :value_node
 
         def traverse_childlen
-          yield @body
           yield @value_node
+          yield @body
+        end
+
+        def lonly_node(node)
+          while !node.is_a?(TopNode) 
+            if node.is_a?(LocalLabel) then
+              if node.come_from.size == 0 then
+                return true
+              else
+                return false
+              end
+            end
+
+            node = node.parent
+          end
+
+          return false
         end
 
         def collect_info(context)
+          if @modified_local_var_list.size == 0 then
+            # first visit
+            delnode = []
+            fornode = []
+            @come_from.keys.each do |ele|
+              if lonly_node(ele) then
+                delnode.push ele
+              end
+            end
+            delnode.each do |ele|
+              @come_from.delete(ele)
+            end
+          end
+            
           modlocvar = context.modified_local_var.last.map {|ele| ele.dup}
           @modified_local_var_list.push modlocvar
-          modinsvar = context.modified_instance_var.dup
-          @modified_instance_var_list.push modinsvar
-          if @modified_instance_var_list.size == @come_from.size then
+          if @modified_local_var_list.size == 1 then
+            @body.collect_info(context)
+          elsif @modified_local_var_list.size == @come_from.size then
             context.merge_local_var(@modified_local_var_list)
-            context.merge_instance_var(@modified_instance_var_list)
             @body.collect_info(context)
           else
             context
@@ -1233,9 +1525,8 @@ LocalVarNode
         def compile(context)
           context = super(context)
           @come_from_val.push context.ret_reg
-
-          # When all node finish to compile, next node compile
-          if @come_from_val.size == @come_from.size then
+          
+          if @come_from_val.size == 1 then
             @body.compile(context)
           else
             context
@@ -1363,21 +1654,26 @@ LocalVarNode
 
       # Literal
       class LiteralNode<BaseNode
+        include TypeListWithoutSignature
+
         def initialize(parent, val)
           super(parent)
           @value = val
           @type = RubyType::BaseType.from_object(val)
-          @my_element_node = BaseNode.new(self)
         end
         
         attr :value
 
         def collect_candidate_type(context)
-          @type_list.add_type(context.to_signature, @type)
+          # ??? 
+          if @type == nil then 
+            @type = RubyType::BaseType.from_object(@value) 
+          end
+
+          sig = context.to_signature
+          add_type(sig, @type)
           case @value
           when Array
-            sig = context.to_signature
-            @element_node_list = [[sig, @my_element_node]]
             @value.each do |ele|
               etype = RubyType::BaseType.from_object(ele)
               @element_node_list[0][1].add_type(sig, etype)
@@ -1428,6 +1724,10 @@ LocalVarNode
 
           context
         end
+
+        def get_constant_value
+          [@value]
+        end
       end
 
       class ClassValueNode<BaseNode
@@ -1446,7 +1746,15 @@ LocalVarNode
         attr_accessor :define
 
         def collect_candidate_type(context)
-          context = @define.collect_candidate_type(context,[], [])
+          dmylit = LiteralNode.new(self, nil)
+          arg = [dmylit, dmylit, @define]
+          sig = []
+          arg.each do |ele|
+            ele.decide_type_once(context.to_signature)
+            sig.push ele.type
+          end
+          context = @define.collect_candidate_type(context, arg, sig)
+
           context = @body.collect_candidate_type(context)
           context
         end
@@ -1514,10 +1822,18 @@ LocalVarNode
         def compile(context)
           context = super(context)
           asm = context.assembler
-          slfarg = @frame_info.offset_arg(2, BPR)
+          # You can crash when you use yield in block.
+          # You can fix this bug for traversing TMPR3 for method top.
+          # But is is little troublesome. So it  is not supported.
+          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, TMPR3)
           asm.with_retry do
+            asm.mov(TMPR3, prevenv)
             asm.mov(TMPR3, slfarg)
           end
+          context.ret_reg2 = TMPR3
           
           context.ret_reg = @frame_info.offset_arg(1, BPR)
           context.ret_node = self
@@ -1533,11 +1849,12 @@ LocalVarNode
           @calling_convention = :unkown
           @reciever = nil
           @send_node = nil
+          @ruby_reciever = nil
         end
 
         def set_reciever(sendnode)
           @send_node = sendnode
-          if sendnode.is_fcall then
+          if sendnode.is_fcall or sendnode.is_vcall then
             @reciever = @parent.class_top
           else
             @reciever = sendnode.arguments[2]
@@ -1592,7 +1909,20 @@ LocalVarNode
             if knode and knode.search_method_with_super(@name)[0] then
               @calling_convention = :ytl
             else
-              mth = rklass.instance_method(@name)
+              slfval = @reciever.get_constant_value
+              mth = nil
+              if slfval then
+                begin
+                  mth = slfval[0].instance_method(@name)
+                  @ruby_reciever = slfval[0]
+                rescue NameError
+                end
+              end
+              if slfval == nil or mth == nil then
+                mth = rklass.instance_method(@name)
+                @ruby_reciever = rklass
+              end
+
               if variable_argument?(mth.parameters) then
                 @calling_convention = :c_vararg
               else
@@ -1607,10 +1937,12 @@ LocalVarNode
         def compile(context)
           context = super(context)
           if @send_node.is_fcall or @send_node.is_vcall then
+            slfop = @parent.frame_info.offset_arg(2, BPR)
             asm = context.assembler
             asm.with_retry do
-              asm.mov(TMPR3, 4)
+              asm.mov(TMPR3, slfop)
             end
+            context.ret_reg2 = TMPR3
             mtop = @reciever.search_method_with_super(@name)[0]
             if mtop then
               sig = @parent.signature(context)
@@ -1638,7 +1970,9 @@ LocalVarNode
             context = @reciever.compile(context)
             context.ret_node.decide_type_once(context.to_signature)
             rtype = context.ret_node.type
-            context = rtype.gen_boxing(context)
+            if @calling_convention != :ytl then
+              context = rtype.gen_boxing(context)
+            end
             recval = context.ret_reg
             knode = ClassTopNode.get_class_top_node(rtype.ruby_type)
             mtop = nil
@@ -1665,6 +1999,7 @@ LocalVarNode
                 asm.mov(TMPR2, RETR)
                 asm.pop(TMPR3)
               end
+              context.ret_reg2 = TMPR3
               
               context.end_using_reg(FUNC_ARG[1])
               context.end_using_reg(FUNC_ARG[0])
@@ -1677,8 +2012,18 @@ LocalVarNode
 
             elsif knode and mtop = knode.search_method_with_super(@name)[0] then
               asm = context.assembler
-              asm.with_retry do
-                asm.mov(TMPR3, recval)
+              if !rtype.boxed and rtype.ruby_type == Float then
+                if recval != XMM0 then
+                  asm.with_retry do
+                    asm.mov(XMM0, recval)
+                  end
+                end
+                context.ret_reg2 = XMM0
+              else
+                asm.with_retry do
+                  asm.mov(TMPR3, recval)
+                end
+                context.ret_reg2 = TMPR3
               end
 
               sig = @parent.signature(context)
@@ -1689,12 +2034,27 @@ LocalVarNode
               # regident type 
 
               asm = context.assembler
-              asm.with_retry do
-                asm.mov(TMPR3, recval)
+              if !rtype.boxed and rtype.ruby_type == Float then
+                if recval != XMM0 then
+                  asm.with_retry do
+                    asm.mov(XMM0, recval)
+                  end
+                end
+                context.ret_reg2 = XMM0
+              else
+                asm.with_retry do
+                  asm.mov(TMPR3, recval)
+                end
+                context.ret_reg2 = TMPR3
               end
 
               addr = lambda {
-                rtype.ruby_type.method_address_of(@name)
+                if @ruby_reciever.class == Module then
+                  name = @name
+                  @ruby_reciever.send(:method_address_of, name)
+                else
+                  @ruby_reciever.method_address_of(@name)
+                end
               }
               if addr.call then
                 context.ret_reg = OpVarMemAddress.new(addr)
@@ -1745,13 +2105,14 @@ LocalVarNode
 
         def collect_info(context)
           vti = nil
-          if context.modified_local_var.last[@depth] then
-            vti = context.modified_local_var.last[@depth][@offset]
+          if context.modified_local_var.last[-@depth - 1] then
+            vti = context.modified_local_var.last[-@depth - 1][@offset]
           end
 
           if vti then
-            @var_type_info = vti.dup
+            @var_type_info = vti.map {|e| e.dup }
           else
+            raise "maybe bug"
             roff = @current_frame_info.real_offset(@offset)
             @var_type_info = [@current_frame_info.frame_layout[roff]]
           end
@@ -1760,9 +2121,11 @@ LocalVarNode
         end
 
         def collect_candidate_type(context)
-          @var_type_info.each do |src|
-            same_type(self, src, 
-                      context.to_signature, context.to_signature, context)
+          @var_type_info.each do |topnode, node|
+            cursig = context.to_signature
+            varsig = context.to_signature(topnode)
+            same_type(self, node, cursig, varsig, context)
+            same_type(node, self, varsig, cursig, context)
           end
           context
         end
@@ -1772,15 +2135,34 @@ LocalVarNode
           context = gen_pursue_parent_function(context, @depth)
           base = context.ret_reg
           offarg = @current_frame_info.offset_arg(@offset, base)
+
+          asm = context.assembler
+          @type = nil
+          rtype = decide_type_once(context.to_signature)
+          if !rtype.boxed and rtype.ruby_type == Float then
+            asm.with_retry do
+              asm.mov(XMM0, offarg)
+            end
+            context.ret_reg = XMM0
+          else
+            asm.with_retry do
+              asm.mov(TMPR, offarg)
+            end
+            context.ret_reg = TMPR
+          end
+
+          if base == TMPR2 then
+            context.end_using_reg(TMPR2)
+          end
+
           context.ret_node = self
-          context.ret_reg = offarg
           context
         end
       end
 
       class SelfRefNode<LocalVarRefNode
         def initialize(parent)
-          super(parent, 0, 2)
+          super(parent, 2, 0)
           @classtop = search_class_top
         end
 
@@ -1793,12 +2175,12 @@ LocalVarNode
 
         def collect_candidate_type(context)
           @type = RubyType::BaseType.from_ruby_class(@classtop.klass_object)
-          @type_list.add_type(context.to_signature, @type)
+          add_type(context.to_signature, @type)
           context
         end
 
         def compile(context)
-          context = super(context)
+#          context = super(context)
           compile_main(context)
         end
       end
@@ -1818,14 +2200,31 @@ LocalVarNode
 
         def collect_info(context)
           context = @val.collect_info(context)
-          context.modified_local_var.last[@depth][@offset] = [self]
+          top = @frame_info.parent
+
+          nodepare = nil
+          if @depth > 0 then 
+            nodepare = top.orig_modified_local_var[-@depth]
+          end
+          if nodepare then
+            nodepare = nodepare[@offset]
+          end
+          if nodepare then
+            nodepare.push [top, self]
+          else
+            nodepare = [[top, self]]
+          end
+            
+          context.modified_local_var.last[-@depth - 1][@offset] = nodepare
+
           @body.collect_info(context)
         end
           
         def collect_candidate_type(context)
           context = @val.collect_candidate_type(context)
-          same_type(self, @val, 
-                    context.to_signature, context.to_signature, context)
+          cursig = context.to_signature
+          same_type(self, @val, cursig, cursig, context)
+#          same_type(@val, self, cursig, cursig, context)
           @body.collect_candidate_type(context)
         end
 
@@ -1887,20 +2286,18 @@ LocalVarNode
 
         def collect_info(context)
           vti = context.modified_instance_var[@name]
-          if vti then
-            @var_type_info = vti.dup
-          else
-            @var_type_info = nil
-          end
+          # Not dup so vti may update after.
+          @var_type_info = vti 
 
           context
         end
 
         def collect_candidate_type(context)
           @var_type_info.each do |src|
-            same_type(self, src, 
-                      context.to_signature, context.to_signature, context)
+            cursig = context.to_signature
+            same_type(self, src, cursig, cursig, context)
           end
+
           context
         end
 
@@ -1935,8 +2332,9 @@ LocalVarNode
 
         def collect_candidate_type(context)
           context = @val.collect_candidate_type(context)
-          same_type(self, @val, 
-                    context.to_signature, context.to_signature, context)
+          cursig = context.to_signature
+          same_type(self, @val, cursig, cursig, context)
+#          same_type(@val, self, cursig, cursig, context)
           @body.collect_candidate_type(context)
         end
 
@@ -1952,21 +2350,31 @@ LocalVarNode
 
       class ConstantRefNode<VariableRefCommonNode
         include NodeUtil
+        include TypeListWithoutSignature
         
         def initialize(parent, klass, name)
           super(parent)
           @name = name
           @class_top = klass # .search_class_top
-          @value_node = klass.constant_tab[@name]
+          @value_node, dummy = klass.search_constant_with_super(@name)
         end
 
         attr :value_node
 
         def collect_candidate_type(context)
-          same_type(self, @value_node,
-                    context.to_signature, context.to_signature, context)
+          if @value_node.is_a?(ClassTopNode) then
+            add_type(context.to_signature, @value_node.type)
+          else
+            context = @value_node.collect_candidate_type(context)
+            cursig = context.to_signature
+            same_type(self, @value_node, cursig, cursig, context)
+          end
           context
         end
+        
+        def type
+          @value_node.type
+        end
 
         def compile(context)
           case @value_node
@@ -1982,6 +2390,45 @@ LocalVarNode
           context.ret_node = self
           context 
         end
+
+        def get_constant_value
+          @value_node.get_constant_value
+        end
+      end
+
+      class ConstantAssignNode<VariableRefCommonNode
+        include NodeUtil
+        include HaveChildlenMixin
+        
+        def initialize(parent, klass, name, value)
+          super(parent)
+          @name = name
+          @class_top = klass # .search_class_top
+          @value = value
+
+          if klass.is_a?(ClassTopNode) then
+            klass.constant_tab[@name] = @value
+          else
+            pp klass.class
+            raise "Not Implemented yet for set constant for dynamic class"
+          end
+        end
+
+        def traverse_childlen
+          yield @body
+        end
+
+        def collect_candidate_type(context)
+          @body.collect_candidate_type(context)
+        end
+        
+        def type
+          @value.type
+        end
+
+        def compile(context)
+          @body.compile(context)
+        end
       end
 
       # Reference Register