ytljit 0.0.2 → 0.0.3

data/lib/ytljit/vm_sendnode.rb

@@ -53,7 +53,13 @@ module YTLJit
         end
 
         def self.add_special_send_node(name)
-          @@special_node_tab[name] = self
+          oldcls = @@special_node_tab[name]
+          if oldcls == nil or self < oldcls then
+            @@special_node_tab[name] = self
+
+          else
+            raise "Illigal SendNode #{self} #{name}"
+          end
         end
 
         def self.make_send_node(parent, func, arguments, op_flag)
@@ -151,7 +157,7 @@ module YTLJit
           if is_fcall or is_vcall then
             mt = @func.method_top_node(@class_top, nil)
           else
-            @arguments[2].decide_type_once(context.to_key)
+            @arguments[2].decide_type_once(context.to_signature)
             slf = @arguments[2].type
             if slf.instance_of?(RubyType::DefaultType0) then
               # Chaos
@@ -162,8 +168,8 @@ module YTLJit
           end
           
           if mt then
-            same_type(self, mt, context.to_key, signat, context)
-            same_type(mt, self, signat, context.to_key, context)
+            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|
@@ -202,167 +208,19 @@ module YTLJit
           context.start_using_reg(TMPR2)
           context.start_using_reg(TMPR3)
           callconv = @func.calling_convention(context)
-          fnc = nil
           
           case callconv
           when :c_vararg
-            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_key)
-              context = @type.to_box.gen_unboxing(context)
-
-              context
-            end
+            context = compile_c_vararg(context)
             
           when :c_fixarg
-            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_key)
-                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_key)
-            context = @type.to_box.gen_unboxing(context)
+            context = compile_c_fixarg(context)
 
           when :ytl
-            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 = compile_ytl(context)
           end
           
-          decide_type_once(context.to_key)
+          decide_type_once(context.to_signature)
           if @type.is_a?(RubyType::RubyTypeUnboxed) and 
               @type.ruby_type == Float then
             context.ret_reg = XMM0
@@ -386,6 +244,8 @@ module YTLJit
           if arguments[4].is_a?(LiteralNode) then
             @new_method.name = arguments[4].value
             @class_top.method_tab[arguments[4].value] = @new_method
+          else
+            raise "Not supported not literal method name"
           end
         end
 
@@ -416,26 +276,142 @@ module YTLJit
         end
       end
 
-      class SendPlusNode<SendNode
-        include ArithmeticOperationUtil
-        include SendUtil
-        add_special_send_node :+
+      class SendAllocateNode<SendNode
+        add_special_send_node :allocate
+
+        def collect_candidate_type_regident(context, slf)
+          slfnode = @arguments[2]
+          if slf.ruby_type.is_a?(Class) then
+            case slfnode
+            when ConstantRefNode
+              case slfnode.value_node
+              when ClassTopNode
+                clstop = slfnode.value_node
+                tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
+                @type_list.add_type(context.to_signature, tt)
+                
+              else
+                raise "Unkown node type in constant #{slfnode.value_node.class}"
+              end
+
+            else
+              raise "Unkonwn node type #{@arguments[2].class} "
+            end
+          end
+          context
+        end
+      end
+
+      class SendInitializeNode<SendNode
+        add_special_send_node :initialize
+
+        def compile(context)
+          context.start_using_reg(TMPR2)
+          context.start_using_reg(TMPR3)
+          callconv = @func.calling_convention(context)
+          
+          case callconv
+          when :c_vararg
+            context = compile_c_vararg(context)
+            
+          when :c_fixarg
+            context = compile_c_fixarg(context)
+
+          when :ytl
+            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_node = self
+          context.end_using_reg(TMPR3)
+          context.end_using_reg(TMPR2)
+          
+          context = @body.compile(context)
+          context
+        end
+      end
+
+      class SendNewNode<SendNode
+        add_special_send_node :new
 
         def initialize(parent, func, arguments, op_flag)
           super
