ytljit 0.0.7 → 0.0.8

data/lib/ytljit/vm_codegen.rb

@@ -78,6 +78,7 @@ LO        |                       |   |  |
         @top_node = tnode
         @modified_local_var = []
         @modified_instance_var = Hash.new
+        @modified_global_var = Hash.new
         @yield_node = []
 
         # Options from user
@@ -87,6 +88,7 @@ LO        |                       |   |  |
       attr          :top_node
       attr_accessor :modified_local_var
       attr_accessor :modified_instance_var
+      attr_accessor :modified_global_var
       attr_accessor :yield_node
       attr_accessor :options
 
@@ -269,7 +271,8 @@ LO        |                       |   |  |
 #        @depth_reg = {}
         @depth_reg = Hash.new(0)
         @stack_content = []
-        @reg_content = {}
+        @reg_content = Hash.new(true)
+        @reg_history = Hash.new {|hash, key| hash[key] = []}
 
         # Use only type inference compile mode
         @slf = nil
@@ -386,17 +389,22 @@ LO        |                       |   |  |
 
       def reset_using_reg
         @depth_reg = Hash.new(0)
+#        @depth_reg = {}
       end
 
       def start_using_reg_aux(reg)
         if @depth_reg[reg] then
-          assembler.with_retry do
-            assembler.push(reg)
-            cpustack_push(reg)
+          if @reg_content[reg] then
+            assembler.with_retry do
+              assembler.push(reg)
+              cpustack_push(reg)
+            end
           end
         else
           @depth_reg[reg] = 0
         end
+        @reg_history[reg].push @reg_content[reg]
+        @reg_content[reg] = nil
         @depth_reg[reg] += 1
       end
 
@@ -426,13 +434,16 @@ LO        |                       |   |  |
       def end_using_reg_aux(reg)
         if @depth_reg[reg] then
           @depth_reg[reg] -= 1
+          @reg_content[reg] = @reg_history[reg].pop
         else
           raise "Not saved reg #{reg}"
         end
         if @depth_reg[reg] != -1 then
-          assembler.with_retry do
-            assembler.pop(reg)
-            cpustack_pop(reg)
+          if @reg_content[reg] then
+            assembler.with_retry do
+              assembler.pop(reg)
+              cpustack_pop(reg)
+            end
           end
         else
           @depth_reg[reg] = nil
@@ -537,7 +548,10 @@ LO        |                       |   |  |
           asm.with_retry do
             asm.mov(SPR, BPR)
             asm.pop(BPR)
-            asm.pop(THEPR) if @is_escape != :export_object
+            if @is_escape != :local_export and 
+                @is_escape != :global_export then
+              asm.pop(THEPR) 
+            end
             asm.mov(SPR, BPR)
             asm.pop(BPR)
           end
@@ -584,7 +598,9 @@ LO        |                       |   |  |
         case siz
         when Integer
           add = lambda { 
-            address_of("ytl_arena_alloca")
+            a = address_of("ytl_arena_alloca")
+            $symbol_table[a] = "ytl_arena_alloca"
+            a
           }
           alloca = OpVarMemAddress.new(add)
           asm.with_retry do
@@ -605,7 +621,7 @@ LO        |                       |   |  |
 
       def gen_save_thepr(context)
         casm = context.assembler
-        arenaaddr = context.top_node.get_arena_address
+        arenaaddr = context.top_node.get_local_arena_address
         casm.with_retry do
           casm.mov(TMPR, arenaaddr)
           casm.mov(INDIRECT_TMPR, THEPR)

data/lib/ytljit/vm_cruby_obj.rb

@@ -4,6 +4,7 @@ module YTLJit
       class CRubyInstanceVarRefNode<InstanceVarRefNode
         include TypeListWithoutSignature
         include CommonCodeGen
+        include UnboxedArrayUtil
 
         def initialize(parent, name, mnode)
           super
@@ -11,15 +12,41 @@ module YTLJit
         end
 
         def compile_main(context)
-          slfoff = @current_frame_info.offset_arg(2, BPR)
+          cursig = context.to_signature
+          asm = context.assembler
           mivl = @class_top.end_nodes[0].modified_instance_var.keys
           off = mivl.index(@name)
+          slfoff = @current_frame_info.offset_arg(2, BPR)
+
+          if !cursig[2].boxed then
+            context.start_using_reg(TMPR2)
+            asm.with_retry do
+              asm.mov(TMPR2, slfoff)
+            end
+            context = gen_ref_element(context, nil, off)
+            context.end_using_reg(TMPR2)
+            rtype = decide_type_once(cursig)
+            if rtype.ruby_type == Float and !rtype.boxed then
+              asm.with_retry do
+                asm.mov(XMM0, context.ret_reg)
+              end
+              context.ret_reg = XMM0
+            else
+              asm.with_retry do
+                asm.mov(RETR, context.ret_reg)
+              end
+              context.ret_reg = RETR
+            end
+            return context
+          end
+
           addr = lambda {
-            address_of("ytl_ivar_get_boxing")
+            a = address_of("ytl_ivar_get_boxing")
+            $symbol_table[a] = "ytl_ivar_get_boxing"
+            a
           }
           ivarget = OpVarMemAddress.new(addr)
           context.start_arg_reg
