ytljit 0.0.5 → 0.0.6

data/lib/ytljit/vm.rb

@@ -110,7 +110,7 @@ LocalVarNode
             if @my_element_node == nil then
               @my_element_node = BaseNode.new(self)
             end
-            @element_node_list = [[sig, @my_element_node]]
+            @element_node_list = [[sig, @my_element_node, nil]]
           end
         end
       end
@@ -137,7 +137,7 @@ LocalVarNode
             if @my_element_node == nil then
               @my_element_node = BaseNode.new(self)
             end
-            @element_node_list = [[sig, @my_element_node]]
+            @element_node_list = [[sig, @my_element_node, nil]]
           end
         end
       end
@@ -173,9 +173,12 @@ LocalVarNode
           @my_element_node = nil
           @type_inference_proc = cs
           @type_cache = nil
+          @is_escape = false
 
           @ti_observer = {}
           @ti_observee = []
+
+          @debug_info = nil
         end
 
         attr_accessor :parent
@@ -184,10 +187,13 @@ LocalVarNode
 
         attr_accessor :type
         attr_accessor :element_node_list
+        attr_accessor :is_escape
 
         attr          :ti_observer
         attr          :ti_observee
 
+        attr_accessor :debug_info
+
         def collect_info(context)
           if is_a?(HaveChildlenMixin) then
             traverse_childlen {|rec|
@@ -296,6 +302,8 @@ LocalVarNode
             dst.ti_changed
             context.convergent = false
           end
+
+          dst.is_escape ||= src.is_escape
         end
 
         def same_type(dst, src, dsig, ssig, context)
@@ -319,15 +327,27 @@ LocalVarNode
           ti_update(dst, src, dsig, ssig, context)
         end
 
-        def add_element_node(sig, enode, context)
+        def add_element_node(sig, enode, index, context)
           slfetnode = @element_node_list
           unless slfetnode.include?(enode)
-            @element_node_list.push [sig, enode]
+            if @element_node_list == nil and index != nil then
+              @element_node_list.push [sig, enode, nil]
+            end
+            @element_node_list.push [sig, enode, index]
             orgsig = @element_node_list[0][0]
             orgnode = @element_node_list[0][1]
             if orgnode != enode then
               same_type(orgnode, enode, orgsig, sig, context)
             end
+            if index != nil then
+              @element_node_list.each do |orgsig, orgnode, orgindex|
+                if orgindex == index and
+                    orgnode != enode then
+                  same_type(orgnode, enode, orgsig, sig, context)
+                end
+              end
+            end
+                  
             ti_changed
 #            context.convergent = false
           end
@@ -338,17 +358,18 @@ LocalVarNode
           context
         end
 
-        def decide_type_core(tlist)
+        def decide_type_core(tlist, local_cache = {})
           tlist = tlist.select {|e| e.class != RubyType::DefaultType0 }
           case tlist.size
           when 0
             RubyType::DefaultType0.new
             
           when 1
+            local_cache[self] = tlist[0]
             if tlist[0].have_element? then
               sig = @element_node_list[0][0]
               node = @element_node_list[0][1]
-              node.decide_type_once(sig)
+              node.decide_type_once(sig, local_cache)
               tlist[0].element_type = node.type
             end
             tlist[0]
@@ -360,18 +381,25 @@ LocalVarNode
             else
               tlist[1]
             end
+
           else
             RubyType::DefaultType0.new
           end
         end
 
-        def decide_type_once(sig)
+        def decide_type_once(sig, local_cache = {})
+          if local_cache[self] then
+            return local_cache[self] 
+          end
+
           if @type.equal?(nil) or @type.is_a?(RubyType::DefaultType0) then
             tlist = type_list(sig).flatten.uniq
-            @type = decide_type_core(tlist)
+            @type = decide_type_core(tlist, local_cache)
           else
             @type
           end
+
+          @type
         end
 
         def decide_type(sig)
@@ -511,9 +539,7 @@ LocalVarNode
           context.start_using_reg(TMPR2)
           
           context = gen_make_argv(context) do |context, rarg|
-            context.start_using_reg(FUNC_ARG[0])
-            context.start_using_reg(FUNC_ARG[1])
-            context.start_using_reg(FUNC_ARG[2])
+            context.start_arg_reg
             
             context.cpustack_pushn(3 * AsmType::MACHINE_WORD.size)
             casm = context.assembler
@@ -521,27 +547,25 @@ LocalVarNode
               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)
+            context.set_reg_content(FUNC_ARG[0].dst_opecode, nil)
+            context.set_reg_content(FUNC_ARG[1].dst_opecode, TMPR2)
 
             # Method Select
             # it is legal. use TMPR2 for method select
-            # use TMPR3 for store self
+            # use PTMPR for store self
             context = @func.compile(context)
             fnc = context.ret_reg
             casm.with_retry do 
               casm.mov(FUNC_ARG[2], context.ret_reg2)     # self
             end
