ytljit 0.0.2 → 0.0.3

data/lib/ytljit/vm.rb

@@ -131,16 +131,16 @@ LocalVarNode
         attr_accessor :type
         attr_accessor :element_node_list
 
-        def add_type(key, type)
-          @type_list.add_type(key, type)
+        def add_type(sig, type)
+          @type_list.add_type(sig, type)
         end
 
-        def type_list(key)
-          @type_list.type_list(key).value
+        def type_list(sig)
+          @type_list.type_list(sig).value
         end
 
-        def set_type_list(key, val)
-          @type_list.type_list(key).value = val
+        def set_type_list(sig, val)
+          @type_list.type_list(sig).value = val
         end
 
         def collect_info(context)
@@ -153,22 +153,22 @@ LocalVarNode
           context
         end
 
-        def ti_add_observer(dst, dkey, skey, context)
+        def ti_add_observer(dst, dsig, ssig, context)
           if @ti_observer[dst] == nil then
             @ti_observer[dst] = []
           end
           
-          if @ti_observer[dst].all? {|edkey, eskey, eprc| 
-              (edkey != dkey) or (eskey != skey)
+          if @ti_observer[dst].all? {|edsig, essig, eprc| 
+              (edsig != dsig) or (essig != ssig)
             } then
-            prc = lambda { send(:ti_update, dst, self, dkey, skey, context) }
-            @ti_observer[dst].push [dkey, skey, prc]
+            prc = lambda { send(:ti_update, dst, self, dsig, ssig, context) }
+            @ti_observer[dst].push [dsig, ssig, prc]
           end
         end
 
         def ti_changed
           @ti_observer.each do |rec, lst|
-            lst.each do |dkey, skey, prc|
+            lst.each do |dsig, ssig, prc|
               prc.call
             end
           end
@@ -185,17 +185,17 @@ LocalVarNode
           res
         end
 
-        def ti_update(dst, src, dkey, skey, context)
-          dtlist = dst.type_list(dkey)
-          stlist = src.type_list(skey)
+        def ti_update(dst, src, dsig, ssig, context)
+          dtlist = dst.type_list(dsig)
+          stlist = src.type_list(ssig)
 =begin
-          print dkey.map(&:ruby_type), "\n"
+          print dsig.map(&:ruby_type), "\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(dkey, merge_type(dtlist, stlist))
+          dst.set_type_list(dsig, merge_type(dtlist, stlist))
 
           if orgsize != dtlist.size then
             dst.type = nil
@@ -213,7 +213,7 @@ LocalVarNode
           end
         end
 
-        def same_type(dst, src, dkey, skey, context)
+        def same_type(dst, src, dsig, ssig, context)
 =begin
           print "#{src.class} -> #{dst.class} \n"
           if dst.is_a?(LocalVarNode) then
@@ -225,20 +225,20 @@ LocalVarNode
 =end
 
           if dst.is_a?(BaseNode) then
-            src.ti_add_observer(dst, dkey, skey, context)
+            src.ti_add_observer(dst, dsig, ssig, context)
           end
 
-          ti_update(dst, src, dkey, skey, context)
+          ti_update(dst, src, dsig, ssig, context)
         end
 
-        def add_element_node(key, type, context)
+        def add_element_node(sig, enode, context)
           slfetnode = @element_node_list
-          unless slfetnode.include?(type)
-            @element_node_list.push [key, type]
-            orgkey = @element_node_list[0][0]
-            orgtype = @element_node_list[0][1]
-            if orgtype != type then
-              same_type(orgtype, type, orgkey, key, context)
+          unless slfetnode.include?(enode)
+            @element_node_list.push [sig, enode]
+            orgsig = @element_node_list[0][0]
+            orgnode = @element_node_list[0][1]
+            if orgnode != enode then
+              same_type(orgnode, enode, orgsig, sig, context)
             end
             ti_changed
 #            context.convergent = false
@@ -258,9 +258,9 @@ LocalVarNode
             
           when 1
             if tlist[0].have_element? then
-              key = @element_node_list[0][0]
+              sig = @element_node_list[0][0]
               node = @element_node_list[0][1]
-              node.decide_type_once(key)
+              node.decide_type_once(sig)
               tlist[0].element_type = node.type
             end
             tlist[0]
@@ -271,19 +271,19 @@ LocalVarNode
           end
         end
 
-        def decide_type_once(key)
+        def decide_type_once(sig)
           if @type.equal?(nil) # or @type.is_a?(RubyType::DefaultType0) then
-            tlist = @type_list.type_list(key).value
+            tlist = @type_list.type_list(sig).value
             @type = decide_type_core(tlist)
           end
         end
 
-        def decide_type(key)
-          decide_type_once(key)
+        def decide_type(sig)
+          decide_type_once(sig)
 
           if is_a?(HaveChildlenMixin) then
             traverse_childlen {|rec|
-              rec.decide_type(key)
+              rec.decide_type(sig)
             }
           end
         end
@@ -362,11 +362,14 @@ LocalVarNode
       end
 
       module SendUtil
+        include AbsArch
+
         def gen_eval_self(context)
           # eval 1st arg(self)
           slfnode = @arguments[2]
           context = slfnode.compile(context)
           
+          context.ret_node.decide_type_once(context.to_signature)
           rtype = context.ret_node.type
           rtype.gen_unboxing(context)
         end
@@ -374,12 +377,175 @@ LocalVarNode
         def signature(context)
           res = []
           @arguments.each do |ele|
-            ele.decide_type_once(context.to_key)
+            ele.decide_type_once(context.to_signature)
             res.push ele.type
           end
 
           res
         end
+
+        def compile_c_vararg(context)
+          fnc = nil
+          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.cpustack_pushn(3 * AsmType::MACHINE_WORD.size)
+            casm = context.assembler
+            # 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
+            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)
+            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_using_reg(TMPR2)
+            context.ret_reg = RETR
+            context.ret_node = self
+            
+            decide_type_once(context.to_signature)
+            context = @type.to_box.gen_unboxing(context)
+            
+            context
+          end
+        end
+
+        def compile_c_fixarg(context)
+          fnc = nil
+          numarg = @arguments.size - 2
+          
+          numarg.times do |i|
+            context.start_using_reg(FUNC_ARG[i])
+          end
+          context.cpustack_pushn(numarg * AsmType::MACHINE_WORD.size)
+          
+          argpos = 0
+          cursrc = 0
+          @arguments.each do |arg|
+            # skip prevenv and block_argument
+            if cursrc < 2 then
+              cursrc = cursrc + 1
+              next
+            end
+            
+            if cursrc == 2 then
+              # Self
+              # Method Select
+              # it is legal. use TMPR2 for method select
+              # use TMPR3 for store self
+              context = @func.compile(context)
+              fnc = context.ret_reg
+              casm = context.assembler
+              casm.with_retry do 
+                casm.mov(FUNC_ARG[0], TMPR3)
+              end
+              context.set_reg_content(FUNC_ARG[0], context.ret_node)
+            else
+              # other arg.
+              context = arg.compile(context)
+              context.ret_node.decide_type_once(context.to_signature)
+              rtype = context.ret_node.type
+              context = rtype.gen_boxing(context)
+              casm = context.assembler
+              casm.with_retry do 
+                casm.mov(FUNC_ARG[argpos], context.ret_reg)
+              end
+              context.set_reg_content(FUNC_ARG[argpos], context.ret_node)
+            end
+            argpos = argpos + 1
+            cursrc = cursrc + 1
+          end
+          
+          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_using_reg(fnc)
+          
+          decide_type_once(context.to_signature)
+          @type.to_box.gen_unboxing(context)
+        end
+
+        def compile_ytl(context)
+          fnc = nil
+          numarg = @arguments.size
+          
+          numarg.times do |i|
+            context.start_using_reg(FUNC_ARG_YTL[i])
+          end
+          context.cpustack_pushn(numarg * 8)
+          
+          # push prev env
+          casm = context.assembler
+          casm.with_retry do 
+            casm.mov(FUNC_ARG_YTL[0], BPR)
+          end
+          context.set_reg_content(FUNC_ARG_YTL[0], BPR)
+          
+          # block
+          # eval block
+          # local block
+          
+          # compile block with other code space and context
+          tcontext = context.dup
+          @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)
+            casm = context.assembler
+            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)
+          end
+          
+          # self
+          # Method Select
+          # it is legal. use TMPR2 for method select
+          # use TMPR3 for store self
+          context = @func.compile(context)
+          fnc = context.ret_reg
+          casm = context.assembler
+          casm.with_retry do 
+            casm.mov(FUNC_ARG_YTL[2], TMPR3)
+          end
+          context.set_reg_content(FUNC_ARG_YTL[2], @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])
+          end
+          context.end_using_reg(fnc)
+          context
+        end
       end
 
       class DummyNode
