furnace-avm2 0.9.2 → 1.0.0

data/lib/furnace-avm2/transform/ast_normalize.rb

@@ -7,10 +7,10 @@ module Furnace::AVM2
         @options = options
       end
 
-      def transform(ast)
+      def transform(ast, *stuff)
         visit ast
 
-        ast
+        [ ast, *stuff ]
       end
 
       # (pop x) -> (jump-target) x
@@ -115,21 +115,12 @@ module Furnace::AVM2
       alias :on_jump_if :fix_boolean
 
       def replace_with_nop(node)
-        if @options[:eliminate_nops]
-          node.update(:remove)
-        else
-          node.update(:nop)
-        end
+        node.update(:nop)
       end
+      alias :on_kill        :replace_with_nop
       alias :on_debug       :replace_with_nop
       alias :on_debug_file  :replace_with_nop
       alias :on_debug_line  :replace_with_nop
-
-      def on_nop(node)
-        if @options[:eliminate_nops]
-          node.update(:remove)
-        end
-      end
     end
   end
 end

data/lib/furnace-avm2/transform/cfg_build.rb

@@ -1,32 +1,64 @@
 module Furnace::AVM2
   module Transform
     class CFGBuild
-      include AST::Visitor
+      def transform(ast, body, finallies)
+        @jumps      = Set.new
+        @exceptions = {}
 
-      def transform(ast)
-        @ast = ast
+        @cfg = CFG::Graph.new
 
-        @jumps = Set.new
+        body.exceptions.each_with_index do |exc, index|
+          if finallies.find { |f| f[:first_catch] == exc }
+            # The first catch in finally is a no-op
+            next
+          end
 
-        visit @ast
+          unless exc_block = @exceptions[exc.range]
+            exc_block = CFG::Node.new(@cfg, "exc_#{index}")
 
-        @cfg = CFG::Graph.new
+            dispatch_node = AST::Node.new(:exception_dispatch, [], keep: true)
+            exc_block.insns << dispatch_node
+            exc_block.cti = dispatch_node
+
+            @exceptions[exc.range] = exc_block
+          end
+
+          exc_block.target_labels << exc.target_offset
+
+          if finallies.find { |f| f[:second_catch] == exc }
+            exc_block.cti.children <<
+                AST::Node.new(:finally,
+                  [ exc.target_offset ])
+          else
+            exc_block.cti.children <<
+                AST::Node.new(:catch,
+                  [ (exc.exception.to_astlet if exc.exception),
+                    exc.variable.to_astlet,
+                    exc.target_offset ])
+          end
+        end
 
         @pending_label = nil
+        @pending_exc_block = nil
+        @pending_exc_range = nil
         @pending_queue = []
 
-        @ast.children.each_with_index do |node, index|
-          @pending_label ||= node.metadata[:label]
-          @pending_queue << node if ![:nop, :jump].include? node.type
+        ast.children.each_with_index do |node, index|
+          unless @pending_label
+            @pending_label = node.metadata[:label]
+
+            exception_block_for(@pending_label) do |block, range|
+              @pending_exc_block = block
+              @pending_exc_range = range
+            end
+          end
+
+          @pending_queue << node if ![:nop, :jump, :label].include? node.type
 
-          next_node  = @ast.children[index + 1]
+          next_node  = ast.children[index + 1]
           next_label = next_node.metadata[:label] if next_node
 
           case node.type
-          when :label
-            @jumps.add node.children.first
-            node.update :nop
-
           when :return_value, :return_void
             cutoff(nil, [nil])
 
@@ -44,7 +76,13 @@ module Furnace::AVM2
             cutoff(node, jumps_to)
 
           else
-            if @jumps.include? next_label
+            *, next_exception_block = exception_block_for(next_label)
+
+            if @jumps.include?(next_label) || (next_node && next_node.type == :label)
+              cutoff(nil, [next_label])
+            elsif body.exceptions.find { |ex| ex.target_offset == next_label }
+              cutoff(nil, [next_label])
+            elsif @pending_exc_block != next_exception_block
               cutoff(nil, [next_label])
             end
           end
@@ -54,33 +92,23 @@ module Furnace::AVM2
         @cfg.nodes.add exit_node
         @cfg.exit = exit_node
 
+        @exceptions.values.each do |exc_node|
+          @cfg.nodes.add exc_node
+        end
+
         @cfg.eliminate_unreachable!
         @cfg.merge_redundant!
 
         @cfg
       end
 
