furnace 0.3.1 → 0.4.0.beta.1

data/.gitignore

@@ -5,3 +5,4 @@ pkg/*
 *.sublime-*
 doc/
 .yardoc/
+coverage/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+ - 1.9.3
+ - jruby-19mode

data/Gemfile

@@ -1,5 +1,4 @@
 source "http://rubygems.org"
 
 # Specify your gem's dependencies in furnace.gemspec
-gemspec
-gem 'bacon', github: 'chneukirchen/bacon'
+gemspec

data/{LICENSE → LICENSE.MIT}

@@ -1,20 +1,20 @@
-Copyright (c) 2011-2012  Peter Zotov <whitequark@whitequark.org>
+Copyright (c) 2011-2013  Peter Zotov <whitequark@whitequark.org>
 
-Permission is hereby granted, free of charge, to any person obtaining a 
-copy of this software and associated documentation files (the 
-"Software"), to deal in the Software without restriction, including 
-without limitation the rights to use, copy, modify, merge, publish, 
-distribute, sublicense, and/or sell copies of the Software, and to 
-permit persons to whom the Software is furnished to do so, subject to 
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
 the following conditions:
 
-The above copyright notice and this permission notice shall be included 
+The above copyright notice and this permission notice shall be included
 in all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -5,11 +5,7 @@ task :default => :test
 
 desc "Run test suite"
 task :test do
-  require 'bacon'
-  Bacon.summary_at_exit
-  Dir["test/**/*_test.rb"].each do |file|
-    load file
-  end
+  sh "bacon test/*_test.rb"
 end
 
 PAGES_REPO = 'git@github.com:whitequark/furnace'

data/furnace.gemspec

@@ -17,8 +17,12 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_development_dependency 'rake'
-  s.add_development_dependency 'bacon', '~> 1.1'
+  s.add_dependency 'ansi'
+
+  s.add_development_dependency 'rake',  '~> 10.0'
+  s.add_development_dependency 'bacon', '~> 1.2'
+  s.add_development_dependency 'bacon-colored_output'
+  s.add_development_dependency 'simplecov'
   s.add_development_dependency 'yard'
-  s.add_development_dependency 'redcarpet'
+  s.add_development_dependency 'kramdown'
 end

data/lib/furnace/ast/node.rb

@@ -130,6 +130,20 @@ module Furnace::AST
       "(#{fancy_type} ...)"
     end
 
+    # Returns {#children}. This is very useful in order to decompose nodes
+    # concisely. For example:
+    #
+    #     node = s(:gasgn, :$foo, s(:integer, 1))
+    #     s
+    #     var_name, value = *node
+    #     p var_name # => :$foo
+    #     p value    # => (integer 1)
+    #
+    # @return [Array]
+    def to_a
+      children
+    end
+
     # Converts `self` to a pretty-printed s-expression.
     #
     # @param  [Integer] indent Base indentation level.

data/lib/furnace/ast/processor.rb

@@ -37,7 +37,7 @@ module Furnace::AST
   #       def process_binary_op(node)
   #         # Children aren't decomposed automatically; it is suggested to use Ruby
   #         # multiple assignment expansion, as it is very convenient here.
-  #         left_expr, right_expr = node.children
+  #         left_expr, right_expr = *node
   #
   #         # AST::Node#updated won't change node type if nil is passed as a first
   #         # argument, which allows to reuse the same handler for multiple node types
@@ -54,11 +54,11 @@ module Furnace::AST
   #       def on_negate(node)
   #         # It is also possible to use #process_all for more compact code
   #         # if every child is a Node.
-  #         node.updated(nil, process_all(node.children))
+  #         node.updated(nil, process_all(node))
   #       end
   #
   #       def on_store(node)
-  #         expr, variable_name = node.children
+  #         expr, variable_name = *node
   #
   #         # Note that variable_name is not a Node and thus isn't passed to #process.
   #         node.updated(nil, [
@@ -74,7 +74,7 @@ module Furnace::AST
   #       end
   #
   #       def on_each(node)