-            context.set_reg_content(FUNC_ARG[2], context.ret_node)
+            context.set_reg_content(FUNC_ARG[2].dst_opecode, context.ret_node)
             
             context = gen_call(context, fnc, 3)
             context.cpustack_popn(3 * AsmType::MACHINE_WORD.size)
-            
-            context.end_using_reg(FUNC_ARG[2])
-            context.end_using_reg(FUNC_ARG[1])
-            context.end_using_reg(FUNC_ARG[0])
+            context.end_arg_reg
             context.end_using_reg(TMPR2)
             context.ret_reg = RETR
+            context.set_reg_content(context.ret_reg, self)
             context.ret_node = self
             
             decide_type_once(context.to_signature)
@@ -557,9 +581,7 @@ LocalVarNode
           fnc = nil
           numarg = @arguments.size - 2
           
-          numarg.times do |i|
-            context.start_using_reg(FUNC_ARG[i])
-          end
+          context.start_arg_reg
           context.cpustack_pushn(numarg * AsmType::MACHINE_WORD.size)
           
           argpos = 0
@@ -575,14 +597,15 @@ LocalVarNode
               # Self
               # Method Select
               # it is legal. use TMPR2 for method select
-              # use TMPR3 for store self
+              # use PTMPR for store self
               context = @func.compile(context)
               fnc = context.ret_reg
               casm = context.assembler
               casm.with_retry do 
                 casm.mov(FUNC_ARG[0], context.ret_reg2)
               end
-              context.set_reg_content(FUNC_ARG[0], context.ret_node)
+              context.set_reg_content(FUNC_ARG[0].dst_opecode, 
+                                      context.ret_node)
             else
               # other arg.
               context = arg.compile(context)
@@ -593,7 +616,8 @@ LocalVarNode
               casm.with_retry do 
                 casm.mov(FUNC_ARG[argpos], context.ret_reg)
               end
-              context.set_reg_content(FUNC_ARG[argpos], context.ret_node)
+              context.set_reg_content(FUNC_ARG[argpos].dst_opecode, 
+                                      context.ret_node)
             end
             argpos = argpos + 1
             cursrc = cursrc + 1
@@ -602,11 +626,10 @@ LocalVarNode
           context = gen_call(context, fnc, numarg)
           
           context.cpustack_popn(numarg * AsmType::MACHINE_WORD.size)
-          numarg.times do |i|
-            context.end_using_reg(FUNC_ARG[numarg - i - 1])
-          end
+          context.end_arg_reg
           context.end_using_reg(fnc)
           context.ret_reg = RETR
+          context.set_reg_content(context.ret_reg, self)
           
           decide_type_once(context.to_signature)
           if !@type.boxed then 
@@ -620,9 +643,8 @@ LocalVarNode
           fnc = nil
           numarg = @arguments.size
           
-          numarg.times do |i|
-            context.start_using_reg(FUNC_ARG_YTL[i])
-          end
+          context.start_arg_reg
+          context.start_arg_reg(FUNC_ARG_YTL)
           context.cpustack_pushn(numarg * 8)
           
           # push prev env
@@ -633,12 +655,12 @@ LocalVarNode
               casm.mov(TMPR, prevenv)
               casm.mov(FUNC_ARG_YTL[0], TMPR)
             end
-            context.set_reg_content(FUNC_ARG_YTL[0], prevenv)
+            context.set_reg_content(FUNC_ARG_YTL[0].dst_opecode, prevenv)
           else
             casm.with_retry do 
               casm.mov(FUNC_ARG_YTL[0], BPR)
             end
-            context.set_reg_content(FUNC_ARG_YTL[0], BPR)
+            context.set_reg_content(FUNC_ARG_YTL[0].dst_opecode, BPR)
           end
           
           # block
@@ -647,6 +669,7 @@ LocalVarNode
           
           # compile block with other code space and context
           tcontext = context.dup
+          tcontext.prev_context = context
           @arguments[1].compile(tcontext)
           
           casm = context.assembler
@@ -658,34 +681,77 @@ LocalVarNode
             casm.with_retry do 
               casm.mov(FUNC_ARG_YTL[i + 3], context.ret_reg)
             end
-            context.set_reg_content(FUNC_ARG_YTL[i + 3], context.ret_node)
+            context.set_reg_content(FUNC_ARG_YTL[i + 3].dst_opecode, 
+                                    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)
+          context.set_reg_content(FUNC_ARG_YTL[1].dst_opecode, nil)
 
           # self
           # Method Select
           # it is legal. use TMPR2 for method select
-          # use TMPR3 for store self
+          # use PTMPR for store self
           context = @func.compile(context)
           fnc = context.ret_reg
           casm = context.assembler
           casm.with_retry do 
             casm.mov(FUNC_ARG_YTL[2], context.ret_reg2)
           end