-      # propagate labels
-      def on_any(node)
-        return if node == @ast
-
-        label = nil
-
-        node.children.each do |child|
-          if child.is_a?(AST::Node) && child.metadata[:label]
-            if label.nil? || child.metadata[:label] < label
-              label = child.metadata[:label]
-            end
-
-            child.metadata.delete :label
-          end
-        end
-
-        node.metadata[:label] = label if label
-      end
+      private
 
       def cutoff(cti, targets)
         node = CFG::Node.new(@cfg, @pending_label, @pending_queue, cti, targets)
+        if @pending_exc_block
+          node.exception_label = @pending_exc_block.label
+        end
 
         if @cfg.nodes.empty?
           @cfg.entry = node
@@ -89,8 +117,21 @@ module Furnace::AVM2
         @cfg.nodes.add node
 
         @pending_label = nil
+        @pending_exc_block = nil
+        @pending_exc_range = nil
         @pending_queue = []
       end
+
+      def exception_block_for(label)
+        return nil unless label
+
+        @exceptions.find do |range, block|
+          if range.include? label
+            yield block, range if block_given?
+            true
+          end
+        end
+      end
     end
   end
 end

data/lib/furnace-avm2/transform/cfg_reduce.rb

@@ -1,102 +1,408 @@
 module Furnace::AVM2
   module Transform
     class CFGReduce
+      def initialize(options={})
+        @verbose = options[:verbose] || false
+
+        #@verbose = true
+      end
+
       def transform(cfg)
         @cfg   = cfg
 
         @dom   = @cfg.dominators
         @loops = @cfg.identify_loops
 
-        @visited       = Set.new
-        @loop_tails    = {}
-        @loop_nonlocal = Set.new
+        @visited        = Set.new
+        @loop_tails     = {}
+        @loop_nonlocal  = Set.new
+
+        @postcond_heads = Set.new
+        @postcond_tails = Set.new
+
+        @try_tails      = Hash.new { |h,k| h[k] = Set.new }
 
         ast, = extended_block(@cfg.entry)
 
+        @visited.add @cfg.exit
+        if @visited != @cfg.nodes
+          raise "failsafe: not all blocks visited (#{(@cfg.nodes - @visited).map(&:label).join(", ")} left)"
+        end
+
         ast
       end
 
-      def extended_block(block, stopgap=nil, loop_stack=[])
+      def possibly_wrap_eh(block, nodes, exception, loop_stack, nesting)
+        if nodes.any?
+          if exception.nil?
+            nodes
+          else
+            log nesting, "exception dispatcher"
+
+            unless exception.cti.type == :exception_dispatch
+              raise "invalid exception cti"
+            end
+
+            @visited.add exception
+
+            catches  = exception.cti.children
+            handlers = []
+
+            root, *tails = find_merge_point([ block ] + exception.targets)
+            exception.targets.zip(tails).each_with_index do |(target, tail), index|
+              log nesting, "handler #{catches[index].inspect}"
+              handler = extended_block(target, tail || root, loop_stack, nesting + 1, nil)
+
+              node = catches[index]
+              if node.type == :catch
+                exc_name, var_name = node.children
+                handlers.push AST::Node.new(:catch, [
+                  exc_name, var_name,
+                  handler
+                ], node.metadata)
+              elsif node.type == :finally
+                handlers.push AST::Node.new(:finally, [
+                  handler
+                ], node.metadata)
+              else
+                raise "unknown handler type #{node.type}"
+              end
+            end
+
+            eh_nodes = [ AST::Node.new(:try, [
+              AST::Node.new(:begin, nodes),
+            ] + handlers) ]
+
+            if tails.any? && tails.uniq.count == 1 &&
+                      @dom[tails.first].include?(exception)
+              # Handle a special case whether control doesn't flow after tails
+              # of the catches by its own, e.g. the last statement of try
+              # block is return.
+
+              tail_block = tails.first
+            elsif @try_tails.has_key? exception
+              # Handle a special case where control falls through more than
+              # one level of scopes.
+              if @try_tails[exception].count > 1
+                raise "multiple try block exit points"
+              end
+
+              tail_block = @try_tails[exception].first
+            end
+
+            if tail_block
+              tail_code = extended_block(tail_block, nil, loop_stack, nesting + 1, nil)
+              eh_nodes.concat tail_code.children
+            end
+
+            eh_nodes
+          end
+        else
+          []
+        end
+      end
+
+      def is_loop_head?(block, loop_stack)
+        (@loops.include?(block) || @postcond_tails.include?(block)) &&
+                    loop_stack.include?(block)
+      end
+
+      def is_loop_tail?(block, loop_stack)
+        @loop_tails.include?(block) &&
+                    loop_stack.include?(@loop_tails[block])
+      end
+
+      def extended_block(block, stopgap=nil, loop_stack=[], nesting=0, upper_exc=nil)
         nodes = []
