furnace 0.0.1

data/lib/furnace/transform/generic/anf_build.rb

@@ -0,0 +1,153 @@
+module Furnace
+  module Transform
+    module Generic
+      class ANFBuild
+        include AST::Visitor
+
+        def transform(cfg, method)
+          @method_locals = method.local_names
+
+          @last_label = -1
+          @anf_nodes = Hash.new { |k,v| v }
+          @anf_edges = []
+
+          @anf = ANF::Graph.new
+
+          cfg.nodes.each do |node|
+            @locals = {}
+            @node   = node
+
+            @last_anf_node = nil
+
+            # At this point we can have no more than two edges.
+            @default_edge = node.default_leaving_edge
+            @other_edge   = node.leaving_edge(node.operations.last.metadata[:label])
+
+            # Transform the AST for each node to ANF, removing redundant root nodes
+            # in the process.
+            node.operations.delete_if do |operation|
+              visit operation
+
+              operation.type == :remove
+            end
+
+            # If there were no nodes created, fallback to default CFG edge.
+            @last_anf_node ||= @default_edge.target_label
+
+            # If some operations were done just for side effect, add an InNode.
+            if node.operations.any?
+              anf_in = ANF::InNode.new(@anf, node.operations)
+              @anf.nodes.add anf_in
+
+              @anf_edges << [ anf_in, @last_anf_node ]
+              @last_anf_node = anf_in
+            end
+
+            # If any locals were rebound, add a LetNode.
+            if @locals.any? || node.operations.any?
+              anf_let = ANF::LetNode.new(@anf, passed_locals)
+              @anf.nodes.add anf_let
+
+              @anf_edges << [ anf_let, @last_anf_node ]
+              @last_anf_node = anf_let
+            end
+
+            @anf_nodes[node.label] = @last_anf_node
+          end
+
+          # The root is a CFG node with label (ip) 0.
+          @anf.root = @anf_nodes[0]
+
+          @anf_edges.each do |(source_label, target_label, param)|
+            @anf.edges.add ANF::Edge.new(@anf_nodes[source_label],
+                                         @anf_nodes[target_label],
+                                         param)
+          end
+
+          [ @anf, method ]
+        end
+
+        def passed_locals
+          map = @method_locals.map do |name|
+            # Is the name rebound?
+            if @locals.include?(name)
+              [ name, @locals[name] ]
+            # Is it the middle of function?
+            elsif @node.entering_edges.any?
+              [ name, AST::LocalVariable.new(name) ]
+            # Locals default to nil.
+            else
+              [ name, nil ]
+            end
+          end
+
+          Hash[*map.flatten]
+        end
+
+        # (set-lvar :var value)
+        def on_set_lvar(ast_node)
+          @locals[ast_node.children.first] = ast_node.children.last
+
+          ast_node.update(:remove)
+        end
+
+        # (jump-if compare_to condition)
+        def on_jump_if(ast_node)
+          if ast_node.children.first == true
+            true_edge, false_edge = @other_edge, @default_edge
+          else
+            true_edge, false_edge = @default_edge, @other_edge
+          end
+
+          true_node      = ANF::LetNode.new(@anf, passed_locals)
+          false_node     = ANF::LetNode.new(@anf, passed_locals)
+          @last_anf_node = ANF::IfNode.new(@anf, ast_node.children.last)
+
+          @anf.nodes.merge [ true_node, false_node, @last_anf_node ]
+
+          @anf_edges << [ @last_anf_node, true_node, true   ] <<
+                        [ true_node,  true_edge.target_label  ]
+          @anf_edges << [ @last_anf_node, false_node, false ] <<
+                        [ false_node, false_edge.target_label ]
+
+          ast_node.update(:remove)
+        end
+
+        # (return expression)
+        def on_return(ast_node)
+          @last_anf_node = ANF::ReturnNode.new(@anf, ast_node.children.last)
+
+          @anf.nodes.add @last_anf_node
+
+          ast_node.update(:remove)
+        end
+
+        # (get-lvar :x) -> %x
+        def on_get_lvar(node)
+          node.update(:expand, AST::LocalVariable.new(node.children.first))
+        end
+
+        # AST node labels do not make sense.
+        def on_any(ast_node)
+          ast_node.metadata.delete :label
+        end
+
+        def expand_node(node)
+          node.update(:expand)
+        end
+
+        # Immediates do not have to carry metadata anymore.
+        alias :on_true :expand_node
+        alias :on_false :expand_node
+        alias :on_nil :expand_node
+        alias :on_fixnum :expand_node
+        alias :on_literal :expand_node
+
+        # We have a near infinite supply of small, unoccupied labels.
+        def make_label
+          @last_label -= 1
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/generic/cfg_build.rb