@@ -427,8 +593,8 @@ LocalVarNode
         end
 
         def find_cs_by_signature(sig)
-          @code_spaces.each do |key, val|
-            if key == sig then
+          @code_spaces.each do |csig, val|
+            if csig == sig then
               return val
             end
           end
@@ -490,8 +656,6 @@ LocalVarNode
         end
 
         def collect_info(context)
-          context.modified_local_var.push Hash.new
-          context.modified_instance_var = {}
           context.yield_node.push []
           @body.collect_info(context)
           @yield_node = context.yield_node.pop
@@ -509,8 +673,10 @@ LocalVarNode
           context.current_method_signature_node.push signode
           context = @body.collect_candidate_type(context)
           @end_nodes.each do |enode|
-            same_type(self, enode, context.to_key, context.to_key, context)
-            same_type(enode, self, context.to_key, context.to_key, context)
+            same_type(self, enode, 
+                      context.to_signature, context.to_signature, context)
+            same_type(enode, self, 
+                      context.to_signature, context.to_signature, context)
           end
           context.current_method_signature_node.pop
           context
@@ -545,6 +711,8 @@ LocalVarNode
           if context.options[:disp_signature] then
             disp_signature
           end
+
+          context.ret_node = self
           context
         end
       end
@@ -553,6 +721,13 @@ LocalVarNode
       class MethodTopNode<TopNode
         include MethodTopCodeGen
 