-  #         node.updated(nil, process_all(node.children))
+  #         node.updated(nil, process_all(node))
   #       end
   #     end
   #
@@ -95,7 +95,7 @@ module Furnace::AST
   #       def compute_op(node)
   #         # First, node children are processed and then unpacked to local
   #         # variables.
-  #         nodes = process_all(node.children)
+  #         nodes = process_all(node)
   #
   #         if nodes.all? { |node| node.type == :integer }
   #           # If each of those nodes represents a literal, we can fold this
@@ -186,7 +186,7 @@ module Furnace::AST
   #         # (divide
   #         #   (integer 1)
   #         #   (divide (integer 1) (integer 0))
-  #         left, right = process_all(node.children)
+  #         left, right = process_all(node)
   #
   #         if right.type == :integer &&
   #            right.children.first == 0
@@ -250,7 +250,7 @@ module Furnace::AST
     # @param  [Array<AST::Node>] nodes
     # @return [Array<AST::Node>]
     def process_all(nodes)
-      nodes.map do |node|
+      nodes.to_a.map do |node|
         process node
       end
     end

data/lib/furnace/ssa/argument.rb

@@ -0,0 +1,23 @@
+module Furnace
+  class SSA::Argument < SSA::NamedValue
+    attr_reader :type
+
+    def initialize(function, type, name)
+      super(function, name)
+      self.type = type
+    end
+
+    def type=(type)
+      @type = type.to_type if type
+    end
+
+    def has_side_effects?
+      true
+    end
+
+    def pretty_print(p=SSA::PrettyPrinter.new)
+      p.type type
+      p.name name
+    end
+  end
+end

data/lib/furnace/ssa/basic_block.rb

@@ -0,0 +1,117 @@
+module Furnace
+  class SSA::BasicBlock < SSA::NamedValue
+    def initialize(function, name=nil, insns=[])
+      super(function, name)
+      @instructions = insns.to_a
+    end
+
+    def initialize_copy(original)
+      super
+
+      @instructions = []
+    end
+
+    def to_a
+      @instructions.dup
+    end
+
+    def include?(instruction)
+      @instructions.include? instruction
+    end
+
+    def each(type=nil, &proc)
+      if type.nil?
+        @instructions.each(&proc)
+      else
+        return to_enum(:each, type) if proc.nil?
+
+        @instructions.each do |insn|
+          if insn.instance_of? type
+            yield insn
+          end
+        end
+      end
+    end
+
+    alias each_instruction each
+
+    def append(instruction)
+      @instructions.push instruction
+    end
+
+    alias << append
+
+    def insert(before, instruction)
+      unless index = @instructions.index(before)
+        raise ArgumentError, "Instruction #{before} is not found"
+      end
+
+      @instructions.insert index, instruction
+    end
+
+    def replace(instruction, replace_with)
+      insert instruction, replace_with
+      remove instruction
+    end
+
+    def remove(instruction)
+      @instructions.delete instruction
+    end
+
+    def terminator
+      @instructions.last
+    end
+
+    def successor_names
+      terminator.successors
+    end
+
+    def successors
+      successor_names.map do |label|
+        @function.find(label)
+      end
+    end
+
+    def predecessor_names
+      predecessors.map(&:name)
+    end
+
+    def predecessors
+      @function.predecessors_for(@name)
+    end
+
+    def exits?
+      terminator.exits?
+    end
+
+    def self.to_type
+      SSA::BasicBlockType.instance
+    end
+
+    def type
+      self.class.to_type
+    end
+
+    def constant?
+      true
+    end
+
+    def pretty_print(p=SSA::PrettyPrinter.new)
+      p.text    @name, ":"
+      p.newline
+
+      each do |insn|
+        p << '   '
+        insn.pretty_print(p)
+        p.newline
+      end
+
+      p
+    end
+
+    def inspect_as_value(p=SSA::PrettyPrinter.new)
+      p.keyword 'label'
+      p.name    name
+    end
+  end
+end

data/lib/furnace/ssa/builder.rb

