cast_off 0.2.0

data/lib/cast_off/compile/basicblock.rb

@@ -0,0 +1,144 @@
+# coding=utf-8
+
+module CastOff::Compiler
+  class Translator::CFG
+    class BasicBlock
+      include CastOff::Util
+      include CastOff::Compiler::Instruction
+      include CastOff::Compiler::SimpleIR
+
+      attr_reader :insns, :pre, :next, :labels, :number, :irs, :iseq
+
+      def initialize(cfg, insns, number)
+        @cfg = cfg
+        @insns = insns
+        bug() if @insns.find{|i| not i.instance_of?(InsnInfo)}
+        @number = number
+        @pre = nil
+        @next = nil
+        @labels = []
+        @irs = nil
+        @entry_point = number == 0
+        @iseq = @insns[0].iseq
+        bug() if @insns.find{|i| i.iseq != @iseq}
+      end
+
+      def entry_point?
+        @entry_point
+      end
+
+      def set_prev_block(blocks)
+        @pre = []
+        index = blocks.index(self)
+        if index != 0
+          pre = blocks[index - 1]
+          case pre
+          when Symbol
+            # this block is branch or jump target
+            @labels << pre
+            i = index - 2
+            while i >= 0
+              break unless blocks[i].is_a?(Symbol)
+              @labels << blocks[i]
+              i -= 1
+            end
+            matchlabels = []
+            blocks.each do |basicblock|
+              case basicblock when BasicBlock
+                last_insn = basicblock.insns.last
+                op = last_insn.op
+                argv = last_insn.argv
+                if BranchInstruction.include?(op)
+                  case op
+                  when :jump, :branchunless, :branchif, \
+                       :cast_off_enter_block, :cast_off_leave_block, :cast_off_continue_loop, \
+                       :cast_off_break_block
+                    targets = [argv[0]]
+                  when :cast_off_handle_optional_args
+                    targets = argv[0]
+                  else
+                    bug("unexpected instruction #{op}")
+                  end
+                  targets.each do |t|
+                    if @labels.include?(t)
+                      matchlabels << t
+                      @pre << basicblock unless @pre.include?(basicblock)
+                    end
+                  end
+                end
+              end
+            end
+            if @pre.empty?
+              # join point with exception handler
+              # nothing to do
+              @labels = []
+            else
+              @labels = @labels & matchlabels
+              bug() if @labels.empty?
+            end
+            # consider fall-throuth from previous block
+            i = index - 2
+            while i >= 0
+              pre = blocks[i]
+              break if pre.is_a?(BasicBlock)
+              i -= 1
+            end
+            if pre.is_a?(BasicBlock)
+              last_insn = pre.insns.last
+              @pre << pre if !JumpOrReturnInstruction.include?(last_insn.op)
+            end
+          when BasicBlock
+            # fall-throuth from previous block
+            last_insn = pre.insns.last
+            if JumpOrReturnInstruction.include?(last_insn.op)
+              # dead block
+            else
+              @pre << pre
+            end
+          else
+            bug()
+          end
+        else
+          # entry point
+        end
+      end
+
+      def set_next_block(blocks)
+        @next = []
+        bug() if blocks.find{|b| b.instance_of?(BasicBlock) && !b.pre }
+        blocks.each{|b| @next << b if b.instance_of?(BasicBlock) && b.pre.include?(self)}
+      end
+
+      def gen_ir()
+        @irs = generate_ir(@cfg, @insns, in_depth())
+      end
+
+      def to_c()
+        params = []
+        codes = []
+        @labels.each{|label| codes << "#{label}:" }
+        @irs.each do |ir|
+          bug() unless ir.insn.iseq == @iseq
+          ir.variables.each{|v| @iseq.declare_local_variable("#{v.declare()} #{v}") if v.declare?}
+          case ir
+          when SubIR, JumpIR, ReturnIR, GuardIR
+            codes << ir.to_c()
+          when ParamIR
+            params << ir.param_value
+          when CallIR
+            codes << ir.to_c(params)
+          else
+            bug("invalid ir #{ir}")
+          end
+        end
+        bug() unless params.empty?
+        codes.join("\n")
+      end
+
+      def to_s()
+        "(#{@labels.join(", ")})BB#{@number}"
+      end
+    end
+  end
+end
+

data/lib/cast_off/compile/cfg.rb