+          allocfunc = MethodSelectNode.new(self, :allocate)
+          alloc = SendNode.make_send_node(self, allocfunc, arguments[0, 3], 0)
+          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)
+          initfunc.set_reciever(init)
+          alloc.parent = init
+          @initmethod = init
+        end
+
+        def traverse_childlen
+          @arguments.each do |arg|
+            yield arg
+          end
+          yield @func
+          yield @initmethod
+        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
+              when ClassTopNode
+                clstop = slfnode.value_node
+                tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
+                @type_list.add_type(context.to_signature, tt)
+                
+              else
+                raise "Unkown node type in constant #{slfnode.value_node.class}"
+              end
+
+            else
+              raise "Unkonwn node type #{@arguments[2].class} "
+            end
+          end
+          context
+        end
+        
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rrtype.is_a?(Class) then
+            @initmethod.compile(context)
+          else
+            super
+          end
         end
+      end
+
+      class SendPlusNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :+
 
         def collect_candidate_type_regident(context, slf)
           case [slf.ruby_type]
-          when [Fixnum], [Float], [String]
+          when [Fixnum], [Float], [String], [Array]
             same_type(@arguments[3], @arguments[2], 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
             same_type(@arguments[2], @arguments[3], 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
             same_type(self, @arguments[2], 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
             same_type(@arguments[2], self, 
-                      context.to_key, context.to_key, context)
+                      context.to_signature, context.to_signature, context)
           end
 
           context
@@ -443,17 +419,18 @@ module YTLJit
 
 #=begin
         def compile(context)
-          @arguments[2].decide_type_once(context.to_key)
+          @arguments[2].decide_type_once(context.to_signature)
           rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
           if rtype.is_a?(RubyType::DefaultType0) or
-              @class_top.method_tab(rtype.ruby_type)[@func.name] then
+             @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
 
           context.current_method_signature.push signature(context)
-          if rtype.ruby_type == Fixnum then
+          if rrtype == Fixnum then
             context = gen_arithmetic_operation(context, :add, TMPR2, TMPR)
-          elsif rtype.ruby_type == Float then
+          elsif rrtype == Float then
             context = gen_arithmetic_operation(context, :addsd, XMM4, XMM0)
           else
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
@@ -464,32 +441,199 @@ module YTLJit
 #=end
       end
 
+      class SendMinusNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :-
+
+        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)
+          end
+
+          context
+        end
+
+        def compile(context)
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rtype.is_a?(RubyType::DefaultType0) or
+              @class_top.search_method_with_super(@func.name, rrtype)[0] then
+            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
+            context = gen_arithmetic_operation(context, :subsd, XMM4, XMM0)
+          else
+            raise "Unkown method #{rtype.ruby_type}##{@func.name}"
+          end
+
+          context.current_method_signature.pop
+          @body.compile(context)
+        end
+      end
+
+      class SendMultNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :*
+
+        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)
+
+          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)
+            @arguments[3].add_type(context.to_signature, fixtype)
+          end
+
+          context
+        end
+
+        def compile(context)
+          @arguments[2].type = nil
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rtype.is_a?(RubyType::DefaultType0) or
+             @class_top.search_method_with_super(@func.name, rrtype)[0] then
+            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)
+              end
+            end
+              
+          elsif rrtype == Float then
+            context = gen_arithmetic_operation(context, :mulsd, XMM4, XMM0)
+          else
+            raise "Unkown method #{rtype.ruby_type}##{@func.name}"
+          end
+
+          context.current_method_signature.pop
+          @body.compile(context)
+        end
+      end
+
+      class SendDivNode<SendNode
+        include ArithmeticOperationUtil
+        include SendUtil
+        add_special_send_node :/
+
+        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)
+          end
+
+          context
+        end
+
+        def compile(context)
+          @arguments[2].type = nil
+          @arguments[2].decide_type_once(context.to_signature)
+          rtype = @arguments[2].type
+          rrtype = rtype.ruby_type
+          if rtype.is_a?(RubyType::DefaultType0) or
+              @class_top.search_method_with_super(@func.name, rrtype)[0] then
+            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.cdq
+                asm.idiv(context.ret_reg)
+                asm.and(DBLHIR, DBLHIR)
+                asm.setnz(DBLHIR)
+                asm.neg(DBLHIR)
+                asm.and(DBLHIR, DBLLOR)
+                asm.setl(DBLHIR)
+                asm.sub(DBLLOR, DBLHIR)
+                context.end_using_reg(context.ret_reg)
+              end
+            end
+              
+          elsif rrtype == Float then
+            context = gen_arithmetic_operation(context, :divsd, XMM4, XMM0)
+          else
+            raise "Unkown method #{rtype.ruby_type}##{@func.name}"
+          end
+
+          context.current_method_signature.pop
+          @body.compile(context)
+        end
+      end
+
       class SendCompareNode<SendNode
         include SendUtil
         def collect_candidate_type_regident(context, slf)
           same_type(@arguments[3], @arguments[2], 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           same_type(@arguments[2], @arguments[3], 
-                    context.to_key, context.to_key, context)
+                    context.to_signature, context.to_signature, context)
           tt = RubyType::BaseType.from_ruby_class(true)