@@ -0,0 +1,100 @@
+module Furnace
+  class SSA::Builder
+    attr_reader   :function
+    attr_accessor :block
+
+    def self.scope
+      SSA
+    end
+
+    def initialize(name, arguments=[], return_type=nil)
+      @function = SSA::Function.new(name, [], return_type)
+      @function.arguments = arguments.map do |(type, name)|
+        SSA::Argument.new(@function, type, name)
+      end
+
+      @block = @function.entry = add_block
+    end
+
+    def lookup_insn(opcode)
+      self.class.scope.const_get SSA.opcode_to_class_name(opcode)
+    end
+
+    def add_block
+      block = SSA::BasicBlock.new(@function)
+      @function.add block
+
+      if block_given?
+        branch block
+        @block = block
+
+        yield
+      else
+        block
+      end
+    end
+
+    def append(instruction, *args)
+      insn = lookup_insn(instruction).new(@block, *args)
+      @block.append insn
+
+      insn
+    end
+
+    def branch(target)
+      append(:branch, [ target ])
+    end
+
+    def phi(type, mapping)
+      append(:phi, type, Hash[mapping])
+    end
+
+    def fork(post_block)
+      old_block = @block
+      new_block = add_block
+
+      @block    = new_block
+
+      value     = yield old_block
+
+      branch post_block
+
+      [ new_block, value ]
+    ensure
+      @block    = old_block
+    end
+
+    def control_flow_op(instruction, type=nil, uses)
+      cond_block = @block
+      post_block = add_block
+
+      mapping = yield cond_block, post_block
+
+      targets = mapping.map { |(target, _)| target }
+      append(instruction, uses + targets)
+
+      @block = post_block
+      phi(type, mapping.map do |(target, value)|
+                  if target == post_block
+                    [cond_block, value]
+                  else
+                    [target, value]
+                  end
+                end)
+    end
+
+    def return(value)
+      append(:return, [ value ])
+    end
+
+    def method_missing(opcode, *args)
+      class_name = SSA.opcode_to_class_name(opcode)
+
+      if self.class.scope.const_defined? class_name
+        append opcode, *args
+      else
+        super
+      end
+    end
+  end
+end

data/lib/furnace/ssa/constant.rb

@@ -0,0 +1,43 @@
+module Furnace
+  class SSA::Constant < SSA::Value
+    attr_reader   :type
+    attr_accessor :value
+
+    def initialize(type, value)
+      super()
+
+      self.type = type
+      @value    = value
+    end
+
+    def type=(type)
+      @type     = type.to_type
+    end
+
+    def constant?
+      true
+    end
+
+    def ==(other)
+      if other.respond_to? :to_value
+        other_value = other.to_value
+
+        other_value.constant? &&
+            other_value.type  == type &&
+            other_value.value == value
+      else
+        false
+      end
+    end
+
+    def inspect_as_value(p=SSA::PrettyPrinter.new)
+      p.type type
+      p.text @value.inspect unless type == SSA.void
+      p
+    end
+
+    def inspect
+      pretty_print
+    end
+  end
+end

data/lib/furnace/ssa/function.rb

