ytljit 0.0.5 → 0.0.6

data/lib/ytljit/vm_sendnode.rb

@@ -47,11 +47,16 @@ module YTLJit
 
         @@current_node = nil
         @@special_node_tab = {}
+        @@macro_tab = {}
         
         def self.node
           @@current_node
         end
 
+        def self.get_macro_tab
+          @@macro_tab
+        end
+
         def self.add_special_send_node(name)
           oldcls = @@special_node_tab[name]
           if oldcls == nil or self < oldcls then
@@ -63,6 +68,15 @@ module YTLJit
         end
 
         def self.make_send_node(parent, func, arguments, op_flag, seqno)
+          if mproc = @@macro_tab[func.name] then
+            args = []
+            arguments[3..-1].each do |ele|
+              args.push eval(ele.to_ruby(ToRubyContext.new).ret_code.last)
+            end
+            res = mproc.call(*args)
+            return res
+          end
+
           spcl = @@special_node_tab[func.name]
           newobj = nil
           if spcl then
@@ -84,7 +98,6 @@ module YTLJit
           @arguments = arguments
           @opt_flag = op_flag
           @seq_no = seqno
-          @var_return_address = nil
           @next_node = @@current_node
           @@current_node = self
 
@@ -101,7 +114,6 @@ module YTLJit
         attr_accessor :func
         attr_accessor :arguments
         attr          :opt_flag
-        attr          :var_return_address
         attr          :next_node
         attr          :class_top
         attr          :frame_info
@@ -271,7 +283,7 @@ module YTLJit
           context = super(context)
 
           context.start_using_reg(TMPR2)
-          context.start_using_reg(TMPR3)
+          context.start_using_reg(PTMPR)
           callconv = @func.calling_convention(context)
           
           case callconv
@@ -281,8 +293,14 @@ module YTLJit
           when :c_fixarg
             context = compile_c_fixarg(context)
 
+          when :c_fixarg_raw
+            context = compile_c_fixarg_raw(context)
+
           when :ytl
             context = compile_ytl(context)
+
+          else
+            raise "Unsupported calling conversion #{callconv}"
           end
           
           decide_type_once(context.to_signature)
@@ -293,7 +311,7 @@ module YTLJit
             context.ret_reg = RETR
           end
           context.ret_node = self
-          context.end_using_reg(TMPR3)
+          context.end_using_reg(PTMPR)
           context.end_using_reg(TMPR2)
           
           context = @body.compile(context)
@@ -382,12 +400,11 @@ module YTLJit
           # 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
+          rrtype = ClassClassWrapper.instance(@arguments[3].type.ruby_type)
           clsnode = ClassTopNode.get_class_top_node(rrtype)
           clsnode.get_method_tab[@new_method.name] = @new_method
 
           @body.collect_candidate_type(context)
-          context
         end
 
         def compile(context)
@@ -397,9 +414,16 @@ module YTLJit
           context = @new_method.compile(context)
           context.set_code_space(ocs)
 
+          context.ret_reg = 4   # nil
+          context.ret_node = self
+
           context
         end
       end
+      
+      class SendEvalNode<SendNode
+        add_special_send_node :eval
+      end
 
       class SendAllocateNode<SendNode
         add_special_send_node :allocate
@@ -434,7 +458,7 @@ module YTLJit
 
         def compile(context)
           context.start_using_reg(TMPR2)
-          context.start_using_reg(TMPR3)
+          context.start_using_reg(PTMPR)
           callconv = @func.calling_convention(context)
           
           case callconv
@@ -446,11 +470,19 @@ module YTLJit
 
           when :ytl
             context = compile_ytl(context)
+
+          else
+            raise "Unsupported calling conversion #{callconv}"
+          end
+
+          asm = context.assembler
+          asm.with_retry do
+            asm.mov(RETR, PTMPR)
           end
 
-          context.ret_reg = RETR 
+          context.ret_reg = RETR
           context.ret_node = self
-          context.end_using_reg(TMPR3)
+          context.end_using_reg(PTMPR)
           context.end_using_reg(TMPR2)
           
           context = @body.compile(context)
@@ -475,6 +507,13 @@ module YTLJit
           initfunc.set_reciever(init)
           alloc.parent = init
           @initmethod = init