@@ -0,0 +1,391 @@
+# coding=utf-8
+
+module CastOff::Compiler
+  class Translator
+  class CFG
+    include CastOff::Util
+    include CastOff::Compiler::Instruction
+    include CastOff::Compiler::SimpleIR
+
+    attr_reader :blocks
+
+    def to_c()
+      @blocks.each{|b| b.iseq.append_c_function_body(b.to_c())}
+    end
+
+    def to_s()
+      @blocks.join("\n")
+    end
+
+    def translator
+      bug() unless @translator
+      @translator
+    end
+
+    def initialize(body)
+      @translator = nil
+      blocks = []
+      basicblock = []
+      body.each do |v|
+        case v
+        when InsnInfo
+          basicblock << v
+          if BlockSeparator.include?(v.op)
+            blocks << basicblock
+            basicblock = []
+          end
+        when Symbol
+          if !basicblock.empty?
+            blocks << basicblock
+            basicblock = []
+          end
+          blocks << v
+        else
+          bug("v = #{v}")
+        end
+      end
+      blocks << basicblock unless basicblock.empty?
+
+      bbnum = -1
+      blocks.map!{|b| b.instance_of?(Array) ? BasicBlock.new(self, b, bbnum += 1) : b}
+      blocks.each{|b| b.set_prev_block(blocks) if b.instance_of?(BasicBlock)}
+      blocks.each{|b| b.set_next_block(blocks) if b.instance_of?(BasicBlock)}
+      @blocks = blocks.select{|b| b.instance_of?(BasicBlock)}
+      @blocks.each{|b| bug() unless b.next && b.pre}
+
+      eliminate_unreachable_blocks()
+      validate_stack() # stack.rb
+    end
+
+    def gen_ir(t)
+      @translator = t
+      @blocks.each{|b| b.gen_ir()}
+      change = true
+      while change
+        change = false
+        set_information() # information.rb
+        type_propergation()
+        propergate_exact_class()
+        propergate_guard_usage()
+        inject_guards()
+        reject_redundant_guards()
+        if transform_branch_instruction()
+          eliminate_unreachable_blocks() # this method generates jump_guards
+          change = true
+        end
+        reject_unused_ir() # should be call after guard generation
+        change |= method_inlining()
+        if change
+          validate_stack() # stack.rb
+          reject_guards()
+          reset_ir()
+        end
+      end
+      unboxing()
+      attach_var_info()
+      set_sampling()
+    end
+
+    def find_variable(v0)
+      all_variable.find{|v1| v0 == v1}
+    end
+
+    private
+
+    def all_ir()
+      @blocks.inject([]){|a, b| a.concat(b.irs)}.freeze()
+    end
+
+    def all_pointer_definition()
+      all_ir().select{|ir| ir.result_variable.is_a?(Pointer)}.freeze()
+    end
+
+    def all_pointer()
+      ptrs = all_pointer_definition().map{|ir| ir.result_variable}.uniq()
+      bug() if ptrs.find{|p| not p.is_a?(Pointer)}
+      ptrs.freeze()
+    end
+
+    def all_variable()
+      all_ir().inject([]){|a, ir| a.concat(ir.variables)}.uniq()
+    end
+
+    def reset_ir()
+      all_ir().each{|ir| ir.reset()}
+    end
+
+    def eliminate_unreachable_blocks()
+      # Breadth first search
+      achieved = []
+      vertex = nil
+      depth = 0
+      queue = [@blocks[0]]
+      while !queue.empty?
+        vertex = queue.shift()
+        bug() unless vertex
+        achieved << vertex
+        queue += vertex.next.select{|b| !queue.include?(b) && !achieved.include?(b)}
+      end
+      deadblocks = @blocks - achieved
+      achieved.each do |aliveblock|
+        aliveblock.pre.reject!{|b| deadblocks.include?(b)}
+        bug() if aliveblock.next.find{|b| deadblocks.include?(b)}
+      end
+      @blocks = achieved
+      @blocks.sort! {|a, b| a.number <=> b.number}
+      bug() if @blocks.find{|b| b.pre.empty? && !b.entry_point?}
+    end
+
+    def reject_unused_ir()
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.mark(defs)
+            defs.step(ir)
+          end
+        end
+      end
+      @blocks.each do |b|
+        information = b.information.dup
+        information.reject!{|ir| not ir.alive?}
+        b.information = information
+        b.irs.reject!{|ir| not ir.alive?}
+      end
+    end
+
+    def transform_branch_instruction()
+      change = false
+      @blocks.each do |b|
+        if b.next.size > 1
+          ir = b.irs.last
+          bug() unless ir.is_a?(JumpIR)
+          unused = ir.unused_target()
+          if unused
+            change = true
+            bug() unless b.next.size == 2
+            targets = ir.jump_targets
+            bug() unless targets.size() == 1
+            target = targets[0]
+            fallthrough = unused != :fallthrough
+            if fallthrough
+              dead_index = b.next[0].labels.include?(target) ? 0 : 1
+            else
+              dead_index = b.next[0].labels.include?(target) ? 1 : 0
+            end
+            dead  = b.next[dead_index]
+            jir = b.irs.pop()
+            b.irs.push(JumpGuard.new(jir.cond_value, all_variable, jir.insn, self))
+            if !fallthrough
+              insn = InsnInfo.new([:jump, target], ir.insn.iseq, -1, -1)
+              b.irs.push(JumpIR.new(nil, insn, self))
+            end
+            b.next.delete(dead)
+            dead.pre.delete(b)
+          end
+        end
+      end
+      change
+    end
+
+    def method_inlining()
+      @blocks.each do |b|
+        b.irs.each do |ir|
+          if ir.inlining_target?
+            todo()
+          end
+        end
+      end
+      false
+    end
+
+    def type_propergation()
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.type_propergation(defs)
+            bug() unless change == true || change == false
+            defs.step(ir)
+          end
+        end
+      end
+      all_ir().each{|ir| ir.variables.each{|v| v.not_initialized() if v.undefined?}}
+      bug() if all_ir().find{|ir| ir.variables.find{|v| v.undefined?}}
+    end
+
+    def propergate_exact_class()
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.propergate_exact_class(defs)
+            defs.step(ir)
+          end
+        end
+      end
+    end
+
+    def propergate_guard_usage()
+      irs = all_ir()
+      irs.each{|ir| ir.propergate_guard_usage()}
+    end
+
+    ### unboxing begin ###
+    def unboxing()
+      # 1: mark value which can not unbox
+      # 1: mark value which can unbox
+      irs = all_ir()
+      irs.each{|ir| ir.unboxing_prelude()}
+      bug() if irs.map{|ir| ir.values }.flatten.find{|v| v.box_unbox_undefined? }
+
+      # 2: propergate value which can not unbox
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.propergate_value_which_can_not_unbox(defs)
+            defs.step(ir)
+          end
+        end
+      end
+      bug() if irs.find{|ir| ir.instance_of?(SubIR) && ir.dst.can_not_unbox? != ir.src.can_not_unbox?}
+
+      # 3: propergate value which can unbox
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.propergate_unbox_value(defs)
+            defs.step(ir)
+          end
+        end
+      end
+
+      bug() if irs.map{|ir| ir.values }.flatten.find{|v| v.unboxed? && (v.dynamic? || v.types.size != 1)}
+      irs.each do |ir|
+        ir.values.each do |v|
+          next unless v.unboxed?
+        end
+      end
+
+      irs.map{|ir| ir.values}.flatten.each{|v| v.box() unless v.unboxed?}
+      irs.map{|ir| ir.values}.flatten.each{|v| bug() if !v.boxed? && !v.unboxed?}
+      change = true
+      while change
+        change = false
+        @blocks.each do |b|
+          defs = b.information.dup
+          b.irs.each do |ir|
+            change |= ir.propergate_box_value(defs)
+            defs.step(ir)
+          end
+        end
+      end
+
+      @blocks.each do |b|
+        defs = b.information.dup
+        b.irs.each do |ir|
+          case ir
+          when SubIR
+            bug() unless ir.src.boxed?   == ir.dst.boxed?
+            bug() unless ir.src.unboxed? == ir.dst.unboxed?
+          end
+          ir.variables_without_result.each do |v|
+            ds = defs.variable_definition.select {|d| v == d.result_variable }
+            if v.unboxed?
+              bug() if ds.find{|d| not d.result_variable.unboxed? }
+            elsif v.boxed?
+              bug() if ds.find{|d| d.result_variable.unboxed? }
+            else
+              bug(ir)
+            end
+          end
+          defs.step(ir)
+        end
+      end
+    end
+    ### unboxing end ###
+
+    def reject_redundant_guards()
+      redundant = []
+      ptrs = all_pointer()
+      @blocks.each do |b|
+        safe = b.in_guards.dup()
+        b.irs.each do |ir|
+          redundant << ir if safe.redundant?(ir)
+          safe.step(ir)
+        end
+        safe.validate_final()
+        b.irs.reject!{|ir| redundant.include?(ir)}
+      end
+    end
+
+    def reject_guards()
+      @blocks.each{|b| b.irs.reject!{|ir| ir.is_a?(StandardGuard)}}
+    end
+
+    def set_sampling()
+      all_ir().each do |ir|
+        targets = nil
+        case ir
+        when CallIR
+          case ir
+          when InvokeIR
+            ir.sampling_return_value()
+          else
+            # TODO
+          end
+          targets = ir.param_variables()
+        when JumpIR
+          targets = [ir.cond_value] if ir.cond_value
+        end
+        next unless targets
+        targets.each do |p|
+          next unless p.dynamic?
+          ir.get_definition(p).each do |d|
+            case d
+            when Literal
+              bug()
+            when Self
+              ir.add_sampling_variable(d)
+            when SubIR
+              d.add_sampling_variable(d.src)
+              #ir.add_sampling_variable(d.src)
+            when CallIR
+              # Nothing to do.
+              # Always sampling CallIR's return value.
+            else
+              bug()
+            end
+          end
+        end
+      end
+    end
+
+    def attach_var_info()
+      set_information() # information.rb
+
+      @blocks.each do |b|
+        defs = b.information.dup()
+        b.irs.each do |ir|
+          ir.set_info(defs.dup())
+          defs.step(ir)
+        end
+        defs.validate_final()
+      end
+    end
+  end
+  end
+end
+