+        prev_block = nil
+        current_exception = upper_exc
+        current_nodes     = []
+        exception_changed = false
+
+        log nesting, "--- STOPGAP: #{stopgap.inspect}"
 
         while block
-          if @loops.include?(block) && loop_stack.include?(block)
-            # We have just arrived to loop head. Insert `continue'
-            # and exit.
+          log nesting, "BLOCK: #{block.inspect}"
+
+          if is_loop_head?(block, loop_stack)
+            log nesting, "exit: loop head (continue stmt)"
+
             check_nonlocal_loop(loop_stack, block) do |params|
-              nodes << AST::Node.new(:continue, params)
+              current_nodes << AST::Node.new(:continue, params)
             end
+
             break
-          elsif @loop_tails.include?(block) &&
-                    loop_stack.include?(@loop_tails[block])
-            # We have just arrived to loop tail. Insert `break'
-            # and exit.
+          elsif is_loop_tail?(block, loop_stack)
+            log nesting, "exit: loop tail (break stmt)"
+
             loop = @loop_tails[block]
             check_nonlocal_loop(loop_stack, loop) do |params|
-              nodes << AST::Node.new(:break, params)
+              current_nodes << AST::Node.new(:break, params)
             end
+
+            break
+          elsif loop_stack.first == block && !@loops.include?(block)
+            log nesting, "exit: do..while cti block"
             break
           elsif block == stopgap
-            # We have just arrived to a merge point of `if'
-            # contidional. Exit.
+            log nesting, "exit: stopgap encountered"
+            break
+          elsif block.cti && block.cti.type == :exception_dispatch
+            log nesting, "exit: spurious exception dispatch traverse"
             break
+          elsif !upper_exc.nil? && block.exception.nil? && block != @cfg.exit
+            log nesting, "exit: leaving try block"
+
+            @try_tails[upper_exc].add block
+
+            break
+          elsif block == @cfg.exit
+            # We have just arrived to exit node.
+            break
+          end
+
+          log nesting, "EX: #{(current_exception.label if current_exception) || '-'} " <<
+                       "NEW-EX: #{(block.exception.label if block.exception) || '-'}"
+
+          if block.exception != current_exception
+            nodes.concat possibly_wrap_eh(prev_block, current_nodes, current_exception, loop_stack, nesting)
+
+            current_exception = block.exception
+            current_nodes     = []
+            exception_changed = true
           end
 
           if @visited.include? block
             raise "failsafe: block #{block.label} already visited"
-          elsif block != @cfg.exit
-            @visited.add block
           end
 
-          block.insns.each do |insn|
-            next if insn == block.cti
-            nodes << insn
-          end
+          prev_block = block
+          @visited.add block
 
           if block.cti
             if block.cti.type == :lookup_switch