+          @allocmethod = alloc
+        end
+
+        def debug_info=(val)
+          @initmethod.debug_info = val
+          @allocmethod.debug_info = val
+          @debug_info = val
         end
 
         def traverse_childlen
@@ -494,19 +533,32 @@ module YTLJit
             when ConstantRefNode
               context = @initmethod.collect_candidate_type(context)
               clstop = slfnode.value_node
+              tt = nil
+              sig = context.to_signature
               case clstop
               when ClassTopNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.klass_object)
-                add_type(context.to_signature, tt)
+                add_type(sig, tt)
                 
               when LiteralNode
                 tt = RubyType::BaseType.from_ruby_class(clstop.value)
-                add_type(context.to_signature, tt)
+                add_type(sig, tt)
 
               else
                 raise "Unkown node type in constant #{slfnode.value_node.class}"
               end
 
+              # set element type
+              if tt.ruby_type == Range then
+                tt.args = @arguments[3..-1]
+                add_element_node(sig, @arguments[3], [0], context)
+              end
+
+              if tt.ruby_type == Array then
+                @arguments[3..-1].each_with_index do |anode, idx|
+                  add_element_node(sig, anode, [idx - 3], context)
+                end
+              end
             else
               raise "Unkonwn node type #{@arguments[2].class} "
             end
@@ -519,7 +571,37 @@ module YTLJit
           rtype = @arguments[2].type
           rrtype = rtype.ruby_type
           if rrtype.is_a?(Class) then
-            context = @initmethod.compile(context)
+            if !@is_escape and rrtype.to_s == '#<Class:Range>' then
+              context = gen_alloca(context, 3)
+              asm = context.assembler
+              breg = context.ret_reg
+
+              off = 0
+              [3, 4, 5].each do |no|
+                context = @arguments[no].compile(context)
+                dst = OpIndirect.new(breg, off)
+                asm.with_retry do
+                  if context.ret_reg.is_a?(OpRegistor) then
+                    asm.mov(dst, context.ret_reg)
+                  else
+                    asm.mov(TMPR, context.ret_reg)
+                    asm.mov(dst, TMPR)
+                  end
+                end
+                off = off + AsmType::MACHINE_WORD.size
+              end
+              
+              context.ret_reg = breg
+              context.ret_node = self
+              context
+
+            elsif @initmethod.func.calling_convention(context) then
+              context = @initmethod.compile(context)
+
+            else
+              # initialize method not defined
+              context = @allocmethod.compile(context)
+            end
             @body.compile(context)
           else
             super
@@ -536,8 +618,6 @@ module YTLJit
           case [slf.ruby_type]
           when [Fixnum], [Float], [String], [Array]
             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
@@ -577,8 +657,6 @@ module YTLJit
           case [slf.ruby_type]
           when [Fixnum], [Float], [Array]
             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
@@ -600,6 +678,7 @@ module YTLJit
           elsif rrtype == Float then
             context = gen_arithmetic_operation(context, :subsd, XMM4, XMM0)
           else
+            p debug_info
             raise "Unkown method #{rtype.ruby_type}##{@func.name}"
           end
 
@@ -616,8 +695,6 @@ module YTLJit
           cursig = context.to_signature
           case [slf.ruby_type]
           when [Fixnum], [Float]
-            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)
 
@@ -651,6 +728,14 @@ module YTLJit
                   asm.imul(INDIRECT_SPR)
                   asm.add(SPR, AsmType::MACHINE_WORD.size)
                 end
+              elsif context.ret_reg.is_a?(OpImmidiateMachineWord) then
+                asm.with_retry do
+                  asm.mov(TMPR, context.ret_reg)
+                  asm.push(TMPR)
+                  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)
@@ -679,8 +764,6 @@ module YTLJit
           case [slf.ruby_type]
           when [Fixnum], [Float]
             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
@@ -709,6 +792,13 @@ module YTLJit
                   asm.cdq
                   asm.idiv(INDIRECT_SPR)
                   asm.add(SPR, AsmType::MACHINE_WORD.size)