+        def collect_info(context)
+          context.modified_local_var.push [{}]
+          context = super
+          context.modified_local_var.pop
+          context
+        end
+
         def construct_frame_info(locals, argnum)
           locals.unshift :_self
           locals.unshift :_block
@@ -563,6 +738,13 @@ LocalVarNode
       end
 
       class BlockTopNode<MethodTopNode
+        def collect_info(context)
+          context.modified_local_var.last.push Hash.new
+          context = super
+          context.modified_local_var.last.pop
+          context
+        end
+
         include MethodTopCodeGen
       end
 
@@ -570,11 +752,25 @@ LocalVarNode
         include MethodTopCodeGen
         @@class_top_tab = {}
 
+        def self.get_class_top_node(klass)
+          @@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)
-          @nested_class_tab = {}
+          @constant_tab = {}
           @method_tab = {}
           @klass_object = klassobj
+          @klassclass = class << @klass_object; self; end
+          RubyType::define_wraped_class(@klassclass, RubyType::RubyTypeBoxed)
           unless @@class_top_tab[klassobj]
             @@class_top_tab[klassobj] = self
           end
@@ -593,7 +789,21 @@ LocalVarNode
           end
         end
 
-        attr :nested_class_tab
+        def search_method_with_super(name, klassobj = @klass_object)
+          clsnode = @@class_top_tab[klassobj]
+          if clsnode then
+            mtab = clsnode.method_tab
+            if val = mtab[name] then
+              return [val, clsnode]
+            end
+            
+            return search_method_with_super(name, klassobj.superclass)
+          end
+
+          [nil, nil]
+        end
+
+        attr :constant_tab
         attr :klass_object
 
         def construct_frame_info(locals, argnum)