@@ -0,0 +1,89 @@
+module Furnace
+  module Transform
+    module Generic
+      class VariableTracer
+        include AST::Visitor
+
+        attr_reader :read_set, :write_set
+
+        def initialize
+          @read_set  = Set.new
+          @write_set = Set.new
+          @conflict  = false
+        end
+
+        def reset
+          @read_set.clear
+          @write_set.clear
+          @conflict = false
+        end
+
+        def conflict?
+          @conflict
+        end
+
+        def on_set_lvar(node)
+          var = node.children.first
+
+          @write_set.add var
+          @conflict ||= @read_set.include?(var)
+        end
+
+        def on_get_lvar(node)
+          var = node.children.first
+
+          @read_set.add var
+          @conflict ||= @write_set.include?(var)
+        end
+      end
+
+      class CFGBuild
+        def transform(ast, target_map, method)
+          cfg = CFG::Graph.new
+
+          tracer = VariableTracer.new
+
+          ast.children.each do |child|
+            label = child.metadata[:label]
+
+            # Transfer control to the next operation directly if this
+            # is a jump target.
+            if target_map.include? label
+              cfg.transfer({ nil => label })
+            end
+
+            # Our CFG must also be easily convertible to ANF/SSA.
+            # Split blocks if a non-SSA variable operation is encountered.
+            tracer.visit child
+
+            if tracer.conflict?
+              cfg.transfer({ nil => child.metadata[:label] })
+            end
+
+            # Expand current operation.
+            cfg.expand label, child
+
+            # Transfer control non-sequentaly if needed.
+            if child.type == :jump
+              cfg.transfer({ label => child.children[0] })
+            elsif child.type == :jump_if
+              cfg.transfer({ label => child.children[0],
+                             nil   => child.next.metadata[:label] })
+            elsif child.type == :return
+              cfg.transfer({ })
+            elsif tracer.conflict?
+              # Reset tracer below.
+            else
+              next
+            end
+
+            # There was a conflict or a control transfer. Reset the tracer.
+            tracer.reset
+          end
+
+          [ cfg, method ]
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/generic/cfg_normalize.rb

@@ -0,0 +1,41 @@
+module Furnace
+  module Transform
+    module Generic
+      class CFGNormalize
+        def transform(cfg, method)
+          cfg.nodes.each do |node|
+            # If a last operation is an unconditional jump, optimize it out.
+            last = node.operations.last
+            if last.type == :jump
+              edge = node.leaving_edge(last.metadata[:label])
+
+              node.operations.delete last
+
+              cfg.edges.delete edge
+              cfg.edges.add CFG::Edge.new(cfg, nil, node.label, edge.target.label)
+            end
+
+            # Remove no-ops.
+            node.operations.delete_if { |op| op.type == :nop }
+          end
+
+          # Remove empty nodes.
+          cfg.nodes.delete_if do |node|
+            if node.operations.empty?
+              node.entering_edges.each do |edge|
+                edge.target = node.default_leaving_edge.target
+              end
+              cfg.edges.subtract node.leaving_edges
+
+              true
+            else
+              false
+            end
+          end
+
+          [ cfg, method ]
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/generic/label_normalize.rb

@@ -0,0 +1,60 @@
+module Furnace
+  module Transform
+    module Generic
+      class LabelNormalize
+        include AST::Visitor
+
+        def transform(ast, method)
+          # Find the minimal label in each operation sub-tree.
+          # It's the operation entry point.
+          visit ast
+
+          # Traverse operations in reverse order and bypass all jump_target's,
+          # recording the forwarded address in label_map.
+          label_map  = {}
+
+          last_real_operation = nil
+          ast.children.reverse.each do |child|
+            if child.type == :jump_target
+              label = last_real_operation
+            else
+              label = child.metadata[:label]
+              last_real_operation = label
+            end
+
+            label_map[child.metadata[:label]] = label
+          end
+
+          # Remove jump_target's.
+          ast.children.reject! { |c| c.type == :jump_target }
+
+          # Find all jumpable labels and substitute the addresses to forward
+          # through jump_target's.
+          target_map = []
+
+          ast.children.each do |child|
+            if child.type == :jump || child.type == :jump_if
+              forwarded_target  = label_map[child.children[0]]
+              child.children[0] = forwarded_target
+
+              target_map << forwarded_target
+            end
+          end
+
+          [ ast, target_map, method ]
+        end
+
+        def on_any(node)
+          return if node.type == :root
+
+          child_nodes = node.children.select { |c| c.is_a? AST::Node }
+
+          new_label = child_nodes.map { |c| c.metadata[:label] }.compact.min
+          node.metadata[:label] = new_label if new_label
+
+          child_nodes.each { |c| c.metadata.delete :label }
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/optimizing/fold_constants.rb

