ytljit 0.0.3 → 0.0.4

data/lib/ytljit/vm_codegen.rb

@@ -77,7 +77,7 @@ LO        |                       |   |  |
       def initialize(tnode)
         @top_node = tnode
         @modified_local_var = []
-        @modified_instance_var = {}
+        @modified_instance_var = Hash.new {|hash, key| hash[key] = []}
         @yield_node = []
       end
 
@@ -103,44 +103,126 @@ LO        |                       |   |  |
 
         @modified_local_var[-1] = res
       end
-
-      def merge_instance_var(lvlist)
-        res = nil
-        lvlist.each do |lvs|
-          if res then
-            lvs.each do |name, vall|
-              res[name] = res[name] | vall
-            end
-          else
-            res = lvs.dup
-          end
-        end
-      
-        @modified_instance_var = res
-      end
     end
     
     class TypeInferenceContext
       def initialize(tnode)
         @top_node = tnode
-        @current_method_signature_node = []
+        @current_method_signature_node = [[]]
+        @current_method = [tnode]
         @convergent = false
         @visited_top_node = {}
       end
 
-      def to_signature(offset = -1)
-        cursig = @current_method_signature_node[offset]
-        res = cursig.map { |enode|
-          if enode.is_a?(Node::BaseNode) then
-            enode.decide_type_once(to_signature(offset - 1))
-            enode.type
+      def to_signature(offset = -1, cache = {})
+        if offset.is_a?(Node::TopNode) then
+          i = -1
+          while @current_method[i] and @current_method[i] != offset
+            i = i - 1
+          end
+          if @current_method[i] == offset then
+            offset = i
           else
-            enode
+            # This is legal this TopNode has only one signature 
+            sigc = offset.signature_cache
+            if sigc.size == 1 then
+              return sigc[0]
+            else
+              raise "I can't type inference..."
+            end
           end
+        end
+
+        cursignode = @current_method_signature_node[offset]
+        curmethod = @current_method[offset]
+
+        sigc = curmethod.signature_cache
+        if sigc.size == 1 then
+          return sigc[0]
+        end
+        
+        if rsig = cache[cursignode] then
+          return rsig
+        end
+
+        if curmethod.is_a?(Node::ClassTopNode) then
+          rsig = to_signature_aux(cursignode, offset, cache)
+          cache[cursignode] = rsig
+          rsig
+
+        elsif curmethod.is_a?(Node::TopNode) then
+          prevsig = to_signature(offset - 1, cache)
+          rsig = to_signature_aux2(curmethod, cursignode, 
+                                   prevsig, offset, cache)
+          cache[cursignode] = rsig
+          rsig
+          
+        else
+          raise "Maybe bug"
+=begin
+          prevsig = to_signature(offset - 1, cache)
+          mt, slf = curmethod.get_send_method_node(prevsig)
+
+          rsig = to_signature_aux2(mt, cursignode, prevsig, offset, cache)
+          cache[cursignode] = rsig
+          return rsig
+=end
+        end
+      end
+
+      def to_signature_aux(cursignode, offset, cache)
+        res = cursignode.map { |enode|
+          enode.decide_type_once(to_signature(offset - 1, cache))
         }
+        
         res
       end
 
+      def to_signature_aux2(mt, args, cursig, offset, cache)
+        res = []
+        args.each do |ele|
+          ele.decide_type_once(cursig)
+          res.push ele.type
+        end
+
+        if mt and (ynode = mt.yield_node[0]) then
+          yargs = ynode.arguments
+          push_signature(args, mt)
+          ysig = to_signature_aux3(yargs, -1, cache)
+          args[1].type = nil
+          args[1].decide_type_once(ysig)
+          res[1] = args[1].type
+          pop_signature
+        end
+        
+        res
+      end
+
+      def to_signature_aux3(cursignode, offset, cache)
+        if res = cache[cursignode] then
+          return res
+        end
+
+        res = cursignode.map { |enode|
+          cursignode = @current_method_signature_node[offset]
+          sig = to_signature_aux3(cursignode, offset - 1, cache)
+          enode.decide_type_once(sig)
+        }
+        cache[cursignode] = res
+        
+        res
+      end
+
+      def push_signature(signode, method)
+        @current_method_signature_node.push signode
+        @current_method.push method
+      end
+
+      def pop_signature
+        @current_method.pop
+        @current_method_signature_node.pop
+      end
+
       attr          :top_node
       attr          :current_method_signature_node
       attr_accessor :convergent
@@ -159,6 +241,7 @@ LO        |                       |   |  |
         
         # RETR(EAX, RAX) or RETFR(STO, XM0) or Immdiage object
         @ret_reg = RETR
+        @ret_reg2 = RETR
         @ret_node = nil
 #        @depth_reg = {}
         @depth_reg = Hash.new(0)
@@ -179,6 +262,7 @@ LO        |                       |   |  |
 
       attr          :depth_reg
       attr_accessor :ret_reg
+      attr_accessor :ret_reg2
       attr_accessor :ret_node
 
       attr          :reg_content
@@ -206,8 +290,8 @@ LO        |                       |   |  |
             cpustack_setn(dst.disp.value / wsiz, val)
           end
         else
-          p "foo"
-          p dst
+          pp "foo"
+          pp dst
         end
       end
 
@@ -336,6 +420,17 @@ LO        |                       |   |  |
       def to_signature(offset = -1)
         @current_method_signature[offset]
       end
+
+      def push_signature(signode, method)
+        sig = signode.map { |enode|
+          enode.decide_type_once(to_signature)
+        }
+        @current_method_signature.push sig
+      end
+
+      def pop_signature
+        @current_method_signature.pop
+      end
     end
 
     module Node
@@ -349,6 +444,7 @@ LO        |                       |   |  |
             # Make linkage of frame pointer
             asm.push(BPR)
             asm.mov(BPR, SPR)
+            asm.push(TMPR)
             asm.push(BPR)
             asm.mov(BPR, SPR)
           end
@@ -490,6 +586,7 @@ LO        |                       |   |  |
         casm.with_retry do 
           dmy, callpos = casm.call_with_arg(fnc, numarg)
         end
+        context.end_using_reg(fnc)
         @var_return_address = casm.output_stream.var_base_address(callpos)
         if context.options[:dump_context] then
           dump_context(context)

data/lib/ytljit/vm_cruby_obj.rb

@@ -0,0 +1,91 @@
+module YTLJit
+  module VM
+    module Node
+      class CRubyInstanceVarRefNode<InstanceVarRefNode
+        include TypeListWithoutSignature
+
+        def initialize(parent, name)
+          super
+          @current_frame_info = search_frame_info
+        end
+
+        def compile_main(context)
+          slfoff = @current_frame_info.offset_arg(2, BPR)
+          asm = context.assembler
+          ivid = ((@name.object_id << 1) / InternalRubyType::RObject.size)
+          ivarget = OpMemAddress.new(address_of("rb_ivar_get"))
+          asm.with_retry do
+            asm.mov(FUNC_ARG[0], slfoff)
+            asm.mov(FUNC_ARG[1], ivid)
+            asm.call_with_arg(ivarget, 2)
+          end
+          
+          context.ret_reg = RETR
+          context.ret_node = self
+          context
+        end
+      end
+
+      class CRubyInstanceVarAssignNode<InstanceVarAssignNode
+        include TypeListWithoutSignature
+
+        def initialize(parent, name, val)
+          super
+          @current_frame_info = search_frame_info
+        end
+
+        def compile_main(context)
+          slfoff = @current_frame_info.offset_arg(2, BPR)
+          ivid = ((@name.object_id << 1) / InternalRubyType::RObject.size)
+          ivarset = OpMemAddress.new(address_of("rb_ivar_set"))
+          context = @val.compile(context)
+          rtype = @val.decide_type_once(context.to_signature)
+          context = rtype.gen_boxing(context)
+
+          asm = context.assembler
+          asm.with_retry do
+            asm.push(TMPR2)
+            asm.mov(TMPR2, context.ret_reg)
+            asm.mov(FUNC_ARG[0], slfoff)
+            asm.mov(FUNC_ARG[1], ivid)
+            asm.mov(FUNC_ARG[2], TMPR2)
+            asm.call_with_arg(ivarset, 3)
+            asm.pop(TMPR2)
+          end
+          
+          context.ret_reg = RETR
+          context.ret_node = self
+          @body.compile(context)
+        end
+      end
+    end
+
+    module YARVTranslatorCRubyObjectMixin
+      include Node
+
+      def visit_getinstancevariable(code, ins, context)
+        curnode = context.current_node
+        node = CRubyInstanceVarRefNode.new(curnode, ins[1])
+        context.expstack.push node
+      end
+
+      def visit_setinstancevariable(code, ins, context)
+        val = context.expstack.pop
+        curnode = context.current_node
+        node = CRubyInstanceVarAssignNode.new(curnode, ins[1], val)
+        if context.expstack[-1] == val then
+          context.expstack[-1] = CRubyInstanceVarRefNode.new(curnode, ins[1])
+        end
+        curnode.body = node
+        context.current_node = node
+      end
+    end
+
+    class YARVTranslatorCRubyObject<YARVTranslatorBase
+      include YARVTranslatorSimpleMixin
+      include YARVTranslatorCRubyObjectMixin
+    end
+  end
+end
+
+      

data/lib/ytljit/vm_inline_method.rb

@@ -5,16 +5,23 @@ module YTLJit
       def gen_arithmetic_operation(context, inst, tempreg, resreg)
         context.start_using_reg(tempreg)
         context = gen_eval_self(context)
+        context.ret_node.type = nil
+        rtype = context.ret_node.decide_type_once(context.to_signature)
+        context = rtype.gen_unboxing(context)
         asm = context.assembler
-        asm.with_retry do
-            if context.ret_reg.using(tempreg) then
-              asm.mov(TMPR, context.ret_reg)
-              context.end_using_reg(context.ret_reg)
-              asm.mov(tempreg, TMPR)
-            else
-              asm.mov(tempreg, context.ret_reg)
-              context.end_using_reg(context.ret_reg)
-            end
+        if context.ret_reg.using(tempreg) then
+          asm.with_retry do
+            asm.mov(TMPR, context.ret_reg)
+          end
+          context.end_using_reg(context.ret_reg)
+          asm.with_retry do
+            asm.mov(tempreg, TMPR)
+          end
+        else
+          asm.with_retry do
+            asm.mov(tempreg, context.ret_reg)
+          end
+          context.end_using_reg(context.ret_reg)
         end
         context.set_reg_content(tempreg, context.ret_node)
         
@@ -23,8 +30,8 @@ module YTLJit
         # @arguments[3] is other
         aele = @arguments[3]
         context = aele.compile(context)
-        context.ret_node.decide_type_once(context.to_signature)
-        rtype = context.ret_node.type
+        context.ret_node.type = nil
+        rtype = context.ret_node.decide_type_once(context.to_signature)
         context = rtype.gen_unboxing(context)
           
         asm = context.assembler
@@ -53,7 +60,7 @@ module YTLJit
         decide_type_once(context.to_signature)
 
         if @type.boxed then
-          context = @type.gen_boxing(context)
+          context = @type.to_unbox.gen_boxing(context)
         end
         
         context
@@ -61,7 +68,8 @@ module YTLJit
     end
 
     module CompareOperationUtil
-      def gen_compare_operation(context, inst, tempreg, resreg)
+      def gen_compare_operation(context, cinst, sinst, 
+                                tempreg, tempreg2, resreg)
         context.start_using_reg(tempreg)
         asm = context.assembler
         asm.with_retry do
@@ -74,17 +82,17 @@ module YTLJit
         # @arguments[3] is other arg
         aele = @arguments[3]
         context = aele.compile(context)
-        context.ret_node.decide_type_once(context.to_signature)
-        rtype = context.ret_node.type
+        context.ret_node.type = nil
+        rtype = context.ret_node.decide_type_once(context.to_signature)
         context = rtype.gen_unboxing(context)
           
         asm = context.assembler
         asm.with_retry do
-          if context.ret_reg != resreg then
-            asm.mov(resreg, context.ret_reg)
+          if context.ret_reg != tempreg2 then
+            asm.mov(tempreg2, context.ret_reg)
           end
-          asm.cmp(resreg, tempreg)
-          asm.send(inst, resreg)
+          asm.send(cinst, tempreg2, tempreg)
+          asm.send(sinst, resreg)
           asm.add(resreg, resreg)
         end
         context.end_using_reg(tempreg)

data/lib/ytljit/vm_sendnode.rb

@@ -62,13 +62,13 @@ module YTLJit
           end
         end
 
-        def self.make_send_node(parent, func, arguments, op_flag)
+        def self.make_send_node(parent, func, arguments, op_flag, seqno)
           spcl = @@special_node_tab[func.name]
           newobj = nil
           if spcl then
-            newobj = spcl.new(parent, func, arguments, op_flag)
+            newobj = spcl.new(parent, func, arguments, op_flag, seqno)
           else
-            newobj = self.new(parent, func, arguments, op_flag)
+            newobj = self.new(parent, func, arguments, op_flag, seqno)
           end
           func.parent = newobj
           arguments.each do |ele|
@@ -78,11 +78,12 @@ module YTLJit
           newobj
         end
 
-        def initialize(parent, func, arguments, op_flag)
+        def initialize(parent, func, arguments, op_flag, seqno)
           super(parent)
           @func = func
           @arguments = arguments
           @opt_flag = op_flag
+          @seq_no = seqno
           @var_return_address = nil
           @next_node = @@current_node
           @@current_node = self
@@ -92,6 +93,9 @@ module YTLJit
 
           @modified_instance_var = nil
           @modified_local_var = [{}]
+
+          @result_cache = nil
+          @method_signature = []
         end
 
         attr_accessor :func
@@ -100,27 +104,58 @@ module YTLJit
         attr          :var_return_address
         attr          :next_node
         attr          :class_top
+        attr          :frame_info
         attr          :modified_local_var
         attr          :modified_instance_var
+        attr_accessor :result_cache
+        attr          :seq_no
 
         def traverse_childlen
           @arguments.each do |arg|
             yield arg
           end
           yield @func
+          yield @body
+        end
+
+        def get_send_method_node(cursig)
+          mt = nil
+          @arguments[2].decide_type_once(cursig)
+          slf = @arguments[2].type
+          if slf.instance_of?(RubyType::DefaultType0) then
+            # Chaos
+          end
+
+          if is_fcall or is_vcall then
+            mt = @func.method_top_node(@class_top, nil)
+
+          else
+
+            mt = @func.method_top_node(@class_top, slf)
+          end
+
+          [mt, slf]
         end
 
         def collect_candidate_type_regident(context, slf)
           context
         end
 
+        # This is for reduce method call whose all arguments is constant.
+        # But all methods can't apply because the method may have side
+        # effect.
+        def fill_result_cache(context)
+          context
+        end
+
         def collect_info(context)
-          traverse_childlen {|rec|
-            context = rec.collect_info(context)
-          }
+          @arguments.each do |arg|
+            context = arg.collect_info(context)
+          end
+          context = @func.collect_info(context)
           if is_fcall or is_vcall then
             # Call method of same class
-            mt = @class_top.method_tab[@func.name]
+            mt = @class_top.get_method_tab[@func.name]
             if mt then
               miv = mt.modified_instance_var
               if miv then
@@ -131,13 +166,59 @@ module YTLJit
             end
           end
 
-          @modified_local_var    = context.modified_local_var.dup
+          @modified_local_var    = context.modified_local_var.last.dup
           @modified_instance_var = context.modified_instance_var.dup
 
+          context = fill_result_cache(context)
+
           @body.collect_info(context)
         end
 
+        def search_signature(cursig)
+          metsigent = nil
+          @method_signature.each do |tabent|
+            if cursig == tabent[0] then
+              metsigent = tabent
+            end
+          end
+          metsigent
+        end
+
+        def check_signature_changed(context, signat, metsigent, cursig)
+          if metsigent then
+            if metsigent[1][1] != signat[1] then
+              if metsigent[1][1].ruby_type < signat[1].ruby_type then
+                signat[1] = metsigent[1][1]
+                false
+              else
+                type_list(cursig)[1] = []
+                ti_reset
+                ti_del_link
+                context.convergent = false
+                metsigent[1] = signat
+                true
+              end
+            else
+              false
+            end
+          else
+            # Why not push, because it excepted type inference about
+            # this signature after. So reduce search loop.
+            @method_signature.unshift [cursig, signat]
+            false
+          end
+        end
+
         def collect_candidate_type(context)
+          cursig = context.to_signature
+
+          # get saved original signature
+          metsigent = search_signature(cursig)
+          oldsignat = nil
+          if metsigent then
+            oldsignat = metsigent[1]
+          end
+
           # prev env
           context = @arguments[0].collect_candidate_type(context)
 
@@ -153,48 +234,32 @@ module YTLJit
           context = @func.collect_candidate_type(context)
 
           signat = signature(context)
-          mt = nil
-          if is_fcall or is_vcall then
-            mt = @func.method_top_node(@class_top, nil)
-          else
-            @arguments[2].decide_type_once(context.to_signature)
-            slf = @arguments[2].type
-            if slf.instance_of?(RubyType::DefaultType0) then
-              # Chaos
+          check_signature_changed(context, signat, metsigent, cursig)
 
-            else
-              mt = @func.method_top_node(@class_top, slf)
-            end
-          end
-          
+          mt, slf = get_send_method_node(cursig)
           if mt then
-            same_type(self, mt, context.to_signature, signat, context)
-            same_type(mt, self, signat, context.to_signature, context)
-
-            context.current_method_signature_node.push @arguments
-            mt.yield_node.map do |ynode|
-              yargs = ynode.arguments
-              ysignat = ynode.signature(context)
-              same_type(blknode, ynode, ysignat, signat, context)
-              same_type(ynode, blknode, signat, ysignat, context)
-            end
-            context.current_method_signature_node.pop
+            same_type(self, mt, cursig, signat, context)
+            same_type(mt, self, signat, cursig, context)
 
             context = mt.collect_candidate_type(context, @arguments, signat)
 
-            context.current_method_signature_node.push @arguments
-            mt.yield_node.map do |ynode|
-              yargs = ynode.arguments
-              ysignat = ynode.signature(context)
-              if blknode.is_a?(TopNode) then
-                # Have block
+            context.push_signature(@arguments, mt)
+            if blknode.is_a?(TopNode) then
+              # Have block
+              mt.yield_node.map do |ynode|
+                yargs = ynode.arguments
+                ysignat = ynode.signature(context)
+
+                same_type(ynode, blknode, signat, ysignat, context)
                 context = blknode.collect_candidate_type(context, 
                                                          yargs, ysignat)
-              else
-                context = blknode.collect_candidate_type(context)
+
               end
+            else
+              context = blknode.collect_candidate_type(context)
             end
-            context.current_method_signature_node.pop
+            context.pop_signature
+            
           else
             context = collect_candidate_type_regident(context, slf)
           end
@@ -234,33 +299,93 @@ module YTLJit
           context = @body.compile(context)
           context
         end
+
+        def get_constant_value
+          if @result_cache then
+            [@result_cache]
+          else
+            nil
+          end
+        end
       end
 
       class SendCoreDefineMethodNode<SendNode
         add_special_send_node :"core#define_method"
-        def initialize(parent, func, arguments, op_flag)
+        def initialize(parent, func, arguments, op_flag, seqno)
+          super
+          @new_method = arguments[5]
+          if arguments[4].is_a?(LiteralNode) then
+            @new_method.name = arguments[4].value
+            @class_top.get_method_tab[arguments[4].value] = @new_method
+          else
+            raise "Not supported not literal method name"
+          end
+        end
+
+        def traverse_childlen
+          yield @body
+          yield @new_method
+        end
+
+        def collect_info(context)
+          context = @new_method.collect_info(context)
+          @body.collect_info(context)
+        end
+
+        def collect_candidate_type(context)
+          # type inference of @new method execute when "send" instruction.
+          @body.collect_candidate_type(context)
+          context
+        end
+
+        def compile(context)
+          context = @body.compile(context)
+          ocs = context.code_space
+          # Allocate new code space in compiling @new_method
+          context = @new_method.compile(context)
+          context.set_code_space(ocs)
+
+          context.ret_reg = 4   # nil
+          context.ret_node = self
+
+          context
+        end
+      end
+
+      class SendCoreDefineSigletonMethodNode<SendNode
+        add_special_send_node :"core#define_singleton_method"
+
+        def initialize(parent, func, arguments, op_flag, seqno)
           super
           @new_method = arguments[5]
           if arguments[4].is_a?(LiteralNode) then
             @new_method.name = arguments[4].value
-            @class_top.method_tab[arguments[4].value] = @new_method
+            @class_top.make_klassclass_node
           else
             raise "Not supported not literal method name"
           end
         end
 
         def traverse_childlen
+          yield @arguments[3]
           yield @body
           yield @new_method
         end
 
         def collect_info(context)
+          context = @arguments[3].collect_info(context)
           context = @new_method.collect_info(context)
           @body.collect_info(context)
         end
 
         def collect_candidate_type(context)
           # type inference of @new method execute when "send" instruction.
+          context = @arguments[3].collect_candidate_type(context)
+          @arguments[3].decide_type_once(context.to_signature)
+          rrtype = class << @arguments[3].type.ruby_type; self; end
+          clsnode = ClassTopNode.get_class_top_node(rrtype)
+          clsnode.get_method_tab[@new_method.name] = @new_method
+
           @body.collect_candidate_type(context)
           context
         end
@@ -284,12 +409,14 @@ module YTLJit
           if slf.ruby_type.is_a?(Class) then
             case slfnode
             when ConstantRefNode
-              case slfnode.value_node
+              clstop = slfnode.value_node
+              case clstop
               when ClassTopNode
-                clstop = slfnode.value_node
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                @type_list.add_type(context.to_signature, tt)
-                
+                add_type(context.to_signature, tt)
+              when LiteralNode
+                tt = RubyType::BaseType.from_ruby_class(clstop.value)
+                add_type(context.to_signature, tt)
               else
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
               end
@@ -321,12 +448,7 @@ module YTLJit
             context = compile_ytl(context)
           end
 
-          decide_type_once(context.to_signature)
-          asm = context.assembler
-          asm.with_retry do
-            asm.mov(RETR, TMPR3)
-          end
-          context.ret_reg = RETR
+          context.ret_reg = RETR 
           context.ret_node = self
           context.end_using_reg(TMPR3)
           context.end_using_reg(TMPR2)
@@ -339,15 +461,17 @@ module YTLJit
       class SendNewNode<SendNode
         add_special_send_node :new
 
-        def initialize(parent, func, arguments, op_flag)
+        def initialize(parent, func, arguments, op_flag, seqno)
           super
           allocfunc = MethodSelectNode.new(self, :allocate)
-          alloc = SendNode.make_send_node(self, allocfunc, arguments[0, 3], 0)
+          alloc = SendNode.make_send_node(self, allocfunc, 
+                                          arguments[0, 3], 0, seqno)
           allocfunc.set_reciever(alloc)
           initfunc = MethodSelectNode.new(self, :initialize)
           initarg = arguments.dup
           initarg[2] = alloc
-          init = SendNode.make_send_node(self, initfunc, initarg, op_flag)
+          init = SendNode.make_send_node(self, initfunc, 
+                                         initarg, op_flag, seqno)
           initfunc.set_reciever(init)
           alloc.parent = init
           @initmethod = init
@@ -359,20 +483,26 @@ module YTLJit
           end
           yield @func
           yield @initmethod
+          yield @body
         end
 
         def collect_candidate_type_regident(context, slf)
           slfnode = @arguments[2]
+
           if slf.ruby_type.is_a?(Class) then
             case slfnode
             when ConstantRefNode
               context = @initmethod.collect_candidate_type(context)
-              case slfnode.value_node
+              clstop = slfnode.value_node
+              case clstop
               when ClassTopNode
-                clstop = slfnode.value_node
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                @type_list.add_type(context.to_signature, tt)
+                add_type(context.to_signature, tt)
                 
+              when LiteralNode
+                tt = RubyType::BaseType.from_ruby_class(clstop.value)
+                add_type(context.to_signature, tt)
+
               else
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
               end
@@ -389,7 +519,8 @@ module YTLJit
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
           if rrtype.is_a?(Class) then
-            @initmethod.compile(context)
+            context = @initmethod.compile(context)
+            @body.compile(context)
           else
             super
           end
@@ -404,14 +535,11 @@ module YTLJit
         def collect_candidate_type_regident(context, slf)
           case [slf.ruby_type]
           when [Fixnum], [Float], [String], [Array]
-            same_type(@arguments[3], @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], @arguments[3], 
-                      context.to_signature, context.to_signature, context)
-            same_type(self, @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], self, 
-                      context.to_signature, context.to_signature, context)
+            cursig = context.to_signature
+            same_type(@arguments[3], @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], @arguments[3], cursig, cursig, context)
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], self, cursig, cursig, context)
           end
 
           context