-          context.set_reg_content(FUNC_ARG_YTL[2], @arguments[2])
+          context.set_reg_content(FUNC_ARG_YTL[2].dst_opecode, @arguments[2])
 
           context = gen_call(context, fnc, numarg)
           
           context.cpustack_popn(numarg * 8)
-          numarg.size.times do |i|
-            context.end_using_reg(FUNC_ARG_YTL[numarg - i])
+          context.end_arg_reg
+          context.end_arg_reg(FUNC_ARG_YTL)
+          context.end_using_reg(fnc)
+          context
+        end
+
+        def compile_c_fixarg_raw(context)
+          context = @func.compile(context)
+          fnc = context.ret_reg
+          numarg = @arguments.size
+          
+          context.start_arg_reg
+          context.cpustack_pushn(numarg * AsmType::MACHINE_WORD.size)
+          
+          @arguments.each_with_index do |arg, argpos|
+#            p "#{@func.name} #{argpos}"
+            context = arg.compile(context)
+            rtype = context.ret_node.decide_type_once(context.to_signature)
+
+            atype = @func.arg_type[argpos]
+            if atype == :"..." or atype == nil then
+              if @func.arg_type.last == :"..." then
+                atype = @func.arg_type[-2]
+              end
+            end
+            if atype == :VALUE then
+              context = rtype.gen_boxing(context)
+            end
+
+            casm = context.assembler
+            casm.with_retry do 
+              casm.mov(FUNC_ARG[argpos], context.ret_reg)
+            end
+            context.set_reg_content(FUNC_ARG[argpos].dst_opecode, 
+                                    context.ret_node)
           end
+          
+          context = gen_call(context, fnc, numarg)
+          
+          context.cpustack_popn(numarg * AsmType::MACHINE_WORD.size)
+          context.end_arg_reg
           context.end_using_reg(fnc)
+          context.ret_reg = RETR
+          context.set_reg_content(context.ret_reg, self)
+          
+          decide_type_once(context.to_signature)
           context
         end
       end
@@ -761,21 +827,59 @@ LocalVarNode
           end
         end
 
-        def construct_frame_info(locals, argnum)
+        def add_arg_to_args(args, addnum)
+          if args.is_a?(Integer) then
+            args = args + addnum
+          elsif args.is_a?(Array) then
+            args = args.dup
+            args[0] += addnum
+            args[3] += addnum if args[3] >= 0
+            args[4] += addnum if args[4] >= 0
+            args[5] += addnum if args[5] >= 0
+          else
+            raise "Unkonwn args #{args}"
+          end
+
+          args
+        end
+
+        def construct_frame_info(locals, argnum, args)
           finfo = LocalFrameInfoNode.new(self)
-          finfo.system_num = 4         # BP ON Stack, BP, RET
+          finfo.system_num = 5         # BP ON Stack, HP, ET, BP, RET
+
+          argc = args
+          opt_label = []
+          rest_index = -1
+          post_len = -1
+          post_start = -1
+          block_index = -1
+          simple = -1
+          if args.is_a?(Array) then
+            argc = args[0]
+            opt_label = args[1]
+            post_len = args[2]
+            post_start = args[3]
+            rest_index = args[4]
+            block_index = args[5]
+            simple = args[6]
+          end
           
-          # 3 means BP, BP and SP
+          # 5means BP, HP, Exception Tag, BP and SP
           lsize = locals.size + finfo.system_num
           
           # construct frame
           frame_layout = Array.new(lsize)
-          i = 0
           fargstart = lsize - argnum
+          i = 0
           argnum.times do
-            lnode = LocalVarNode.new(finfo, locals[i], fargstart + i)
+            kind = :arg
+            if i == rest_index then
+              kind = :rest_arg
+            end
+            lnode = LocalVarNode.new(finfo, locals[i], fargstart + i,
+                                     kind)
             frame_layout[fargstart + i] = lnode
-            i += 1
+            i = i + 1
           end
           
           curpos = fargstart - 1
@@ -786,7 +890,10 @@ LocalVarNode
                                                      :OLD_BP, curpos)
           curpos -= 1
           frame_layout[curpos] = SystemValueNode.new(finfo, 
-                                                     :FRAME_INFO, curpos)
+                                                     :EXPTAG, curpos)
+          curpos -= 1
+          frame_layout[curpos] = SystemValueNode.new(finfo, 
+                                                     :TMPHEAP, curpos)
           curpos -= 1
           frame_layout[curpos] = SystemValueNode.new(finfo, 
                                                      :OLD_BPSTACK, curpos)
@@ -794,7 +901,7 @@ LocalVarNode
           j = 0
           lvarnum = lsize - finfo.system_num 
           while i < lvarnum do
-            lnode = LocalVarNode.new(finfo, locals[i], j)
+            lnode = LocalVarNode.new(finfo, locals[i], j, :local_var)
             frame_layout[j] = lnode
             i += 1
             j += 1
@@ -803,6 +910,7 @@ LocalVarNode
           finfo.argument_num = argnum
           
           @body = finfo