@@ -603,6 +813,23 @@ LocalVarNode
           argnum += 3
           super(locals, argnum)
         end
+
+        def collect_candidate_type(context, signode, sig)
+          @type = RubyType::BaseType.from_ruby_class(@klassclass)
+          @type_list.add_type(sig, @type)
+
+          if add_cs_for_signature(sig) == nil and  
+              context.visited_top_node[self] then
+            return context
+          end
+
+          context.visited_top_node[self] = true
+          
+          context.current_method_signature_node.push signode
+          context = @body.collect_candidate_type(context)
+          context.current_method_signature_node.pop
+          context
+        end
       end
 
       class TopTopNode<ClassTopNode
@@ -762,9 +989,11 @@ LocalVarNode
             tobj = context.current_method_signature_node.last[argoff]
             if tobj then
               same_type(self, tobj, 
-                        context.to_key, context.to_key(-2), context)
+                        context.to_signature, context.to_signature(-2), 
+                        context)
               same_type(tobj, self, 
-                        context.to_key(-2), context.to_key, context)
+                        context.to_signature(-2), context.to_signature, 
+                        context)
             end
           end
           context
@@ -816,14 +1045,15 @@ LocalVarNode
         attr :modified_instance_var
 
         def collect_info(context)
-          context.modified_local_var.pop
           @modified_instance_var = context.modified_instance_var
           context
         end
 
         def collect_candidate_type(context)
-          same_type(self, @parent, context.to_key, context.to_key, context)
-          same_type(@parent, self, context.to_key, context.to_key, context)
+          same_type(self, @parent, 
+                    context.to_signature, context.to_signature, context)
+          same_type(@parent, self, 
+                    context.to_signature, context.to_signature, context)
           context
         end
 
@@ -863,9 +1093,9 @@ LocalVarNode
         def collect_candidate_type(context)
           context = @value_node.collect_candidate_type(context)
           same_type(self, @value_node, 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           same_type(@value_node, self, 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           context = @body.collect_candidate_type(context)
           context
         end
@@ -875,6 +1105,7 @@ 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
@@ -910,9 +1141,9 @@ LocalVarNode
           @local_label.come_from.values.each do |vnode|
             if vnode then
               same_type(self, vnode, 
-                        context.to_key, context.to_key, context)
+                        context.to_signature, context.to_signature, context)
               same_type(vnode, self, 
-                        context.to_key, context.to_key, context)
+                        context.to_signature, context.to_signature, context)
             end
           end
           context
@@ -950,7 +1181,7 @@ LocalVarNode
         end
 
         def collect_info(context)
-          modlocvar = context.modified_local_var.map {|ele| ele.dup}
+          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
@@ -1136,19 +1367,20 @@ LocalVarNode
           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_key, @type)
+          @type_list.add_type(context.to_signature, @type)
           case @value
           when Array
-            key = context.to_key
-            @element_node_list = [[key, BaseNode.new(self)]]
+            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(key, etype)
+              @element_node_list[0][1].add_type(sig, etype)
             end
           end
           context
@@ -1157,7 +1389,7 @@ LocalVarNode
         def compile(context)
           context = super(context)
 
-          decide_type_once(context.to_key)
+          decide_type_once(context.to_signature)
           case @value
           when Fixnum
             val = @value
@@ -1198,11 +1430,42 @@ LocalVarNode
         end
       end
 