@@ -427,7 +555,6 @@ module YTLJit
             return super(context)
           end
 
-          context.current_method_signature.push signature(context)
           if rrtype == Fixnum then
             context = gen_arithmetic_operation(context, :add, TMPR2, TMPR)
           elsif rrtype == Float then
@@ -435,7 +562,7 @@ module YTLJit
           else
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
-          context.current_method_signature.pop
+
           @body.compile(context)
         end
 #=end
@@ -449,14 +576,11 @@ module YTLJit
         def collect_candidate_type_regident(context, slf)
           case [slf.ruby_type]
           when [Fixnum], [Float], [Array]
-            same_type(@arguments[3], @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], @arguments[3], 
-                      context.to_signature, context.to_signature, context)
-            same_type(self, @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], self, 
-                      context.to_signature, context.to_signature, context)
+            cursig = context.to_signature
+            same_type(@arguments[3], @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], @arguments[3], cursig, cursig, context)
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], self, cursig, cursig, context)
           end
 
           context
@@ -471,7 +595,6 @@ module YTLJit
             return super(context)
           end
 
-          context.current_method_signature.push signature(context)
           if rrtype == Fixnum then
             context = gen_arithmetic_operation(context, :sub, TMPR2, TMPR)
           elsif rrtype == Float then
@@ -480,7 +603,6 @@ module YTLJit
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
 