-          @type_list.add_type(context.to_key, tt)
+          @type_list.add_type(context.to_signature, tt)
           tt = RubyType::BaseType.from_ruby_class(false)
-          @type_list.add_type(context.to_key, tt)
+          @type_list.add_type(context.to_signature, tt)
 
           context
         end
 
         def compile(context)
-          @arguments[2].decide_type_once(context.to_key)
+          @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.method_tab(rtype.ruby_type)[@func.name] then
+             @class_top.search_method_with_super(@func.name, rrtype)[0] then
             return super(context)
           end
 
           context.current_method_signature.push signature(context)
           context = gen_eval_self(context)
-          if rtype.ruby_type == Fixnum then
+          if rrtype == Fixnum then
             context = compile_compare(context)
           else
             raise "Unkown method #{rtype.ruby_type} #{@func.name}"
@@ -531,29 +675,59 @@ module YTLJit
         end
       end
 
-      class SendRefNode<SendNode
+      class SendElementRefNode<SendNode
         include SendUtil
         add_special_send_node :[]
         def collect_candidate_type_regident(context, slf)
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
-            @arguments[3].add_type(context.to_key, fixtype)
-            @arguments[2].add_element_node(context.to_key, self, context)
-            key = context.to_key
-            decide_type_once(key)
-#            @arguments[2].type = nil
-#            @arguments[2].decide_type_once(context.to_key)
+            sig = context.to_signature
+            @arguments[3].add_type(sig, fixtype)
+            @arguments[2].add_element_node(sig, self, context)
+            decide_type_once(sig)
+            @arguments[2].type = nil
+            @arguments[2].decide_type_once(sig)
+            epare = @arguments[2].element_node_list[0]
+            esig = epare[0]
+            enode = epare[1]
+            if enode != self then
+              same_type(self, enode, sig, esig, context)
+              same_type(enode, self, esig, sig, context)
+            end
+
+          when [Hash]
+            @arguments[2].add_element_node(context.to_signature, self, context)
+          end
+
+          context
+        end
+      end
+
+      class SendElementAssignNode<SendNode
+        include SendUtil
+        add_special_send_node :[]=
+        def collect_candidate_type_regident(context, slf)
+          case [slf.ruby_type]
+          when [Array]
+            fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
+            sig = context.to_signature
+            val = @arguments[4]
+            @arguments[3].add_type(sig, fixtype)
+            @arguments[2].add_element_node(sig, val, context)
+            decide_type_once(sig)
+            @arguments[2].type = nil
+            @arguments[2].decide_type_once(sig)
             epare = @arguments[2].element_node_list[0]
-            ekey = epare[0]
+            esig = epare[0]
             enode = epare[1]
             if enode != self then
-              same_type(self, enode, key, ekey, context)
-              same_type(enode, self, ekey, key, context)
+              same_type(self, enode, sig, esig, context)
+              same_type(enode, self, esig, sig, context)
             end
 
           when [Hash]
-            @arguments[2].add_element_node(context.to_key, self, context)
+            @arguments[2].add_element_node(context.to_signature, self, context)
           end
 
           context