+      class ClassValueNode<BaseNode
+        include HaveChildlenMixin
+
+        def initialize(parent, define)
+          super(parent)
+          @define = define
+        end
+
+        def traverse_childlen
+          yield @define
+          yield @body
+        end
+        
+        attr_accessor :define
+
+        def collect_candidate_type(context)
+          context = @define.collect_candidate_type(context,[], [])
+          context = @body.collect_candidate_type(context)
+          context
+        end
+
+        def compile(context)
+#          raise "Can't compile"
+          context = super(context)
+          context = @define.compile(context)
+          context = @body.compile(context)
+          context
+        end
+      end
+
       class SpecialObjectNode<BaseNode
         def initialize(parent, kind)
           super(parent)
           @kind = kind
         end
+
         
         attr :kind
 
@@ -1291,15 +1554,15 @@ LocalVarNode
 
         def method_top_node(ctop, slf)
           if slf then
-            ctop.method_tab(slf.ruby_type)[@name]
+            ctop.search_method_with_super(@name, slf.ruby_type)[0]
           else
-            ctop.method_tab[@name]
+            ctop.search_method_with_super(@name)[0]
           end
         end
 
         def calling_convention(context)
           if @send_node.is_fcall or @send_node.is_vcall then
-            mtop = @reciever.method_tab[@name]
+            mtop = @reciever.search_method_with_super(@name)[0]
             if mtop then
               @calling_convention = :ytl
             else
@@ -1307,7 +1570,8 @@ LocalVarNode
               if @reciever.klass_object then
                 addr = @reciever.klass_object.method_address_of(@name)
                 if addr then
-                  if variable_argument?(@eciever.method(@name).parameters) then
+                  recobj = @reciever.klass_object
+                  if variable_argument?(recobj.method(@name).parameters) then
                     @calling_convention = :c_vararg
                   else
                     @calling_convention = :c_fixarg
@@ -1321,15 +1585,19 @@ LocalVarNode
               end
             end
           else
-            context = @reciever.compile(context)
-            context.ret_node.decide_type_once(context.to_key)
-            rtype = context.ret_node.type
+            @reciever.decide_type_once(context.to_signature)
+            rtype = @reciever.type
             rklass = rtype.ruby_type
-            mth = rklass.instance_method(@name)
-            if variable_argument?(mth.parameters) then
-              @calling_convention = :c_vararg
+            knode = ClassTopNode.get_class_top_node(rklass)
+            if knode and knode.search_method_with_super(@name)[0] then
+              @calling_convention = :ytl
             else
-              @calling_convention = :c_fixarg
+              mth = rklass.instance_method(@name)
+              if variable_argument?(mth.parameters) then
+                @calling_convention = :c_vararg
+              else
+                @calling_convention = :c_fixarg
+              end
             end
           end
 
@@ -1343,7 +1611,7 @@ LocalVarNode
             asm.with_retry do
               asm.mov(TMPR3, 4)
             end
-            mtop = @reciever.method_tab[@name]
+            mtop = @reciever.search_method_with_super(@name)[0]
             if mtop then
               sig = @parent.signature(context)
               cs = mtop.find_cs_by_signature(sig)
@@ -1368,10 +1636,12 @@ LocalVarNode
             end
           else
             context = @reciever.compile(context)
-            context.ret_node.decide_type_once(context.to_key)
+            context.ret_node.decide_type_once(context.to_signature)
             rtype = context.ret_node.type
             context = rtype.gen_boxing(context)
             recval = context.ret_reg
+            knode = ClassTopNode.get_class_top_node(rtype.ruby_type)
+            mtop = nil
 
             if rtype.is_a?(RubyType::DefaultType0) then
               # Can't type inference. Dynamic method search
@@ -1404,7 +1674,20 @@ LocalVarNode
               context.set_reg_content(TMPR2, self)
               context.set_reg_content(TMPR3, @reciever)
               context.ret_reg = TMPR2
+
+            elsif knode and mtop = knode.search_method_with_super(@name)[0] then
+              asm = context.assembler
+              asm.with_retry do
+                asm.mov(TMPR3, recval)
+              end
+
+              sig = @parent.signature(context)
+              cs = mtop.find_cs_by_signature(sig)
+              context.ret_reg = cs.var_base_address
+
             else