+          finfo.init_after_construct
           finfo
         end
 
@@ -849,6 +957,10 @@ LocalVarNode
           end
         end
 
+        def compile_init(context)
+          context
+        end
+
         def compile(context)
           oldcs = context.code_space
           @code_spaces.each do |sig, cs|
@@ -857,6 +969,7 @@ LocalVarNode
             context = super(context)
             context.reset_using_reg
             context = gen_method_prologue(context)
+            context = compile_init(context)
             context = @body.compile(context)
             context.current_method_signature.pop
           end
@@ -885,12 +998,13 @@ LocalVarNode
           context
         end
 
-        def construct_frame_info(locals, argnum)
+        def construct_frame_info(locals, argnum, args)
           locals.unshift :_self
           locals.unshift :_block
           locals.unshift :_prev_env
           argnum += 3
-          super(locals, argnum)
+          args = add_arg_to_args(args, 3)
+          super(locals, argnum, args)
         end
       end
 
@@ -922,7 +1036,7 @@ LocalVarNode
           @constant_tab = {}
           @method_tab = {}
           @klass_object = klassobj
-          @klassclass = ClassClassWrapper.new(@klass_object)
+          @klassclass = ClassClassWrapper.instance(@klass_object)
           @klassclass_node = nil # Lazy
           RubyType::define_wraped_class(@klassclass, 
                                         RubyType::RubyTypeBoxed)
@@ -931,6 +1045,12 @@ LocalVarNode
           end
         end
 
+        attr :klass_object
+        attr :constant_tab
+        attr :method_tab
+        attr :klassclass
+        attr :klassclass_node
+
         def collect_info(context)
           context.modified_local_var.push [{}]
           context.modified_instance_var = Hash.new
@@ -943,21 +1063,14 @@ LocalVarNode
           end
         end
 
-        def collect_candidate_type(context, signode, sig)
-          super
-          if @klassclass_node then
-            @klassclass_node.collect_candidate_type(context, signode, sig)
-          else
-            context
-          end
-        end
-
         def make_klassclass_node
-          clsclsnode = ClassTopNode.new(self, 
-                                        @klassclass, 
-                                        @klassclass.name)
-          clsclsnode.body = DummyNode.new
-          @klassclass_node = clsclsnode
+          if @klassclass_node == nil then
+            clsclsnode = ClassTopNode.new(self, 
+                                          @klassclass, 
+                                          @klassclass.name)
+            clsclsnode.body = DummyNode.new
+            @klassclass_node = clsclsnode
+          end
         end
 
         def get_method_tab(klassobj = @klass_object)
@@ -1007,16 +1120,13 @@ LocalVarNode
           [nil, nil]
         end
 
-        attr :klass_object
-        attr :constant_tab
-        attr :method_tab
-
-        def construct_frame_info(locals, argnum)
+        def construct_frame_info(locals, argnum, args)
           locals.unshift :_self
           locals.unshift :_block
           locals.unshift :_prev_env
           argnum += 3
-          super(locals, argnum)
+          args = add_arg_to_args(args, 3)
+          super(locals, argnum, args)
         end
 
         def collect_candidate_type(context, signode, sig)
@@ -1033,30 +1143,42 @@ LocalVarNode
           context.push_signature(signode, self)
           context = @body.collect_candidate_type(context)
           context.pop_signature
-          context
+
+          if @klassclass_node then
+            @klassclass_node.collect_candidate_type(context, signode, sig)
+          else
+            context
+          end
         end
 
         def compile(context)
           context = super(context)
 
-          cs = self.find_cs_by_signature(context.to_signature)
+          sig = context.to_signature.dup
+          sig[2] = @type
+=begin
+          pp sig
+          pp @name
+          pp @code_spaces.map{|a| a[0]}
+=end
+
+          cs = self.find_cs_by_signature(sig)
           if cs then
             asm = context.assembler
-            add = lambda { @klassclass.value.address }
+            add = lambda { @klass_object.address }
             var_klassclass = OpVarImmidiateAddress.new(add)
-            context.start_using_reg(FUNC_ARG[0])
-            context.start_using_reg(FUNC_ARG[1])
-            context.start_using_reg(FUNC_ARG[2])
+            context.start_arg_reg
             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
+            context.set_reg_content(FUNC_ARG_YTL[0].dst_opecode, BPR)
+            context.set_reg_content(FUNC_ARG_YTL[1].dst_opecode, nil)
+            context.set_reg_content(FUNC_ARG_YTL[2].dst_opecode, self)
             add = cs.var_base_address
             context = gen_call(context, add, 3)
-            context.end_using_reg(FUNC_ARG[2])
-            context.end_using_reg(FUNC_ARG[1])
-            context.end_using_reg(FUNC_ARG[0])
+            context.end_arg_reg
           end
           
           context
@@ -1069,6 +1191,12 @@ LocalVarNode
 
       class TopTopNode<ClassTopNode
         include MethodTopCodeGen