@@ -0,0 +1,191 @@
+module Furnace
+  class SSA::Function
+    attr_reader   :original_name
+    attr_accessor :name
+    attr_reader   :arguments
+    attr_accessor :return_type
+
+    attr_accessor :entry
+
+    def initialize(name=nil, arguments=[], return_type=SSA.void)
+      @original_name = name
+      @name          = name
+      self.arguments = arguments
+      @return_type   = return_type
+
+      @basic_blocks  = Set.new
+
+      @name_prefixes = [""].to_set
+      @next_name     = 0
+    end
+
+    def initialize_copy(original)
+      @name = @original_name
+
+      value_map = Hash.new do |value_map, value|
+        new_value = value.dup
+        value_map[value] = new_value
+
+        if new_value.is_a? SSA::User
+          new_value.function = self
+          new_value.operands = value.translate_operands(value_map)
+        end
+
+        new_value
+      end
+
+      @arguments = @arguments.map do |arg|
+        new_arg = arg.dup
+        new_arg.function = self
+        value_map[arg] = new_arg
+
+        new_arg
+      end
+
+      @basic_blocks = @basic_blocks.map do |bb|
+        new_bb = bb.dup
+        new_bb.function = self
+
+        value_map[bb] = new_bb
+
+        new_bb
+      end
+
+      @entry = value_map[@entry]
+
+      original.each do |bb|
+        new_bb = value_map[bb]
+
+        bb.each do |insn|
+          new_insn = value_map[insn]
+          new_insn.basic_block = new_bb
+          new_bb.append new_insn
+        end
+      end
+    end
+
+    def arguments=(arguments)
+      @arguments = sanitize_arguments(arguments)
+    end
+
+    def make_name(prefix=nil)
+      if prefix.nil?
+        (@next_name += 1).to_s
+      else
+        prefix = prefix.to_s
+
+        if @name_prefixes.include? prefix
+          "#{prefix}.#{@next_name += 1}"
+        else
+          @name_prefixes.add prefix
+          prefix
+        end
+      end
+    end
+
+    def each(&proc)
+      @basic_blocks.each(&proc)
+    end
+
+    alias each_basic_block each
+
+    def include?(name)
+      @basic_blocks.any? { |n| n.name == name }
+    end
+
+    def find(name)
+      if block = @basic_blocks.find { |n| n.name == name }
+        block
+      else
+        raise ArgumentError, "Cannot find basic block #{name}"
+      end
+    end
+
+    def add(block)
+      @basic_blocks.add block
+    end
+
+    alias << add
+
+    def remove(block)
+      @basic_blocks.delete block
+    end
+
+    def each_instruction(type=nil, &proc)
+      return to_enum(:each_instruction, type) if proc.nil?
+
+      each do |block|
+        block.each(type, &proc)
+      end
+    end
+
+    def predecessors_for(name)
+      predecessors = Set[]
+
+      each do |block|
+        if block.successor_names.include? name
+          predecessors << block
+        end
+      end
+
+      predecessors
+    end
+
+    def self.to_type
+      SSA::FunctionType.instance
+    end
+
+    def to_value
+      SSA::Constant.new(self.class.to_type, @name)
+    end
+
+    def pretty_print(p=SSA::PrettyPrinter.new)
+      p.keyword 'function'
+      p.type    @return_type
+      p.text    @name, '('
+      p.objects @arguments
+      p.text    ') {'
+      p.newline
+
+      each do |basic_block|
+        basic_block.pretty_print(p)
+        p.newline
+      end
+
+      p.text    "}"
+      p.newline
+    end
+
+    alias inspect pretty_print
+
+    def to_graphviz
+      Graphviz.new do |graph|
+        @basic_blocks.each do |block|
+          options = {}
+
+          if @entry == block
+            options.merge!({ color: 'green' })
+          elsif block.returns?
+            options.merge!({ color: 'red'   })
+          end
+
+          graph.node block.name, block.inspect, options
+
+          block.successor_names.each do |name|
+            graph.edge block.name, name
+          end
+        end
+      end
+    end
+
+    protected
+
+    def sanitize_arguments(arguments)
+      arguments.each_with_index do |argument, index|
+        if !argument.is_a?(SSA::Argument)
+          raise ArgumentError, "function #{@name} arguments: #{argument.inspect} (at #{index}) is not an Argument"
+        end
+      end
+    end
+  end
+end

data/lib/furnace/ssa/generic_instruction.rb

@@ -0,0 +1,14 @@
+module Furnace
+  class SSA::GenericInstruction < SSA::Instruction
+    attr_reader :type
+
+    def initialize(basic_block, type=nil, uses=[], name=basic_block.function.make_name)
+      super(basic_block, uses, name)
+      self.type = type
+    end
+
+    def type=(type)
+      @type = type.to_type if type
+    end
+  end
+end

data/lib/furnace/ssa/generic_type.rb

@@ -0,0 +1,16 @@
+module Furnace
+  class SSA::GenericType < SSA::Type
+    def parameters
+      nil
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) &&
+          other.parameters == parameters
+    end
+
+    def hash
+      [self.class, parameters].hash
+    end
+  end
+end