+              # regident type 
+
               asm = context.assembler
               asm.with_retry do
                 asm.mov(TMPR3, recval)
@@ -1461,7 +1744,11 @@ LocalVarNode
         end
 
         def collect_info(context)
-          vti = context.modified_local_var[@depth][@offset]
+          vti = nil
+          if context.modified_local_var.last[@depth] then
+            vti = context.modified_local_var.last[@depth][@offset]
+          end
+
           if vti then
             @var_type_info = vti.dup
           else
@@ -1475,7 +1762,7 @@ LocalVarNode
         def collect_candidate_type(context)
           @var_type_info.each do |src|
             same_type(self, src, 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
           end
           context
         end
@@ -1501,17 +1788,18 @@ LocalVarNode
           offarg = @current_frame_info.offset_arg(@offset, BPR)
           context.ret_node = self
           context.ret_reg = offarg
+          context
         end
 
         def collect_candidate_type(context)
           @type = RubyType::BaseType.from_ruby_class(@classtop.klass_object)
-          @type_list.add_type(context.to_key, @type)
+          @type_list.add_type(context.to_signature, @type)
           context
         end
 
         def compile(context)
           context = super(context)
-          comile_main(context)
+          compile_main(context)
         end
       end
 
@@ -1530,14 +1818,14 @@ LocalVarNode
 
         def collect_info(context)
           context = @val.collect_info(context)
-          context.modified_local_var[@depth][@offset] = [self]
+          context.modified_local_var.last[@depth][@offset] = [self]
           @body.collect_info(context)
         end
           
         def collect_candidate_type(context)
           context = @val.collect_candidate_type(context)
           same_type(self, @val, 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           @body.collect_candidate_type(context)
         end
 
@@ -1545,9 +1833,9 @@ LocalVarNode
           context = super(context)
           context = @val.compile(context)
 
-          decide_type_once(context.to_key)
+          decide_type_once(context.to_signature)
           if @type.boxed then
-            @val.decide_type_once(context.to_key)
+            @val.decide_type_once(context.to_signature)
             rtype = @val.type
             context = rtype.gen_boxing(context)
           end
@@ -1558,7 +1846,8 @@ LocalVarNode
           offarg = @current_frame_info.offset_arg(@offset, base)
 
           asm = context.assembler
-          if valr.is_a?(OpRegistor) or valr.is_a?(OpImmidiate) then
+          if valr.is_a?(OpRegistor) or 
+              (valr.is_a?(OpImmidiate) and !valr.is_a?(OpImmidiate64)) then
             asm.with_retry do
               asm.mov(offarg, valr)
             end
@@ -1610,7 +1899,7 @@ LocalVarNode
         def collect_candidate_type(context)
           @var_type_info.each do |src|
             same_type(self, src, 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
           end
           context
         end
@@ -1647,7 +1936,7 @@ LocalVarNode
         def collect_candidate_type(context)
           context = @val.collect_candidate_type(context)
           same_type(self, @val, 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           @body.collect_candidate_type(context)
         end
 
@@ -1661,6 +1950,40 @@ LocalVarNode
         end
       end
 
+      class ConstantRefNode<VariableRefCommonNode
+        include NodeUtil
+        
+        def initialize(parent, klass, name)
+          super(parent)
+          @name = name
+          @class_top = klass # .search_class_top
+          @value_node = klass.constant_tab[@name]
+        end
+
+        attr :value_node
+
+        def collect_candidate_type(context)
+          same_type(self, @value_node,
+                    context.to_signature, context.to_signature, context)
+          context
+        end
+
+        def compile(context)
+          case @value_node
+          when ClassTopNode
+            obj = @value_node.klass_object
+            objadd = lambda { obj.address }
+            context.ret_reg  = OpVarImmidiateAddress.new(objadd)
+
+          else
+            context = @value_node.compile(context)
+          end
+          
+          context.ret_node = self
+          context 
+        end
+      end
+
       # Reference Register
       class RefRegister
       end