-              # this is a switch
+              log nesting, "is a switch"
+
+              # Group cases pointing to the same blocks of code.
+              aliases = Hash[block.targets.each_index.
+                    group_by { |index| block.targets[index] }.values.
+                    map { |(main, *others)| [ main, others ] }]
+
+              # Find a merge point for all of the case branches.
+              case_branches = block.targets.values_at(*aliases.keys)
+              case_merges   = find_merge_point(case_branches)
+
+              # A possible exit point for the statement is a merge which
+              # isn't pointed to by a branch. This prediction can fail if
+              # there are empty cases.
+              possible_exit_points = (case_merges.compact - case_branches).uniq
+              if possible_exit_points.count > 1
+                raise "multiple possible switch exit points at first guess"
+              end
+
+              exit_point = possible_exit_points.first
+              log nesting, "exit point (first guess): #{exit_point.inspect}"
+
+              # Compute case predecessors for fallthrough.
+              case_predecessors = Hash.new { |h,k| h[k] = Set.new }
+
+              case_branches.zip(case_merges).each do |(branch, merge)|
+                if case_branches.include?(merge)
+                  case_predecessors[merge].add branch
+                end
+              end
+
+              # One and only one block may have multiple predecessors.
+              # In this case, it is the actual exit point; switch the
+              # prediction.
+              new_exit_point, = case_predecessors.find { |branch, pred| pred.count > 1 }
+              if new_exit_point
+                if case_predecessors.find { |branch, pred|
+                        pred.count > 1 && branch != new_exit_point }
+                  raise "multiple possible switch exit points at second guess"
+                end
+
+                exit_point = new_exit_point
+                log nesting, "exit point (second guess): #{exit_point.inspect}"
+              end
+
+              if exit_point.nil?
+                exit_point = stopgap
+                log nesting, "exit point (last restort): stopgap #{stopgap.inspect}"
+              end
+
+              # Flatten the one-element sets.
+              case_predecessors.each do |branch, pred|
+                case_predecessors[branch] = pred.first
+              end
+
+              case_successors = case_predecessors.invert
+
+              # Generate code for the actual branches. Stopgap is either the
+              # another case (fallthrough) or exit point.
+              case_bodies = case_branches.zip(case_merges).map do |(branch, merge)|
+                if case_branches.include? merge
+                  branch_stopgap = merge
+                else
+                  branch_stopgap = exit_point
+                end
+
+                extended_block(branch, branch_stopgap, loop_stack, nesting + 1, current_exception)
+              end
+
+              node = AST::Node.new(:begin)
 
-            elsif @loops.include?(block)
+              # Sort the nodes in the order of fallthrough precedence
+              # and assemble the body AST.
+              case_pool = case_branches.dup
+              while case_pool.any?
+                next_branch = case_pool.find { |c| !case_predecessors.has_key?(c) }
+                if next_branch.nil?
+                  raise "circular dependency between cases"
+                end
+
+                body = nil
+
+                while next_branch
+                  case_pool.delete next_branch
+
+                  if body && !case_predecessors.has_key?(next_branch)
+                    body.children << AST::Node.new(:break)
+                  end
+
+                  main_index = case_branches.index(next_branch)
+                  body = case_bodies[main_index]
+
+                  [ main_index, *aliases[main_index] ].each do |index|
+                    if index == 0
+                      node.children << AST::Node.new(:default)
+                    else
+                      node.children << AST::Node.new(:case, [
+                        AST::Node.new(:integer, [ index - 1 ])
+                      ])
+                    end
+                  end
+
+                  node.children << body
+
+                  next_branch = case_successors[next_branch]
+                end
+
+                body.children << AST::Node.new(:break)
+              end
+
+              current_nodes << AST::Node.new(:switch, [
+                block.cti.children.last,
+                node
+              ])
+
+              block = exit_point
+            elsif @loops.include?(block) && !@postcond_heads.include?(block)
               # we're trapped in a strange loop
-              reverse = !block.cti.children[0]
-              in_root, out_root = block.targets
+              if block.insns.first == block.cti
+                log nesting, "is a while loop"
 
-              # One of the branch targets should reside within
-              # the loop.
-              if !@loops[block].include?(in_root)
-                in_root, out_root = out_root, in_root
-                reverse = !reverse
+                loop_type = :head_cti
+                cti_block = block
+              else
+                back_edges = []
+
+                @loops[block].each do |loop_block|
+                  loop_block.targets.each do |target|
+                    # Find a back edge
+                    if @dom[loop_block].include? target
+                      back_edges << loop_block
+                    end
+                  end
+                end
+
+                if back_edges.count == 1
+                  loop_type = :tail_cti
+                  cti_block = back_edges.first
+                else
+                  raise "invalid back edge count"
+                end
+              end
+
+              if loop_type == :infinite
+                in_root, out_root = block, nil
+
+                # out_root = nil is not correct in all cases, i.e.
+                # when multiple breaks are present.
+
+                expr = AST::Node.new(:true)
+              else
+                reverse = !cti_block.cti.children[0]
+                in_root, out_root = cti_block.targets
+
+                # One of the branch targets should reside within
+                # the loop.
+                if !@loops[block].include?(in_root)
+                  in_root, out_root = out_root, in_root
+                  reverse = !reverse
+                end
+
+                # If we reversed the roots or it was a (jump-if false),
+                # then reverse the condition.
+                expr = normalize_cti_expr(cti_block, reverse)
               end
 
               # Mark the loop tail so we could detect `break' and
               # `continue' statements.