@@ -0,0 +1,19 @@
+module Furnace
+  module Transform
+    module Optimizing
+      class FoldConstants
+        def transform(anf, method)
+          anf.nodes.each do |node|
+            if node.is_a? ANF::LetNode
+              node.try_propagate
+              node.try_eliminate
+            end
+          end
+          anf.eliminate_dead_code
+
+          [ anf, method ]
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/pipeline.rb

@@ -0,0 +1,17 @@
+module Furnace
+  module Transform
+    class Pipeline
+      def initialize(*stages)
+        @stages = stages
+      end
+
+      def run(*sequence)
+        @stages.each do |stage|
+          sequence = stage.transform *sequence
+        end
+
+        sequence
+      end
+    end
+  end
+end

data/lib/furnace/transform/rubinius/ast_build.rb

@@ -0,0 +1,53 @@
+module Furnace
+  module Transform
+    module Rubinius
+      class ASTBuild
+        def transform(method)
+          stack    = []
+          map      = {}
+          serial   = 0
+
+          ast = AST::Node.new(:root)
+
+          method.decode.each do |opcode|
+            ins = opcode.instruction
+
+            node = AST::Node.new("rbx_#{ins.opcode}")
+            node.metadata[:label] = opcode.ip
+            node.children += opcode.args
+
+            # Compute the real value of consumed values.
+            case ins.stack_consumed
+            when Fixnum
+              consumed = ins.stack_consumed
+            when Array
+              #p ins.stack_consumed, opcode.args
+              consumed = ins.stack_consumed[0] + opcode.args.last
+            end
+
+            # Pop consumed values and attach to current node.
+            consumed.times.map { map[stack.pop] }.reverse.each do |child|
+              child.parent = node
+              node.children << child
+            end
+
+            # Push back and map the results.
+            if ins.stack_produced == 0 || ins.opcode == :ret
+              node.parent = ast
+              ast.children << node
+            elsif ins.stack_produced == 1
+              map[serial] = node
+              stack.push serial
+
+              serial += 1
+            else
+              raise RuntimeError, "don't know what to do with opcode #{opcode.inspect}"
+            end
+          end
+
+          [ ast, method ]
+        end
+      end
+    end
+  end
+end

data/lib/furnace/transform/rubinius/ast_normalize.rb