+                elsif context.ret_reg.is_a?(OpImmidiateMachineWord) then
+                  asm.mov(TMPR, context.ret_reg)
+                  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
@@ -823,28 +913,32 @@ module YTLJit
         include SendUtil
         add_special_send_node :[]
         def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
           case [slf.ruby_type]
           when [Array]
             fixtype = RubyType::BaseType.from_ruby_class(Fixnum)
-            sig = context.to_signature
             @arguments[3].add_type(sig, fixtype)
-            @arguments[2].add_element_node(sig, self, context)
+            cidx = @arguments[3].get_constant_value
+            @arguments[2].add_element_node(sig, self, cidx, context)
             decide_type_once(sig)
             @arguments[2].type = nil
             @arguments[2].decide_type_once(sig)
             epare = @arguments[2].element_node_list[0]
+            @arguments[2].element_node_list.each do |ele|
+              if ele[2] == cidx and ele[1] != self then
+                epare = ele
+                break
+              end
+            end
             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)
-
-          else
-            raise "Unkown type #{slf.ruby_type} in :[]"
+            cidx = @arguments[3].get_constant_value
+            @arguments[2].add_element_node(sig, self, cidx, context)
           end
 
           context
@@ -855,13 +949,14 @@ module YTLJit
         include SendUtil
         add_special_send_node :[]=
         def collect_candidate_type_regident(context, slf)
+          sig = context.to_signature
           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)
+            cidx = @arguments[3].get_constant_value
+            @arguments[2].add_element_node(sig, val, cidx, context)
             decide_type_once(sig)
             @arguments[2].type = nil
             @arguments[2].decide_type_once(sig)
@@ -874,7 +969,8 @@ module YTLJit
             end
 
           when [Hash]
-            @arguments[2].add_element_node(context.to_signature, self, context)
+            cidx = @arguments[3].get_constant_value
+            @arguments[2].add_element_node(sig, self, cidx, context)
           end
 
           context
@@ -886,7 +982,6 @@ module YTLJit
         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
@@ -897,7 +992,6 @@ module YTLJit
         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
@@ -910,6 +1004,39 @@ module YTLJit
           same_type(self, @arguments[2], sig, sig, context)
           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 = gen_eval_self(context)
+          context = rtype.gen_unboxing(context)
+          asm = context.assembler
+          if rrtype == Fixnum then
+            asm.with_retry do
+              asm.mov(RETR, context.ret_reg)
+              asm.neg(RETR)
+            end
+            context.ret_reg = RETR
+          elsif rrtype == Float then
+            context.start_using_reg(XMM4)
+            asm.with_retry do
+              asm.mov(XMM4, context.ret_reg)
+              asm.subsd(XMM0, XMM0)
+              asm.subsd(XMM0, XMM4)
+            end
+            context.ret_reg = XMM0
+            context.end_using_reg(XMM4)
+          end
+          context.ret_node = self
+
+          @body.compile(context)
+        end
       end
 
       class SendRandNode<SendNode
@@ -922,6 +1049,91 @@ module YTLJit
         end
       end
 
+      class SendRangeAccessNode<SendNode
+        include AbsArch
+
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          if slf.ruby_type == Range then
+            epare = @arguments[2].element_node_list[0]
+            esig = epare[0]
+            enode = epare[1]
+            tt = enode.decide_type_once(esig)
+            add_type(cursig, tt)
+          else
+            super
+          end
+
+          context
+        end
+
+        def compile(context)
+          rtype = @arguments[2].decide_type_once(context.to_signature)
+          rrtype = rtype.ruby_type
+          if rrtype == Range and !rtype.boxed then
+            context = @arguments[2].compile(context)
+            slotoff = OpIndirect.new(TMPR, arg_offset)
+            asm = context.assembler
+            asm.with_retry do
+              asm.mov(TMPR, context.ret_reg)
+              asm.mov(RETR, slotoff)
+            end
+
+            context.ret_reg = RETR
+            context.ret_node = self
+
+            context
+          else
+            super(context)
+          end
+        end
+      end
+
+      class SendFirstNode<SendRangeAccessNode
+        add_special_send_node :first
+        def arg_offset
+          0
+        end
+      end
+
+      class SendLastNode<SendRangeAccessNode
+        add_special_send_node :last
+        def arg_offset
+          AsmType::MACHINE_WORD.size
+        end
+      end
+
+      class SendExcludeEndNode<SendRangeAccessNode
+        add_special_send_node :exclude_end?
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          if slf.ruby_type == Range then
+            tt = RubyType::BaseType.from_ruby_class(TrueClass)
+            add_type(cursig, tt)
+            tt = RubyType::BaseType.from_ruby_class(FalseClass)
+            add_type(cursig, tt)
+          else
+            super
+          end
+
+          context
+        end
+
+        def arg_offset
+          AsmType::MACHINE_WORD.size * 2
+        end
+      end
+
+      class SendSizeNode<SendNode
+        add_special_send_node :size
+        def collect_candidate_type_regident(context, slf)
+          cursig = context.to_signature
+          tt = RubyType::BaseType.from_ruby_class(Fixnum)
+          add_type(cursig, tt)
+          context
+        end
+      end
+
       class SendSameArgTypeNode<SendNode
         def collect_candidate_type_regident(context, slf)
           sig = context.to_signature