-              @loop_tails[out_root] = block
+              @loop_tails[out_root] = cti_block
 
-              # If we reversed the roots or it was a (jump-if false),
-              # then reverse the condition.
-              expr = normalize_cti_expr(block, reverse)
+              # Remove the block from visited set if it is unrelated to the
+              # current loop condition, as it should be re-processed.
+              if loop_type != :head_cti
+                @visited.delete block
+
+                @postcond_heads.add block
+                @postcond_tails.add cti_block
+              end
 
-              body = extended_block(in_root, nil, [ block, *loop_stack ])
+              # Handle a special case: all code in the loop header.
+              if loop_type == :tail_cti && cti_block == block
+                body = AST::Node.new(:begin)
+
+                append_instructions(block, body.children)
+              else
+                body = extended_block(in_root, nil, [ cti_block ] + loop_stack, nesting + 1, current_exception)
+              end
 
               # [(label name)]
               # We first parse the body and then add the label before
               # the loop body if anything in the body requires that label
               # to be present.
               if @loop_nonlocal.include?(block)
-                nodes << AST::Node.new(:label, [ loop_label(block) ])
+                current_nodes << AST::Node.new(:label, [ loop_label(block) ])
+              end
+
+              # Map loop types to node types.
+              if loop_type == :head_cti || loop_type == :infinite
+                loop_node = :while
+              else
+                loop_node = :do_while
               end
 
-              # (while (condition)
+              # (while|do-while (condition)
               #   (body ...))