@@ -0,0 +1,170 @@
+module Furnace
+  module Transform
+    module Rubinius
+      class ASTNormalize
+        include AST::Visitor
+
+        def transform(ast, method)
+          @locals   = method.local_names
+          @literals = method.literals
+
+          visit ast
+
+          [ ast, method ]
+        end
+
+        # (rbx-meta-push-0) -> 0
+        def on_rbx_meta_push_0(node)
+          node.update(:fixnum, [0], :constant => true)
+        end
+
+        # (rbx-meta-push-1) -> 1
+        def on_rbx_meta_push_1(node)
+          node.update(:fixnum, [1], :constant => true)
+        end
+
+        # (rbx-meta-push-2) -> 2
+        def on_rbx_meta_push_2(node)
+          node.update(:fixnum, [2], :constant => true)
+        end
+
+        # (rbx-push-int f) -> f
+        def on_rbx_push_int(node)
+          node.update(:fixnum, nil, :constant => true)
+        end
+
+        # (rbx-push-literal l) -> l
+        def on_rbx_push_literal(node)
+          node.update(:literal, nil, :constant => true)
+        end
+
+        # (rbx-push-nil) -> (nil)
+        def on_rbx_push_nil(node)
+          node.update(:nil, nil, :constant => true)
+        end
+
+        # (rbx-string-dup s) -> (dup s)
+        def on_rbx_string_dup(node)
+          node.update(:dup)
+        end
+
+        # (rbx-pop x) -> x
+        def on_rbx_pop(node)
+          child = node.children.first
+          child.update(:nop) if child.metadata[:constant]
+
+          node.update(:expand, [
+            child,
+            AST::Node.new(:jump_target, [], node.metadata)
+          ], nil)
+        end
+
+        # (rbx-*) -> .
+        def make_jump_target(node)
+          node.update(:jump_target)
+        end
+        alias :on_rbx_check_interrupts :make_jump_target
+        alias :on_rbx_allow_private :make_jump_target
+
+        # (rbx-push-self) -> (self)
+        def on_rbx_push_self(node)
+          node.update(:self)
+        end
+
+        # (rbx-push-local n) -> (get-local n)
+        def on_rbx_push_local(node)
+          node.update(:get_lvar, [ @locals[node.children.first] ])
+        end
+
+        # (rbx-set-local n v) -> (set-local n v)
+        def on_rbx_set_local(node)
+          node.update(:set_lvar, [ @locals[node.children.first], node.children.last ])
+        end
+
+        # (rbx-push-ivar n) -> (get-ivar n)
+        def on_rbx_push_ivar(node)
+          node.update(:get_ivar, [ @literals[node.children.first] ])
+        end
+
+        # (rbx-set-ivar n v) -> (set-ivar n v)
+        def on_rbx_set_ivar(node)
+          node.update(:set_ivar, [ @literals[node.children.first], node.children.last ])
+        end
+
+        # (rbx-push-const-fast n x) -> (const n)
+        def on_rbx_push_const_fast(node)
+          node.update(:const, [ node.children.first ])
+        end
+
+        # (rbx-find-const n c) -> (const n c)
+        def on_rbx_find_const(node)
+          node.update(:const, [ @literals[node.children.first], node.children.last ])
+        end
+
+        # (rbx-ret x) -> (return x)
+        def on_rbx_ret(node)
+          node.update(:return)
+        end
+
+        # (rbx-send-method msg receiver) -> (send msg receiver)
+        def on_rbx_send_method(node)
+          node.update(:send, [
+            AST::MethodName.new(node.children[0]),
+            node.children[1]
+          ])
+        end
+
+        # (rbx-send-stack msg count receiver args...) -> (send msg receiver args...)
+        def on_rbx_send_stack(node)
+          node.update(:send, [
+            AST::MethodName.new(node.children[0]),  # message
+            node.children[2],                       # receiver
+            *node.children[3..-1]                   # args
+          ])
+        end
+
+        # (rbx-send-stack-with-block msg count receiver args... block) -> (send-with-block msg receiver args... block)
+        def on_rbx_send_stack_with_block(node)
+          node.update(:send_with_block, [
+            AST::MethodName.new(node.children[0]),  # message
+            node.children[2],                       # receiver
+            *node.children[3..-1]                   # args
+          ])
+        end
+
+        # (rbx-create-block block) -> (lambda block)
+        def on_rbx_create_block(node)
+          $block = node.children.first
+          node.update(:lambda, [ "FAIL" ])
+        end
+
+        # (rbx-meta-* op receiver arg) -> (send op receiver arg)
+        def on_rbx_send_op_any(node)
+          node.update(:send, [
+            AST::MethodName.new(node.children[0]),
+            *node.children[1..-1]
+          ])
+        end
+        alias :on_rbx_meta_send_op_plus :on_rbx_send_op_any
+        alias :on_rbx_meta_send_op_minus :on_rbx_send_op_any
+        alias :on_rbx_meta_send_op_gt :on_rbx_send_op_any
+        alias :on_rbx_meta_send_op_lt :on_rbx_send_op_any
+        alias :on_rbx_meta_to_s :on_rbx_send_op_any
+
+        # (rbx-goto-if-* block condition) -> (jump-if block value condition)
+        def on_rbx_goto_if_false(node)
+          node.update(:jump_if, [ node.children[0], false, node.children[1] ])
+        end
+
+        def on_rbx_goto_if_true(node)
+          node.update(:jump_if, [ node.children[0], true, node.children[1] ])
+        end
+
+        # (rbx-goto block) -> (jump block)
+        def on_rbx_goto(node)
+          node.update(:jump)
+        end
+      end
+    end
+  end
+end

data/lib/furnace/version.rb

@@ -0,0 +1,3 @@
+module Furnace
+  VERSION = "0.0.1"
+end

data/lib/furnace.rb

@@ -0,0 +1,37 @@
+require "furnace/version"
+
+require "set"
+
+require "furnace/ast/node"
+require "furnace/ast/symbolic_node"
+require "furnace/ast/visitor"
+
+require "furnace/cfg/node"
+require "furnace/cfg/edge"
+require "furnace/cfg/graph"
+
+require "furnace/anf/node"
+require "furnace/anf/edge"
+require "furnace/anf/let_node"
+require "furnace/anf/in_node"
+require "furnace/anf/if_node"
+require "furnace/anf/return_node"
+require "furnace/anf/graph"
+
+require "furnace/transform/pipeline"
+
+require "furnace/transform/rubinius/ast_build"
+require "furnace/transform/rubinius/ast_normalize"
+
+require "furnace/transform/generic/label_normalize"
+require "furnace/transform/generic/cfg_build"
+require "furnace/transform/generic/cfg_normalize"
+require "furnace/transform/generic/anf_build"
+
+require "furnace/transform/optimizing/fold_constants"
+
+require "furnace/graphviz"
+
+if RUBY_ENGINE != "rbx"
+  raise "Sorry, Furnace only works on Rubinius."
+end