+        @@frame_struct_tab = {}
+        @@local_object_area = Runtime::Arena.new
+
+        def self.get_frame_struct_tab
+          @@frame_struct_tab
+        end
 
         def initialize(parent, klassobj, name = :top)
           super
@@ -1077,6 +1205,7 @@ LocalVarNode
           @asm_tab = {}
           @id.push 0
 
+          @frame_struct_array = []
           @unwind_proc = CodeSpace.new
           @init_node = nil
           init_unwind_proc
@@ -1086,6 +1215,13 @@ LocalVarNode
         attr_accessor :init_node
         attr          :code_space_tab
         attr          :asm_tab
+        attr          :frame_struct_array
+
+        def make_frame_struct_tab
+          @frame_struct_array.each do |vkey, val|
+            @@frame_struct_tab[vkey.value] = val
+          end
+        end
 
         def traverse_childlen
           if @init_node then
@@ -1130,12 +1266,21 @@ LocalVarNode
           super(context, signode, sig)
         end
 
+        def compile_init(context)
+          ar = @@local_object_area
+          aa = (ar.address + ar.size) & (~0xf)
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(THEPR, aa)
+          end
+          context
+        end
+
         def compile(context)
           if @init_node then
             context = @init_node.compile(context)
           end
-          context = super(context)
-          context
+          super(context)
         end
       end
 
@@ -1149,6 +1294,12 @@ LocalVarNode
           @system_num = nil
           @previous_frame = search_previous_frame(parent)
           @offset_cache = {}
+          @local_area_size = nil
+          @alloca_area_size = 0
+        end
+
+        def init_after_construct
+          @local_area_size = compute_local_area_size
         end
 
         def search_previous_frame(mtop)
@@ -1184,9 +1335,11 @@ LocalVarNode
           @frame_layout.inject(0) {|sum, slot| sum += slot.size}
         end
 
-        def local_area_size
+        def compute_local_area_size
           localnum = @frame_layout.size - @argument_num - @system_num
-          @frame_layout[0, localnum].inject(0) {|sum, slot| sum += slot.size}
+          @frame_layout[0, localnum].inject(0) {|sum, slot| 
+            sum += slot.size
+          }
         end
 
         def real_offset(off)
@@ -1207,7 +1360,7 @@ LocalVarNode
             obyte += @frame_layout[i].size
           end
           
-          obyte - local_area_size
+          obyte - @local_area_size
         end
 
         def offset_arg(n, basereg)
@@ -1226,6 +1379,12 @@ LocalVarNode
           rc
         end
 
