cast_off 0.3.1 → 0.3.2

data/lib/cast_off/compile/ir/guard_ir.rb

@@ -14,16 +14,12 @@ module CastOff
 %  top = @insn.iseq
 %  a = [@insn.iseq]
 %  a = @insn.iseq.ancestors.reverse + a if @translator.inline_block?
-%  stacks = a.map{|s| s.depth}
-%  stacks.shift
-%  stacks.push(@insn.depth)
-%  stacks = stacks.zip(a.map{|s| s.depth}).map{|d0, d1| d0 - d1}
-%  valid = @translator.inline_block? ? @insn.depth : (@insn.depth - @insn.iseq.depth)
-%  bug() unless stacks.inject(0){|sum, d| sum + d} == valid
 %  a.each_with_index do |s, idx|
   {
-%    local_c = s.lvars.size()
-%    stack_c = stacks[idx]
+%    bug() unless @dependent_local_variables[s]
+%    bug() unless @dependent_stack_variables[s]
+%    local_c = @dependent_local_variables[s].size()
+%    stack_c = @dependent_stack_variables[s].size()
 %    if @translator.inline_block?
     int local_c = <%= local_c %>;
     VALUE local_v[<%= local_c %>];
@@ -31,13 +27,13 @@ module CastOff
     int stack_c = <%= stack_c %>;
     VALUE stack_v[<%= stack_c %>];
     rb_iseq_t *iseq = <%= s %>;
-%    s.lvars.each_with_index do |(var_name, var_id, op_idx, depth, var_annotation), i|
+%    @dependent_local_variables[s].each_with_index do |v, i|
 %      if @translator.inline_block?
-    local_v[<%= i %>] = local<%= var_id %>_<%= var_name %>; /* FIXME */
+    local_v[<%= i %>] = <%= get_variable(v).boxed_form %>;
 %      end
 %    end
-%    stack_c.times do |i|
-    stack_v[<%= i %>] = tmp<%= s.depth + i %>;
+%    @dependent_stack_variables[s].each_with_index do |v, i|
+    stack_v[<%= i %>] = <%= get_variable(v).boxed_form %>;
 %    end
 %    method_p = (s.itype == :method ? 1 : 0)
 %    lambda_p = (s.itype == :method ? 0 : 'lambda_p')
@@ -100,30 +96,44 @@ static void <RECOMPILATION_FUNCTION_NAME>(VALUE obj)
 #if 1
   if(!sampling_table) register_sampling_table(rb_hash_new());
 %  count = 0
-%  defs = get_definition(@guard_value)
-%  defs.each do |defn|
-%    case defn
-%    when SubIR
-%      case defn.src
-%      when LocalVariable, DynamicVariable, InstanceVariable, ClassVariable, GlobalVariable, Self
-%        count += 1
+%  done = []
+%  queue = [@guard_value]
+%  while (val = queue.pop)
+%    bug() if done.include?(val)
+%    done << val
+%    bug() unless val.is_a?(Variable)
+%    defs = get_definition(val)
+%    defs.each do |defn|
+%      case defn
+%      when SubIR
+%        case defn.src
+%        when LocalVariable, DynamicVariable, InstanceVariable, ClassVariable, GlobalVariable, Self
+%          count += 1
   sampling_variable(obj, ID2SYM(rb_intern("<%= defn.src.source %>")));
-%      when ConstWrapper
-%        # Fixme
+%          if !queue.include?(defn.src) && !done.include?(defn.src)
+%            dlog("add recompilation queue \#{defn.src}")
+%            queue << defn.src
+%          end
+%        when ConstWrapper
+%          # Fixme
   /* <%= defn.src.path %> */
-%      when Literal
-%        # nothing to do
-%      else
-%        bug(defn.src)
-%      end
-%    when InvokeIR
-%      recv = defn.param_variables.first
-%      bug() if recv.dynamic?
-%      recv.types.each do |k|
-%        recv_class = @translator.get_c_classname(k)
-%        bug() unless recv_class
-%        count += 1
+%        when Literal, Argument, TmpBuffer
+%          # nothing to do
+%        else
+%          bug(defn.src)
+%        end
+%      when InvokeIR
+%        recv = defn.param_variables.first
+%        if recv.dynamic?
+%          bug() if val == @guard_value
+%          next
+%        end
+%        recv.types.each do |k|
+%          recv_class = @translator.get_c_classname(k)
+%          bug() unless recv_class
+%          count += 1
   __sampling_poscall(obj, <%= recv_class %>, ID2SYM(rb_intern("<%= defn.method_id %>")));
+%        end
 %      end
 %    end
 %  end
@@ -244,7 +254,9 @@ static int <CLASS_CHECK_FUNCTION_NAME>_failed(VALUE obj, VALUE klass)
         @variables << @guard_value
         @variables_without_result << @guard_value
         @result_variable = nil
-        @dependent_variables = get_dependent_variables(vars)
+        @dependent_local_variables = get_dependent_local_variables(vars)
+        @dependent_stack_variables = get_dependent_stack_variables(vars)
+        @dependent_variables = @dependent_local_variables.values.flatten + @dependent_stack_variables.values.flatten
         @source = @insn.source
         @source = @source.empty? ? nil : @source
         @source_line = @insn.line.to_s
@@ -252,58 +264,37 @@ static int <CLASS_CHECK_FUNCTION_NAME>_failed(VALUE obj, VALUE klass)
 
       ### unboxing begin ###
       def unboxing_prelude()
-        # TODO inline api の返り値で unbox 可能なものは、class_exact にして伝播させること。
-        if @guard_value.class_exact? && @guard_value.can_unbox?
-          @guard_value.can_unbox()
-        else
-          @guard_value.can_not_unbox()
-        end
+        @guard_value.box() unless @guard_value.class_exact? && @guard_value.can_unbox?
       end
 
-      def propergate_value_which_can_not_unbox(defs)
+      def propergate_boxed_value(defs)
         change = false
 
         # forward
-        change |= defs.can_not_unbox_variable_resolve_forward(@guard_value)
-
-        # backward
-        if @guard_value.can_not_unbox?
-          change |= defs.can_not_unbox_variable_resolve_backward(@guard_value)
-          if @configuration.deoptimize?
-            @dependent_variables.each do |v|
-              change |= v.can_not_unbox()
-            end
-          end
-        end
-
-        change
-      end
-
-      def propergate_box_value(defs)
-        change = false
-
-        # forward
-        change |= defs.box_value_resolve_forward(@guard_value)
+        change |= defs.propergate_boxed_value_forward(@guard_value)
 
         # backward
         if @guard_value.boxed?
-          change |= defs.box_value_resolve_backward(@guard_value)
+          change |= defs.propergate_boxed_value_backward(@guard_value)
           if @configuration.deoptimize?
-            @dependent_variables.each do |v|
-              v.box()
-              change |= defs.box_value_resolve_backward(v)
+            @dependent_variables.each do |var|
+              if var.is_a?(DynamicVariable)
+                bug() unless var.boxed?
+                next
+              end
+              vars = defs.get_variables(var)
+              boxed_p = !!vars.find{|v| v.boxed?}
+              next unless boxed_p
+              vars.each do |v|
+                change |= v.box()
+                change |= defs.propergate_boxed_value_backward(v)
+              end
             end
           end
         end
 
         change
       end
-
-      def propergate_unbox_value(defs)
-        return false if @guard_value.can_not_unbox?
-        bug() unless @guard_value.class_exact?
-        defs.unbox_value_resolve(@guard_value)
-      end
       ### unboxing end ###
 
       def propergate_exact_class(defs)
@@ -357,29 +348,54 @@ static int <CLASS_CHECK_FUNCTION_NAME>_failed(VALUE obj, VALUE klass)
         "  }"
       end
 
-      def get_dependent_variables(vars)
-        targets = []
+      def get_dependent_local_variables(vars)
+        local_variables = {}
         s = @insn.iseq
         level = @insn.iseq.generation
         while s
+          variables = []
           s.lvars.each do |var_name, var_id, op_idx, depth, var_annotation|
             bug() unless depth == level
             if @translator.inline_block?
-              targets << "local#{var_id}_#{var_name}" # FIXME
+              var = vars.find{|v| v.to_name == "local#{var_id}_#{var_name}"} # FIXME
             else
-              targets << "dfp#{depth}[#{op_idx}]" # FIXME
+              var = vars.find{|v| v.to_name == "dfp#{depth}[#{op_idx}]"} # FIXME
             end
+            bug() unless var.is_a?(LocalVariable) || var.is_a?(DynamicVariable)
+            variables << var
           end
+          local_variables[s] = variables
           level -= 1
           s = s.parent
         end
         bug() unless level == -1
-        d = @insn.depth
-        while d > 0 do
-          d -= 1
-          targets << "tmp#{d}" # FIXME
+        bug() unless local_variables.size == (@insn.iseq.generation + 1)
+        local_variables
+      end
+
+      def get_dependent_stack_variables(vars)
+        stack_variables = {}
+        a = [@insn.iseq]
+        a = @insn.iseq.ancestors.reverse + a if @translator.inline_block?
+        stacks = a.map{|s| s.depth}
+        stacks.shift
+        stacks.push(@insn.depth)
+        stacks = stacks.zip(a.map{|s| s.depth}).map{|d0, d1| d0 - d1}
+        valid = @translator.inline_block? ? @insn.depth : (@insn.depth - @insn.iseq.depth)
+        bug() unless stacks.inject(0){|sum, d| sum + d} == valid
+        a.each_with_index do |s, idx|
+          stack_c = stacks[idx]
+          variables = []
+          stack_c.times do |i|
+            var = vars.find{|v| v.to_name == "tmp#{s.depth + i}"} # FIXME
+            bug() unless var.is_a?(TmpVariable)
+            variables << var
+          end
+          bug() unless variables.size == stack_c
+          stack_variables[s] = variables
         end
-        vars.select{|v| targets.include?(v.to_name)}.uniq()
+        bug() unless stack_variables.size == a.size
+        stack_variables
       end
     end
 

data/lib/cast_off/compile/ir/jump_ir.rb

@@ -44,25 +44,13 @@ module CastOff::Compiler
 
       ### unboxing begin ###
       def unboxing_prelude()
-        @cond_value.can_not_unbox() if @cond_value
+        @cond_value.box() if @cond_value
       end
 
-      def propergate_value_which_can_not_unbox(defs)
-        return false unless @cond_value
-        bug() unless @cond_value.can_not_unbox?
-        defs.can_not_unbox_variable_resolve_backward(@cond_value)
-      end
-
-      def propergate_box_value(defs)
+      def propergate_boxed_value(defs)
         return false unless @cond_value
         bug() unless @cond_value.boxed?
-        defs.box_value_resolve_backward(@cond_value)
-      end
-
-      def propergate_unbox_value(defs)
-        return false unless @cond_value
-        bug() unless @cond_value.can_not_unbox?
-        false
+        defs.propergate_boxed_value_backward(@cond_value)
       end
       ### unboxing end ###
 

data/lib/cast_off/compile/ir/operand.rb

@@ -26,29 +26,33 @@ module CastOff::Compiler
         @state = :undefined
         @annotation = []
         @ignore = []
-        @unboxing_state = :undefined
+        @unboxing_state = :unboxed
         @negative_cond_value = false
       end
 
       ### unboxing begin ###
-      def unbox()
-        case @unboxing_state
-        when :can_unbox
-          @unboxing_state = :unboxed
-          return true
-        when :unboxed
-          return false
+      def can_unbox?
+        if instance_of?(LocalVariable) || instance_of?(TmpVariable) || instance_of?(Literal)
+          if dynamic? || @types.size != 1
+            false
+          else
+            bug() unless @types[0].instance_of?(ClassWrapper)
+            case @types[0]
+            when FloatWrapper, FixnumWrapper
+              true
+            else
+              false
+            end
+          end
+        else
+          # ConstWrapper, Self, Pointer, Argument, TmpBuffer
+          false
         end
-        bug()
-      end
-
-      def unboxed?
-        @unboxing_state == :unboxed
       end
 
       def box()
         case @unboxing_state
-        when :unboxed, :can_unbox, :can_not_unbox
+        when :unboxed
           @unboxing_state = :boxed
           return true
         when :boxed
@@ -61,42 +65,24 @@ module CastOff::Compiler
         @unboxing_state == :boxed
       end
 
-      def can_unbox?
-        if instance_of?(LocalVariable) || instance_of?(TmpVariable) || instance_of?(Literal)
-          if dynamic? || @types.size != 1
-            false
-          else
-            true
-          end
-        else
-          # ConstWrapper, Self, Pointer, Argument, TmpBuffer
-          false
-        end
-      end
-
-      def can_not_unbox?
-        @unboxing_state == :can_not_unbox
-      end
-
-      def can_unbox()
-        bug() unless @unboxing_state == :undefined
-        @unboxing_state = :can_unbox
+      def unboxed?
+        @unboxing_state == :unboxed
       end
 
-      def can_not_unbox()
+      def boxed_form()
         case @unboxing_state
-        when :undefined, :can_unbox
-          @unboxing_state = :can_not_unbox
-          true
-        when :can_not_unbox
-          false
-        else
-          bug()
+        when :boxed
+          return self.to_s
+        when :unboxed
+          bug() unless can_unbox?
+          case @types.first
+          when FixnumWrapper
+            return "LONG2FIX(#{self.to_s})"
+          when FloatWrapper
+            return "DBL2NUM(#{self.to_s})"
+          end
         end
-      end
-
-      def box_unbox_undefined?
-        @unboxing_state == :undefined
+        bug()
       end
       ### unboxing end ###
 
@@ -114,7 +100,7 @@ module CastOff::Compiler
           when FixnumWrapper
             return :long
           end
-        when :can_unbox, :can_not_unbox, :boxed
+        when :boxed
           return :VALUE
         end
         bug()

data/lib/cast_off/compile/ir/param_ir.rb

@@ -23,38 +23,17 @@ module CastOff::Compiler
         # nothing to do
       end
 
-      def propergate_value_which_can_not_unbox(defs)
+      def propergate_boxed_value(defs)
         change = false
 
         # forward
-        change |= defs.can_not_unbox_variable_resolve_forward(@param_value)
+        change |= defs.propergate_boxed_value_forward(@param_value)
 
         # backward
-        if @param_value.can_not_unbox?
-          change |= defs.can_not_unbox_variable_resolve_backward(@param_value)
-        end
+        change |= defs.propergate_boxed_value_backward(@param_value) if @param_value.boxed?
 
         change
       end
-
-      def propergate_box_value(defs)
-        change = false
-
-        # forward
-        change |= defs.box_value_resolve_forward(@param_value)
-
-        # backward
-        if @param_value.boxed?
-          change |= defs.box_value_resolve_backward(@param_value)
-        end
-
-        change
-      end
-
-      def propergate_unbox_value(defs)
-        return false if @param_value.can_not_unbox?
-        defs.unbox_value_resolve(@param_value)
-      end
       ### unboxing end ###
 
       def propergate_exact_class(defs)

data/lib/cast_off/compile/ir/return_ir.rb

@@ -31,22 +31,12 @@ module CastOff::Compiler
 
       ### unboxing begin ###
       def unboxing_prelude()
-        @return_value.can_not_unbox()
+        @return_value.box()
       end
 
-      def propergate_value_which_can_not_unbox(defs)
-        bug() unless @return_value.can_not_unbox?
-        defs.can_not_unbox_variable_resolve_backward(@return_value)
-      end
-
-      def propergate_box_value(defs)
+      def propergate_boxed_value(defs)
         bug() unless @return_value.boxed?
-        defs.box_value_resolve_backward(@return_value)
-      end
-
-      def propergate_unbox_value(defs)
-        bug() unless @return_value.can_not_unbox?
-        false
+        defs.propergate_boxed_value_backward(@return_value)
       end
       ### unboxing end ###
 

data/lib/cast_off/compile/ir/simple_ir.rb

@@ -606,11 +606,7 @@ Call site is (#{insn}).
         bug()
       end
 
-      def propergate_value_which_can_not_unbox(defs)
-        bug()
-      end
-
-      def propergate_unbox_value(defs)
+      def propergate_boxed_value(defs)
         bug()
       end
       ### unboxing end ###
@@ -746,7 +742,15 @@ Call site is (#{insn}).
           return [target]
         when Variable
           ds = @information.definition_of(target)
-          bug() if ds.empty?
+          if ds.empty?
+            case target
+            when TmpBuffer, Pointer, Argument, Self
+              return []
+            else
+              bug() unless @information.undefined_variables.include?(target)
+              return [] # FIXME
+            end
+          end
           ary = []
           ds.each do |d|
             case d
@@ -790,6 +794,12 @@ Call site is (#{insn}).
         }.join("\n")
       end
 
+      def get_variable(v)
+        bug() unless v.is_a?(Variable)
+        bug() unless @information
+        @information.get_variable(v)
+      end
+
       def dispatch_method?
         # FIXME 型情報を活用（Fixnum#+ とかはインスタンス変数を触らないよね）
         return true if !@translator.inline_block? && self.is_a?(LoopIR)

data/lib/cast_off/compile/ir/sub_ir.rb

@@ -26,86 +26,28 @@ module CastOff::Compiler
 
       ### unboxing begin ###
       def unboxing_prelude()
-        if @src.can_unbox? && @dst.can_unbox?
-          @src.can_unbox()
-          @dst.can_unbox()
-        else
-          @src.can_not_unbox()
-          @dst.can_not_unbox()
+        unless @src.can_unbox? && @dst.can_unbox?
+          @src.box()
+          @dst.box()
         end
       end
 
-      def propergate_value_which_can_not_unbox(defs)
+      def propergate_boxed_value(defs)
         change = false
 
         # forward
-        change |= defs.can_not_unbox_variable_resolve_forward(@src)
-        if @src.can_not_unbox?
-          change |= @dst.can_not_unbox()
-        end
+        change |= defs.propergate_boxed_value_forward(@src)
+        change |= @dst.box() if @src.boxed?
 
         # backward
-        if @dst.can_not_unbox?
-          change |= @src.can_not_unbox()
-        end
-        if @src.can_not_unbox?
-          change |= defs.can_not_unbox_variable_resolve_backward(@src)
-        end
-        bug() unless @src.can_not_unbox? == @dst.can_not_unbox?
-
-        change
-      end
-
-      def propergate_box_value(defs)
-        change = false
-
-        # forward
-        change |= defs.box_value_resolve_forward(@src)
-        if @src.boxed?
-          change |= @dst.box()
-        end
+        change |= @src.box() if @dst.boxed?
+        change |= defs.propergate_boxed_value_backward(@src) if @src.boxed?
 
-        # backward
-        if @dst.boxed?
-          change |= @src.box()
-        end
-        if @src.boxed?
-          change |= defs.box_value_resolve_backward(@src)
-        end
         bug() unless @src.boxed?   == @dst.boxed?
         bug() unless @src.unboxed? == @dst.unboxed?
 
         change
       end
-
-      def propergate_unbox_value(defs)
-        #return false if @src.unboxed? && @dst.unboxed?
-        if @src.can_not_unbox?
-          bug() unless @dst.can_not_unbox?
-          return false
-        else
-          bug() if @dst.can_not_unbox?
-          change = false
-
-          if @src.instance_of?(Literal)
-            bug() unless @src.types.size == 1
-            bug() unless @src.static?
-            floatwrap  = ClassWrapper.new(Float, true)
-            fixnumwrap = ClassWrapper.new(Fixnum, true)
-            case @src.types[0]
-            when floatwrap, fixnumwrap
-              change |= @src.unbox()
-            end
-          end
-
-          change |= defs.unbox_value_resolve(@src)
-          if @src.unboxed? && !@dst.unboxed?
-            @dst.unbox()
-            change = true
-          end
-          return change
-        end
-      end
       ### unboxing end ###
 
       def propergate_exact_class(defs)

data/lib/cast_off/compile/iseq.rb

@@ -300,6 +300,7 @@ static void <%= ifunc_node_generator() %>()
   rb_thread_t *th = current_thread();
   VALUE cast_off_argv[<%= own_argv_size() %>];
   VALUE cast_off_tmp;
+  VALUE sampling_tmp;
   VALUE self = get_self(th);
   int lambda_p = cast_off_lambda_p(arg, argc, argv);
   int i, num;
@@ -441,6 +442,16 @@ static void <%= ifunc_node_generator() %>()
         @excs[exc] << entry unless @excs[exc].include?(entry)
       end
 
+      def delete_labels(ls)
+        entries = @excs[:break]
+        return unless entries
+        entries.delete_if do |(pc, label, stack)|
+          del_p = ls.include?(label)
+          dlog("#{self}: delete break label #{label}") if del_p
+          del_p
+        end
+      end
+
       def to_name
         "#{@name}: #{@source_file} #{@source_line}"
       end