-          context.current_method_signature.pop
           @body.compile(context)
         end
       end
@@ -491,22 +613,17 @@ module YTLJit
         add_special_send_node :*
 
         def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
           case [slf.ruby_type]
           when [Fixnum], [Float]
-            same_type(@arguments[3], @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], @arguments[3], 
-                      context.to_signature, context.to_signature, context)
-            same_type(self, @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], self, 
-                      context.to_signature, context.to_signature, context)
+            same_type(@arguments[3], @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], @arguments[3], cursig, cursig, context)
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], self, cursig, cursig, context)
 
           when [String]
-            same_type(self, @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], self, 
-                      context.to_signature, context.to_signature, context)
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], self, cursig, cursig, context)
             @arguments[3].add_type(context.to_signature, fixtype)
           end
 
@@ -523,16 +640,24 @@ module YTLJit
             return super(context)
           end
 
-          context.current_method_signature.push signature(context)
           if rrtype == Fixnum then
             context = gen_arithmetic_operation(context, :imul, TMPR2, 
                                                TMPR) do |context|
               asm = context.assembler
-              asm.with_retry do
-                asm.mov(DBLLOR, TMPR2)
-                asm.imul(context.ret_reg)
-                context.end_using_reg(context.ret_reg)
+              if context.ret_reg.is_a?(OpRegistor) then
+                asm.with_retry do
+                  asm.push(context.ret_reg)
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.imul(INDIRECT_SPR)
+                  asm.add(SPR, AsmType::MACHINE_WORD.size)
+                end
+              else
+                asm.with_retry do
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.imul(context.ret_reg)
+                end
               end