+        def alloca(size)
+#          base = -offset_by_byte(0)
+          @alloca_area_size += size
+          -(@local_area_size + @alloca_area_size)
+        end
+
         def collect_candidate_type(context)
           traverse_childlen {|rec|
             context = rec.collect_candidate_type(context)
@@ -1234,26 +1393,30 @@ LocalVarNode
 
         def compile(context)
           context = super(context)
-          siz = local_area_size
+          siz = @local_area_size + @alloca_area_size
           if  siz != 0 then
             asm = context.assembler
             asm.with_retry do
               asm.sub(SPR, siz)
             end
-            context.cpustack_pushn(siz)
           end
-          @body.compile(context)
+          context.cpustack_pushn(siz)
+          context = @body.compile(context)
+          context.cpustack_popn(siz)
+          context
         end
       end
 
       class LocalVarNode<BaseNode
-        def initialize(parent, name, offset)
+        def initialize(parent, name, offset, kind)
           super(parent)
           @name = name
           @offset = offset
+          @kind = kind
         end
 
         attr :name
+        attr :kind
 
         def size
           8
@@ -1387,6 +1550,7 @@ LocalVarNode
         end
 
         def collect_candidate_type(context)
+          @is_escape = true
           context = @value_node.collect_candidate_type(context)
           cursig = context.to_signature
           same_type(self, @value_node, cursig, cursig, context)
@@ -1440,7 +1604,6 @@ LocalVarNode
             if vnode then
               cursig = context.to_signature
               same_type(self, vnode, cursig, cursig, context)
-              same_type(vnode, self, cursig, cursig, context)
             end
           end
           context
@@ -1448,9 +1611,9 @@ LocalVarNode
 
         def compile(context)
           context = super(context)
-          context.set_reg_content(TMPR, self)
           context.ret_node = self
           context.ret_reg = RETR
+          context.set_reg_content(RETR, self)
           context
         end
       end
@@ -1535,6 +1698,7 @@ LocalVarNode
             end
           end
 
+          context.set_reg_content(context.ret_reg, self)
           context
         end
 
@@ -1683,6 +1847,61 @@ LocalVarNode
         include HaveChildlenMixin
       end
 
+      # Multiplexer of node (Using YARV stack operation)
+      class MultiplexNode<BaseNode
+        include HaveChildlenMixin
+        include NodeUtil
+
+        def initialize(node)
+          super(node.parent)
+          @node = node
+          @first_compile = true
+          @res_area = nil
+        end
+
+        def traverse_childlen
+          yield @node
+        end
+
+        def collect_info(context)
+          tnode = search_frame_info
+          offset = tnode.alloca(8)
+          @res_area = OpIndirect.new(BPR, offset)
+          @node.collect_info(context)
+        end
+
+        def collect_candidate_type(context)
+          sig = context.to_signature          
+          same_type(self, @node, sig, sig, context)
+          same_type(@node, self, sig, sig, context)
+          @node.collect_candidate_type(context)
+        end
+
+        def compile(context)
+          if @first_compile then
+            context = @node.compile(context)
+            asm = context.assembler
+            asm.with_retry do
+              asm.mov(@res_area, context.ret_reg)
+            end
+            context.set_reg_content(@res_area, self)
+            @first_compile = false
+
+            context
+          else
+            asm = context.assembler
+            asm.with_retry do
+              asm.mov(RETR, @res_area)
+            end
+            context.set_reg_content(@res_area, self)
+            context.ret_reg = RETR
+            context.ret_node = self
+
+            context
+          end
+        end
+      end
+
       # Literal
       class LiteralNode<BaseNode
         include TypeListWithoutSignature
@@ -1702,14 +1921,22 @@ LocalVarNode
           end
 
           sig = context.to_signature
-          add_type(sig, @type)
           case @value
           when Array
+            add_type(sig, @type)
             @value.each do |ele|
               etype = RubyType::BaseType.from_object(ele)
               @element_node_list[0][1].add_type(sig, etype)
             end
+
+          when Range
+            @type = @type.to_box
+            add_type(sig, @type)
+
+          else
+            add_type(sig, @type)
           end
+
           context
         end
 
@@ -1741,6 +1968,7 @@ LocalVarNode
               context.ret_reg = XMM0
             end
             context.ret_node = self
+            context.set_reg_content(context.ret_reg, self)
 
           else
             if @var_value == nil then
@@ -1751,6 +1979,7 @@ LocalVarNode
             context.ret_node = self
             context.ret_reg = @var_value
             context = @type.gen_copy(context)
+            context.set_reg_content(context.ret_reg, self)
           end
 
           context
@@ -1780,10 +2009,13 @@ LocalVarNode
           dmylit = LiteralNode.new(self, nil)
           arg = [dmylit, dmylit, @define]
           sig = []
+          cursig = context.to_signature
           arg.each do |ele|
-            ele.decide_type_once(context.to_signature)
+            ele.decide_type_once(cursig)
             sig.push ele.type
           end
+          type = RubyType::BaseType.from_ruby_class(@define.klassclass)
+          sig[2] = type
           context = @define.collect_candidate_type(context, arg, sig)
 
           @body.collect_candidate_type(context)
@@ -1852,24 +2084,73 @@ LocalVarNode
           context = super(context)
           asm = context.assembler
           # You can crash when you use yield in block.
-          # You can fix this bug for traversing TMPR3 for method top.
+          # You can fix this bug for traversing PTMPR 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)
+          slfarg = @frame_info.offset_arg(2, PTMPR)
           asm.with_retry do
-            asm.mov(TMPR3, prevenv)
-            asm.mov(TMPR3, slfarg)
+            asm.mov(PTMPR, prevenv)
+            asm.mov(PTMPR, slfarg)
           end
-          context.ret_reg2 = TMPR3
+          context.ret_reg2 = PTMPR
           
           context.ret_reg = @frame_info.offset_arg(1, BPR)
           context.ret_node = self
+          context.set_reg_content(context.ret_reg, self)
+          context
+        end
+      end
+
+      class CApiCommonNode<BaseNode
+        include NodeUtil
+        include SendUtil
+
+        def initialize(parent, name, atype, rtype = :VALUE)
+          super(parent)
+          @name = name
+          @frame_info = search_frame_info
+          @arg_type = atype
+          @ret_type = rtype
+        end
+
+        attr :name
+        attr :frame_info
+        attr :arg_type
+        attr :ret_type
+
+        def collect_candidate_type(context)
+          context
+        end
+
+        def method_top_node(ctop, slf)
+          nil
+        end
+
+        def compile(context)
+          context = super(context)
+          context.ret_reg = OpMemAddress.new(address_of(@name))
+          context.ret_node = self
+          context.set_reg_content(context.ret_reg, self)
           context
         end
       end
 
+      # C API (fix arguments)
+      class FixArgCApiNode<CApiCommonNode
+        def calling_convention(context)
+          :c_fixarg_raw
+        end
+      end
+
+      # C API (variable arguments)
+      class VarArgCApiNode<CApiCommonNode
+        def calling_convention(context)
+          :c_vararg_raw
+        end
+      end
+
       # Method name
       class MethodSelectNode<BaseNode
         def initialize(parent, val)
@@ -1885,6 +2166,11 @@ LocalVarNode
           @send_node = sendnode
           if sendnode.is_fcall or sendnode.is_vcall then
             @reciever = @parent.class_top
+            if @reciever == @parent.search_top and 
+                !@reciever.is_a?(TopTopNode) then
+              @reciever.make_klassclass_node
+              @reciever = @reciever.klassclass_node
+            end
           else
             @reciever = sendnode.arguments[2]
           end
@@ -1900,7 +2186,7 @@ LocalVarNode
 
         def method_top_node(ctop, slf)
           if slf then
-            ctop.search_method_with_super(@name, slf.ruby_type)[0]
+            ctop.search_method_with_super(@name, slf.ruby_type_raw)[0]
           else
             ctop.search_method_with_super(@name)[0]
           end
@@ -1913,17 +2199,20 @@ LocalVarNode
               @calling_convention = :ytl
             else
               # reciever = Object
-              if @reciever.klass_object then
-                addr = @reciever.klass_object.method_address_of(@name)
+              recobj = @reciever.klass_object
+              if recobj.is_a?(ClassClassWrapper) then
+                recobj = recobj.value
+              end
+              if recobj then
+                addr = recobj.method_address_of(@name)
                 if addr then
-                  recobj = @reciever.klass_object
                   if variable_argument?(recobj.method(@name).parameters) then
                     @calling_convention = :c_vararg
                   else
                     @calling_convention = :c_fixarg
                   end
                 else
-                  raise "Unkown method - #{@name}"
+                  raise "Unkown method - #{recobj}##{@name}"
                   @calling_convention = :c
                 end
               else
@@ -1931,12 +2220,12 @@ LocalVarNode
               end
             end
           else
-            @reciever.decide_type_once(context.to_signature)
-            rtype = @reciever.type
-            rklass = rtype.ruby_type
+            rtype = @reciever.decide_type_once(context.to_signature)
+            rklass = rtype.ruby_type_raw
             knode = ClassTopNode.get_class_top_node(rklass)
             if knode and knode.search_method_with_super(@name)[0] then
               @calling_convention = :ytl
+              @ruby_reciever = rklass
             else
               slfval = @reciever.get_constant_value
               mth = nil
@@ -1948,8 +2237,26 @@ LocalVarNode
                 end
               end
               if slfval == nil or mth == nil then
-                mth = rklass.instance_method(@name)
-                @ruby_reciever = rtype.instance_eval {@ruby_type}
+                if rklass.is_a?(ClassClassWrapper) then
+                  rklass = rklass.value
+                end
+                begin
+                  mth = rklass.instance_method(@name)
+                rescue NameError
+                  p @parent.debug_info
+                  p context.to_signature
+                  p @name
+#                  p @reciever.func.reciever.class
+                  p @reciever.instance_eval {@type_list }
+=begin
+                  mc = @reciever.get_send_method_node(context.to_signature)[0]
+                  iv = mc.end_nodes[0].parent.value_node
+                  p iv.instance_eval {@name}
+                  p iv.instance_eval {@type_list}
+=end
+                  raise
+                end
+                @ruby_reciever = rtype.ruby_type_raw
               end
 
               if variable_argument?(mth.parameters) then
@@ -1969,18 +2276,22 @@ LocalVarNode
             slfop = @parent.frame_info.offset_arg(2, BPR)
             asm = context.assembler
             asm.with_retry do
-              asm.mov(TMPR3, slfop)
+              asm.mov(PTMPR, slfop)
             end
-            context.ret_reg2 = TMPR3
+            context.ret_reg2 = PTMPR
             mtop = @reciever.search_method_with_super(@name)[0]
             if mtop then
               sig = @parent.signature(context)
               cs = mtop.find_cs_by_signature(sig)
               context.ret_reg = cs.var_base_address
             else
-              if @reciever.klass_object then
+              recobj = @reciever.klass_object
+              if recobj.is_a?(ClassClassWrapper) then
+                recobj = recobj.value
+              end
+              if recobj then
                 addr = lambda {
-                  @reciever.klass_object.method_address_of(@name)
+                  recobj.method_address_of(@name)
                 }
                 if addr.call then
                   context.ret_reg = OpVarMemAddress.new(addr)
@@ -1997,13 +2308,16 @@ LocalVarNode
             end
           else
             context = @reciever.compile(context)
-            context.ret_node.decide_type_once(context.to_signature)
-            rtype = context.ret_node.type
+            rtype = context.ret_node.decide_type_once(context.to_signature)
             if @calling_convention != :ytl then
               context = rtype.gen_boxing(context)
+              rtype = rtype.to_box
+            elsif !rtype.boxed then
+              context = rtype.gen_unboxing(context)
             end
             recval = context.ret_reg
-            knode = ClassTopNode.get_class_top_node(rtype.ruby_type)
+            rrtype = rtype.ruby_type_raw
+            knode = ClassTopNode.get_class_top_node(rrtype)
             mtop = nil
 
             if rtype.is_a?(RubyType::DefaultType0) then
@@ -2014,8 +2328,7 @@ LocalVarNode
               meaddrof = OpMemAddress.new(addr)
 
               context.start_using_reg(TMPR2)
-              context.start_using_reg(FUNC_ARG[0])
-              context.start_using_reg(FUNC_ARG[1])
+              context.start_arg_reg
               
               asm = context.assembler
               asm.with_retry do
@@ -2026,20 +2339,22 @@ LocalVarNode
                 asm.mov(FUNC_ARG[1], mnval)
                 asm.call_with_arg(meaddrof, 2)
                 asm.mov(TMPR2, RETR)
-                asm.pop(TMPR3)
+                asm.pop(PTMPR)
               end
-              context.ret_reg2 = TMPR3
+              context.set_reg_content(FUNC_ARG_YTL[0].dst_opecode, nil)
+              context.set_reg_content(FUNC_ARG_YTL[1].dst_opecode, self)
+              context.ret_reg2 = PTMPR
               
-              context.end_using_reg(FUNC_ARG[1])
-              context.end_using_reg(FUNC_ARG[0])
+              context.end_arg_reg
               
               context.ret_node = self
               context.set_reg_content(RETR, self)
               context.set_reg_content(TMPR2, self)
-              context.set_reg_content(TMPR3, @reciever)
+              context.set_reg_content(PTMPR, @reciever)
               context.ret_reg = TMPR2
 
-            elsif knode and mtop = knode.search_method_with_super(@name)[0] then
+            elsif knode and
+                mtop = knode.search_method_with_super(@name)[0] then
               asm = context.assembler
               if !rtype.boxed and rtype.ruby_type == Float then
                 if recval != XMM0 then
@@ -2050,9 +2365,9 @@ LocalVarNode
                 context.ret_reg2 = XMM0
               else
                 asm.with_retry do
-                  asm.mov(TMPR3, recval)
+                  asm.mov(PTMPR, recval)
                 end
-                context.ret_reg2 = TMPR3
+                context.ret_reg2 = PTMPR
               end
 
               sig = @parent.signature(context)
@@ -2072,9 +2387,9 @@ LocalVarNode
                 context.ret_reg2 = XMM0
               else
                 asm.with_retry do
-                  asm.mov(TMPR3, recval)
+                  asm.mov(PTMPR, recval)
                 end
-                context.ret_reg2 = TMPR3
+                context.ret_reg2 = PTMPR
               end
 
               addr = lambda {
@@ -2197,6 +2512,7 @@ LocalVarNode
         def initialize(parent)
           super(parent, 2, 0)
           @classtop = search_class_top
+          @topnode = search_top
         end
 
         def compile_main(context)
@@ -2206,11 +2522,17 @@ LocalVarNode
           context
         end
 
+#=begin
         def collect_candidate_type(context)
-          @type = RubyType::BaseType.from_ruby_class(@classtop.klass_object)
-          add_type(context.to_signature, @type)
-          context
+          if @topnode.is_a?(ClassTopNode) then
+            @type = RubyType::BaseType.from_ruby_class(@classtop.klass_object)
+            add_type(context.to_signature, @type)
+            context
+          else
+            super(context)
+          end
         end
+#=end
 
         def compile(context)
 #          context = super(context)
@@ -2273,6 +2595,7 @@ LocalVarNode
           end
 
           valr = context.ret_reg
+          valn = context.ret_node
           context = gen_pursue_parent_function(context, @depth)
           base = context.ret_reg
           offarg = @current_frame_info.offset_arg(@offset, base)
@@ -2290,7 +2613,11 @@ LocalVarNode
               asm.mov(offarg, TMPR)
             end
           end
-          
+
+          tmpctx = context
+          @depth.times { tmpctx = tmpctx.prev_context}
+          tmpctx.set_reg_content(offarg, valn)
+
           context.ret_reg = nil
           if base == TMPR2 then
             context.end_using_reg(base)
@@ -2321,6 +2648,7 @@ LocalVarNode
           vti = context.modified_instance_var[@name]
           if vti == nil then
             vti = []
+            context.modified_instance_var[@name] = vti
           end
           # Not dup so vti may update after.
           @var_type_info = vti 
@@ -2362,11 +2690,16 @@ LocalVarNode
 
         def collect_info(context)
           context = @val.collect_info(context)
-          context.modified_instance_var[@name] = [self]
+          if context.modified_instance_var[@name] == nil then
+            context.modified_instance_var[@name] = []
+          end
+          context.modified_instance_var[@name].push self
           @body.collect_info(context)
         end
 
         def collect_candidate_type(context)
+          @is_escape = true
+          @val.is_escape = true
           context = @val.collect_candidate_type(context)
           cursig = context.to_signature
           same_type(self, @val, cursig, cursig, context)
@@ -2427,10 +2760,6 @@ LocalVarNode
           end
           context
         end
-        
-        def type
-          @value_node.type
-        end
 
         def compile(context)
           case @value_node