-              nodes << AST::Node.new(:while, [
+              current_nodes << AST::Node.new(loop_node, [
                 expr,
                 body
               ])
 
+              # Add cti_block to visited for the do-while case.
+              if loop_type == :tail_cti
+                @visited.add cti_block
+              end
+
               block = out_root
             else
-              # this is an `if', `break' or `continue'
+              log nesting, "is a conditional"
+
+              append_instructions(block, current_nodes)
+
+              # This is an `if'.
               reverse = !block.cti.children[0]
               left_root, right_root = block.targets
 
@@ -110,6 +416,18 @@ module Furnace::AVM2
               # not have edges coming to it even from other blocks
               # dominated by this block.
 
+              # A special case: empty if().
+              if left_root == right_root
+                current_nodes << AST::Node.new(:if, [
+                  block.cti.children[1],
+                  AST::Node.new(:begin)
+                ])
+
+                block = left_root
+
+                next
+              end
+
               # If the left root isn't dominated by block,
               # then it can't be `if' branch.
               if !completely_dominated?(left_root, block)
@@ -119,8 +437,13 @@ module Furnace::AVM2
 
               # If the left root still isn't dominated by block,
               # then this is not a proper conditional.
-              unless completely_dominated?(left_root, block)
-                raise "not-well-formed if"
+              # If the left root leads to a loop head or tail, then
+              # the code will not be generated for that root, and
+              # its dominance is irrelevant.
+              if !completely_dominated?(left_root, block) &&
+                    !(is_loop_head?(left_root, loop_stack) ||
+                      is_loop_tail?(left_root, loop_stack))
+                raise "not well-formed if"
               end
 
               # If the right root is dominated by this block, which
@@ -138,8 +461,11 @@ module Furnace::AVM2
 
               # Does this conditional have an `else' block?
               if completely_dominated?(right_root, block)
-                # Yes. Find a merge point.
-                merge = find_merge_point(block, left_root, right_root, loop_stack)
+                # Yes. Find merge point.
+
+                # The function technically finds two merge points,
+                # but in case of two heads they're identical.
+                merge, = find_merge_point([ left_root, right_root ])
 
                 # If the merge search did not yield a valid node, use
                 # stopgap for the current block to avoid runaway code
@@ -150,32 +476,42 @@ module Furnace::AVM2
                 # objects contained in arguments of recursive calls. As
                 # the `if's are fully nested when well-formed, we can only
                 # check for collision with innermost stopgap block.
-                nodes << AST::Node.new(:if, [
-                  expr,
-                  extended_block(left_root,  merge || stopgap, loop_stack),
-                  extended_block(right_root, merge || stopgap, loop_stack)
-                ])
+
+                log nesting, "left"
+                left_code  = extended_block(left_root,  merge || stopgap, loop_stack, nesting + 1, current_exception)
+
+                log nesting, "right"
+                right_code = extended_block(right_root, merge || stopgap, loop_stack, nesting + 1, current_exception)
+
+                current_nodes << AST::Node.new(:if, [ expr, left_code, right_code ])
 
                 block = merge
               else
                 # No. The "right root" is actually post-if code.
-                nodes << AST::Node.new(:if, [
-                  expr,
-                  extended_block(left_root, right_root, loop_stack)
-                ])
+
+                log nesting, "one-way"
+                code = extended_block(left_root, right_root, loop_stack, nesting + 1, current_exception)
+
+                current_nodes << AST::Node.new(:if, [ expr, code ])
 
                 block = right_root
               end
             end
           elsif block.targets.count == 1
+            append_instructions(block, current_nodes)
+
             block = block.targets.first
-          elsif block == @cfg.exit
-            break
           else
             raise "invalid target count (#{block.targets.count})"
           end
         end
 
+        if exception_changed || nesting == 0
+          nodes.concat possibly_wrap_eh(prev_block, current_nodes, current_exception, loop_stack, nesting)
+        else
+          nodes = current_nodes
+        end
+
         AST::Node.new(:begin, nodes)
       end
 
@@ -191,34 +527,67 @@ module Furnace::AVM2
         end
       end
 
-      # A merge point for blocks R (root), L (left) and D (right)
-      # is first block found with BFS starting at {L,D} so that
-      # it is dominated by R, but not L or D.
-      def find_merge_point(root, left, right, loop_stack)
-        worklist = Set[left, right]
-        visited  = Set[root, left, right]
+      # Find a set of merge points for a set of partially diverged
+      # paths beginning from `heads'.
+      # E.g. here:
+      #
+      #      ----<---
+      #     /        \
+      #    A -------- B --
+      #    |\             \
+      #    | C ---- E - F--- <exit>
+      #    |      /
+      #     \- D -
+      #
+      # with A as the root and B, C and E as heads, the function reports
+      # following merge points: E for C and D, and nil for B.
+      # Note that back edge (denoted by < in the picture) is ignored.
+      def find_merge_point(heads)
+        seen  = Set[]
+
+        heads.map do |head|
+          # Trail is an ordered collection of nodes encountered during
+          # BFS. Order of nodes with same rank is irrelevant.
+          trail = []
+
+          worklist = Set[head]
+          visited  = Set[head]
+          while worklist.any?
+            node = worklist.first
+            worklist.delete node
+
+            visited.add node
+            trail.push node
+
+            # Nodes which are dominated by the current head aren't relevant
+            # for merge point search and will cause false positives.
+            unless @dom[node].include? head
+              seen.add node
+            end
 
-        while worklist.any?
-          node = worklist.first
-          worklist.delete node
+            node.targets.each do |target|
+              # Skip visited nodes.
+              if visited.include?(target)
+                next
+              end
 
-          visited.add node
+              # Skip back edges.
+              if @loops[target] && @loops[target].include?(node)
+                next
+              end
 
-          if (@dom[node].include?(root) &&
-              !(@dom[node].include?(left) ||
-                @dom[node].include?(right))) ||
-              loop_stack.include?(node)
-            return node
+              worklist.add target
+            end
           end
 
-          node.targets.each do |target|
-            next if visited.include? target
-            worklist.add target
+          trail
+        end.map do |(head, *trail)|
+          trail.find do |trail_elem|
+            seen.include?(trail_elem)
           end
+        end.map do |tail|
+          tail unless tail == @cfg.exit
         end
-
-        # The paths have diverged.
-        nil
       end
 
       # Check if the control transfer is nonlocal according to the
@@ -234,6 +603,13 @@ module Furnace::AVM2
         end
       end
 
+      def append_instructions(block, nodes)
+        block.insns.each do |insn|
+          next if insn == block.cti
+          nodes << insn
+        end
+      end
+
       def loop_label(block)
         "label#{block.label}"
       end
@@ -245,6 +621,12 @@ module Furnace::AVM2
           block.cti.children[1]
         end
       end
+
+      private
+
+      def log(nesting, what)
+        $stderr.puts "CFGr: #{"  " * nesting}#{what}" if @verbose
+      end
     end
   end
 end