+              context.end_using_reg(context.ret_reg)
             end
               
           elsif rrtype == Float then
@@ -541,7 +666,6 @@ module YTLJit
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
 
-          context.current_method_signature.pop
           @body.compile(context)
         end
       end
@@ -554,14 +678,11 @@ module YTLJit
         def collect_candidate_type_regident(context, slf)
           case [slf.ruby_type]
           when [Fixnum], [Float]
-            same_type(@arguments[3], @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], @arguments[3], 
-                      context.to_signature, context.to_signature, context)
-            same_type(self, @arguments[2], 
-                      context.to_signature, context.to_signature, context)
-            same_type(@arguments[2], self, 
-                      context.to_signature, context.to_signature, context)
+            cursig = context.to_signature
+            same_type(@arguments[3], @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], @arguments[3], cursig, cursig, context)
+            same_type(self, @arguments[2], cursig, cursig, context)
+            same_type(@arguments[2], self, cursig, cursig, context)
           end
 
           context
@@ -577,15 +698,22 @@ module YTLJit
             return super(context)
           end
 
-          context.current_method_signature.push signature(context)
           if rrtype == Fixnum then
-            context = gen_arithmetic_operation(context, :imul, TMPR2, 
+            context = gen_arithmetic_operation(context, nil, TMPR2, 
                                                TMPR) do |context|
               asm = context.assembler
               asm.with_retry do
-                asm.mov(DBLLOR, TMPR2)
-                asm.cdq
-                asm.idiv(context.ret_reg)
+                if context.ret_reg == TMPR then
+                  asm.push(TMPR)
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.cdq
+                  asm.idiv(INDIRECT_SPR)
+                  asm.add(SPR, AsmType::MACHINE_WORD.size)
+                else
+                  asm.mov(DBLLOR, TMPR2)
+                  asm.cdq
+                  asm.idiv(context.ret_reg)
+                end
                 asm.and(DBLHIR, DBLHIR)
                 asm.setnz(DBLHIR)
                 asm.neg(DBLHIR)
@@ -602,22 +730,36 @@ module YTLJit
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
 
-          context.current_method_signature.pop
           @body.compile(context)
         end
       end
 
       class SendCompareNode<SendNode
         include SendUtil
+        include CompareOperationUtil
         def collect_candidate_type_regident(context, slf)
-          same_type(@arguments[3], @arguments[2], 
-                    context.to_signature, context.to_signature, context)
-          same_type(@arguments[2], @arguments[3], 
-                    context.to_signature, context.to_signature, context)
-          tt = RubyType::BaseType.from_ruby_class(true)
-          @type_list.add_type(context.to_signature, tt)
-          tt = RubyType::BaseType.from_ruby_class(false)
-          @type_list.add_type(context.to_signature, tt)
+          cursig = context.to_signature
+          same_type(@arguments[3], @arguments[2], cursig, cursig, context)
+          same_type(@arguments[2], @arguments[3], cursig, cursig, context)
+          tt = RubyType::BaseType.from_object(true)
+          add_type(cursig, tt)
+          tt = RubyType::BaseType.from_object(false)
+          add_type(cursig, tt)
+
+          context
+        end
+
+        def commmon_compile_compare(context, rtype, fixcmp, flocmp)
+          rrtype = rtype.ruby_type
+          if rrtype == Fixnum then
+            context = gen_compare_operation(context, :cmp, fixcmp, 
+                                            TMPR2, TMPR, RETR)
+          elsif rrtype == Float then
+            context = gen_compare_operation(context, :comisd, flocmp, 
+                                            XMM4, XMM0, RETR)
+          else
+            raise "Unkowwn type #{rtype}"
+          end
 
           context
         end
@@ -631,47 +773,49 @@ module YTLJit
             return super(context)
           end
 
-          context.current_method_signature.push signature(context)
           context = gen_eval_self(context)
+          context.ret_node.type = nil
+          srtype = context.ret_node.decide_type_once(context.to_signature)
+          context = srtype.gen_unboxing(context)
           if rrtype == Fixnum then
-            context = compile_compare(context)
+            context = compile_compare(context, rtype)
+
+          elsif rrtype == Float then
+            context = compile_compare(context, rtype)
+
           else
             raise "Unkown method #{rtype.ruby_type} #{@func.name}"
           end
-          context.current_method_signature.pop
+
           @body.compile(context)
         end
       end
 
       class SendGtNode<SendCompareNode
-        include CompareOperationUtil
         add_special_send_node :<
-        def compile_compare(context)
-          context = gen_compare_operation(context , :setg, TMPR2, TMPR)
+        def compile_compare(context, rtype)
+          commmon_compile_compare(context, rtype, :setg, :seta)
         end
       end
 
       class SendGeNode<SendCompareNode
-        include CompareOperationUtil
         add_special_send_node :<=
-        def compile_compare(context)
-          context = gen_compare_operation(context , :setge, TMPR2, TMPR)
+        def compile_compare(context, rtype)
+          commmon_compile_compare(context, rtype, :setge, :setae)
         end
       end
 
       class SendLtNode<SendCompareNode
-        include CompareOperationUtil
         add_special_send_node :>
-        def compile_compare(context)
-          context = gen_compare_operation(context , :setl, TMPR2, TMPR)
+        def compile_compare(context, rtype)
+          commmon_compile_compare(context, rtype, :setl, :setb)
         end
       end
 
       class SendLeNode<SendCompareNode
-        include CompareOperationUtil
         add_special_send_node :>=
-        def compile_compare(context)
-          context = gen_compare_operation(context , :setle, TMPR2, TMPR)
+        def compile_compare(context, rtype)
+          commmon_compile_compare(context, rtype, :setle, :setbe)
         end
       end
 
@@ -698,6 +842,9 @@ module YTLJit
 
           when [Hash]
             @arguments[2].add_element_node(context.to_signature, self, context)
+
+          else
+            raise "Unkown type #{slf.ruby_type} in :[]"
           end
 
           context
@@ -733,6 +880,139 @@ module YTLJit
           context
         end
       end
+
+      class SendToFNode<SendNode
+        add_special_send_node :to_f
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          floattype = RubyType::BaseType.from_ruby_class(Float)
+          floattype = floattype.to_box
+          add_type(sig, floattype)
+          context
+        end
+      end
+
+      class SendToINode<SendNode
+        add_special_send_node :to_i
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          fixnumtype = RubyType::BaseType.from_ruby_class(Fixnum)
+          fixnumtype = fixnumtype.to_box
+          add_type(sig, fixnumtype)
+          context
+        end
+      end
+
+      class SendAMNode<SendNode
+        add_special_send_node :-@
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          same_type(self, @arguments[2], sig, sig, context)
+          context
+        end
+      end
+
+      class SendRandNode<SendNode
+        add_special_send_node :rand
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          floattype = RubyType::BaseType.from_ruby_class(Float)
+          add_type(sig, floattype)
+          context
+        end
+      end
+
+      class SendSameArgTypeNode<SendNode
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          same_type(self, @arguments[3], sig, sig, context)
+          context
+        end
+      end
+
+      class SendPNode<SendSameArgTypeNode
+        add_special_send_node :p
+      end
+
+      class SendMathFuncNode<SendNode
+        include SendUtil
+        def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
+          floattype = RubyType::BaseType.from_ruby_class(Float)
+          add_type(sig, floattype)
+          context
+        end
+
+        def compile_call_func(context, fname)
+          fadd = address_of(fname)
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(FUNC_FLOAT_ARG[0], context.ret_reg)
+            asm.call_with_arg(fadd, 1)
+            asm.sub(SPR, 8)
+            asm.fstpl(INDIRECT_SPR)
+            asm.pop(XMM0)
+          end
+          context
+        end
+
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rtype.ruby_type.is_a?(RubyType::DefaultType0) or
+             @class_top.search_method_with_super(@func.name, rrtype)[0] then
+            return super(context)
+          end
+
+          @arguments[3].decide_type_once(context.to_signature)
+          rtype = @arguments[3].type
+          rrtype = rtype.ruby_type
+          context = @arguments[3].compile(context)
+          context = rtype.gen_unboxing(context)
+          compile_main(context)
+        end
+      end
+      
+      class SendSqrtNode < SendMathFuncNode
+        add_special_send_node :sqrt
+        def compile_main(context)
+          context = compile_call_func(context, "sqrt")
+          context.ret_node = self
+          context.ret_reg = XMM0
+          context
+        end
+      end
+
+      class SendSinNode < SendMathFuncNode
+        add_special_send_node :sin
+        def compile_main(context)
+          context = compile_call_func(context, "sin")
+          context.ret_node = self
+          context.ret_reg = XMM0
+          context
+        end
+      end
+
+      class SendCosNode < SendMathFuncNode
+        add_special_send_node :cos
+        def compile_main(context)
+          context = compile_call_func(context, "cos")
+          context.ret_node = self
+          context.ret_reg = XMM0
+          context
+        end
+      end
+
+      class SendTanNode < SendMathFuncNode
+        add_special_send_node :tan
+        def compile_main(context)
+          context = compile_call_func(context, "tan")
+          context.ret_node = self
+          context.ret_reg = XMM0
+          context
+        end
+      end
     end
   end
 end