-          asm = context.assembler
           asm.with_retry do
             asm.mov(FUNC_ARG[0], slfoff)
             asm.mov(FUNC_ARG[1], off)
@@ -32,7 +59,7 @@ module YTLJit
           context.end_arg_reg
           context.ret_reg = RETR
           context.ret_node = self
-          decide_type_once(context.to_signature)
+          decide_type_once(cursig)
           if !@type.boxed then 
             context = @type.to_box.gen_unboxing(context)
           end
@@ -43,6 +70,7 @@ module YTLJit
       class CRubyInstanceVarAssignNode<InstanceVarAssignNode
         include TypeListWithoutSignature
         include CommonCodeGen
+        include UnboxedArrayUtil
 
         def initialize(parent, name, mnode, val)
           super
@@ -50,16 +78,30 @@ module YTLJit
         end
 
         def compile_main(context)
+          cursig = context.to_signature
           slfoff = @current_frame_info.offset_arg(2, BPR)
           mivl = @class_top.end_nodes[0].modified_instance_var.keys
           off = mivl.index(@name)
+          rtype = @val.decide_type_once(cursig)
+
+          if !cursig[2].boxed then
+            asm = context.assembler
+            asm.with_retry do
+              asm.mov(TMPR2, slfoff)
+            end
+            context = gen_set_element(context, nil, off, @val)
+            return @body.compile(context)
+          end
+
           addr = lambda {
-            address_of("ytl_ivar_set_boxing")
+            a = address_of("ytl_ivar_set_boxing")
+            $symbol_table[a] = "ytl_ivar_set_boxing"
+            a
           }
           ivarset = OpVarMemAddress.new(addr)
+
           context = @val.compile(context)
-          rtype = @val.decide_type_once(context.to_signature)
-          if @val.is_escape != true then
+          if @val.is_escape != :global_export then
             context = rtype.gen_boxing(context)
           end
 

data/lib/ytljit/vm_inline_method.rb

@@ -174,15 +174,42 @@ module YTLJit
       end
     end
 
+    module UnboxedObjectUtil
+      include AbsArch
+      def compile_object_unboxed(context, siz)
+        context = gen_alloca(context, siz)
+        asm = context.assembler
+        asm.with_retry do
+          (siz - 1).times do |i|
+            off = OpIndirect.new(THEPR, i * 8)
+            asm.mov(TMPR, OpImmidiateMachineWord.new(4))
+            asm.mov(off, TMPR)
+          end
+        end
+        context.ret_node = self
+        context
+      end
+    end
+
     module UnboxedArrayUtil
       include AbsArch
+      include UnboxedObjectUtil
+
+      def compile_array_unboxed(context)
+        siz = ((@element_node_list[1..-1].max_by {|a| a[3][0]})[3][0]) + 1
+        compile_object_unboxed(context, siz)
+      end
+
       def gen_ref_element(context, slf, idx)
-        context.start_using_reg(TMPR2)
-        context = slf.compile(context)
         asm = context.assembler
-        asm.with_retry do
-          asm.mov(TMPR2, context.ret_reg)
+        if slf then
+          context.start_using_reg(TMPR2)
+          context = slf.compile(context)
+          asm.with_retry do
+            asm.mov(TMPR2, context.ret_reg)
+          end
         end
+
         if idx.is_a?(Fixnum) then
           idxval = idx
         else
@@ -202,22 +229,22 @@ module YTLJit
             asm.add(TMPR, TMPR) # * 4
             asm.add(TMPR, TMPR) # * 8
           end
-          asm.add(TMPR2, TMPR)
-          asm.mov(RETR, INDIRECT_TMPR2)
+          asm.add(TMPR, TMPR2)
         end
-        
-        context.end_using_reg(TMPR2)
-        context.ret_reg = RETR
+
+        if slf then
+          context.end_using_reg(TMPR2)
+        end
+        context.ret_reg = INDIRECT_TMPR
         context.ret_node = self
 
         context
       end
-        
-      def gen_set_element(context, slf, idx, val)
-        context.start_using_reg(TMPR2)
 
+      def gen_set_element(context, slf, idx, val)
         asm = context.assembler
         if slf then
+          context.start_using_reg(TMPR2)
           context = slf.compile(context)
           asm.with_retry do
             asm.mov(TMPR2, context.ret_reg)
@@ -245,15 +272,20 @@ module YTLJit
         end
         context = val.compile(context)
 
+        valreg = context.ret_reg
         asm.with_retry do
-          if context.ret_reg != RETR then
-            asm.mov(RETR, context.ret_reg)
+          if !valreg.is_a?(OpRegistor) then
+            asm.mov(RETR, valreg)
+            valreg = RETR
           end
-          asm.mov(INDIRECT_TMPR2, RETR)
+
+          asm.mov(INDIRECT_TMPR2, valreg)
         end
-        
-        context.end_using_reg(TMPR2)
-        context.ret_reg = RETR
+
+        if slf then
+          context.end_using_reg(TMPR2)
+        end
+        context.ret_reg = valreg
         context.ret_node = self
         context
       end