@@ -945,16 +1157,22 @@ module YTLJit
 
         def compile_call_func(context, fname)
           fadd = OpMemAddress.new(address_of(fname))
-          context.start_using_reg(FUNC_ARG[0])
+          context.start_arg_reg(FUNC_FLOAT_ARG)
+          context.start_arg_reg
           asm = context.assembler
           asm.with_retry do
             asm.mov(FUNC_FLOAT_ARG[0], context.ret_reg)
+          end
+          context.set_reg_content(FUNC_FLOAT_ARG[0].dst_opecode, 
+                                  context.ret_node)
+          asm.with_retry do
             asm.call_with_arg(fadd, 1)
             asm.sub(SPR, 8)
             asm.fstpl(INDIRECT_SPR)
             asm.pop(XMM0)
           end
-          context.end_using_reg(FUNC_ARG[0])
+          context.end_arg_reg
+          context.end_arg_reg(FUNC_FLOAT_ARG)
           context
         end
 
@@ -976,7 +1194,7 @@ module YTLJit
         end
       end
       
-      class SendSqrtNode < SendMathFuncNode
+      class SendSqrtNode<SendMathFuncNode
         add_special_send_node :sqrt
         def compile_main(context)
           context = compile_call_func(context, "sqrt")
@@ -986,7 +1204,7 @@ module YTLJit
         end
       end
 
-      class SendSinNode < SendMathFuncNode
+      class SendSinNode<SendMathFuncNode
         add_special_send_node :sin
         def compile_main(context)
           context = compile_call_func(context, "sin")
@@ -996,7 +1214,7 @@ module YTLJit
         end
       end
 
-      class SendCosNode < SendMathFuncNode
+      class SendCosNode<SendMathFuncNode
         add_special_send_node :cos
         def compile_main(context)
           context = compile_call_func(context, "cos")
@@ -1006,7 +1224,7 @@ module YTLJit
         end
       end
 
-      class SendTanNode < SendMathFuncNode
+      class SendTanNode<SendMathFuncNode
         add_special_send_node :tan
         def compile_main(context)
           context = compile_call_func(context, "tan")
@@ -1015,6 +1233,42 @@ module YTLJit
           context
         end
       end
+
+      class RawSendNode<SendNode
+        def collect_candidate_type(context)
+          @arguments.each do |arg|
+            context = arg.collect_candidate_type(context)
+          end
+
+          context = collect_candidate_type_body(context)
+
+          @body.collect_candidate_type(context)
+        end
+      end
+
+      class RetStringSendNode<RawSendNode
+        def collect_candidate_type_body(context)
+          sig = context.to_signature
+          tt = RubyType::BaseType.from_ruby_class(String)
+          add_type(sig, tt)
+
+          context
+        end
+      end
+
+      class RetArraySendNode<RawSendNode
+        def collect_candidate_type_body(context)
+          sig = context.to_signature
+          tt = RubyType::BaseType.from_ruby_class(Array)
+          add_type(sig, tt)
+
+          @arguments[1..-1].each_with_index do |anode, idx|
+            add_element_node(sig, anode, [idx], context)
+          end
+
+          context
+        end
+      end
     end
   end
 end