furnace 0.3.1 → 0.4.0.beta.1

data/lib/furnace/ssa/instruction.rb

@@ -0,0 +1,92 @@
+module Furnace
+  class SSA::Instruction < SSA::User
+    def self.opcode
+      @opcode ||= SSA.class_name_to_opcode(self)
+    end
+
+    def self.syntax(&block)
+      SSA::InstructionSyntax.new(self).evaluate(&block)
+    end
+
+    attr_accessor :basic_block
+
+    def initialize(basic_block, operands=[], name=nil)
+      super(basic_block.function, operands, name)
+      @basic_block = basic_block
+    end
+
+    def initialize_copy(original)
+      super
+
+      @operands = nil
+    end
+
+    def opcode
+      self.class.opcode
+    end
+
+    def remove
+      @basic_block.remove self
+      detach
+    end
+
+    def replace_with(value)
+      replace_all_uses_with value
+
+      if value.is_a? SSA::Instruction
+        @basic_block.replace self, value
+        detach
+      else
+        remove
+      end
+    end
+
+    def has_side_effects?
+      false
+    end
+
+    def terminator?
+      false
+    end
+
+    def pretty_print(p=SSA::PrettyPrinter.new)
+      unless type == SSA.void
+        p.type  type
+        p.name  name
+        p.text  '='
+      end
+
+      if valid?
+        p.keyword opcode
+      else
+        p.keyword_invalid opcode
+      end
+
+      pretty_parameters(p)
+      pretty_operands(p)
+
+      p
+    end
+
+    def inspect_as_value(p=SSA::PrettyPrinter.new)
+      if type == SSA.void
+        p.type  type
+      else
+        super
+      end
+    end
+
+    protected
+
+    def pretty_parameters(p)
+    end
+
+    def pretty_operands(p)
+      if @operands
+        p.values @operands
+      else
+        p.text '<DETACHED>'
+      end
+    end
+  end
+end

data/lib/furnace/ssa/instruction_syntax.rb

@@ -0,0 +1,109 @@
+module Furnace
+  class SSA::InstructionSyntax
+    def initialize(klass)
+      @klass    = klass
+      @operands = {}
+      @splat    = nil
+    end
+
+    def evaluate
+      yield self
+
+      codegen
+    end
+
+    def operand(name, type=nil)
+      check_for_splat
+
+      type = type.to_type unless type.nil?
+      @operands[name.to_sym] = type
+    end
+
+    def splat(name)
+      check_for_splat
+
+      @splat = name.to_sym
+    end
+
+    protected
+
+    def check_for_splat
+      if @splat
+        raise ArgumentError, "There should be at most one splat operand in tail position"
+      end
+    end
+
+    def codegen
+      operands, splat = @operands, @splat
+
+      @klass.class_eval do
+        operands.each_with_index do |(operand, type), index|
+          define_method(operand) do
+            @operands[index]
+          end
+
+          define_method(:"#{operand}=") do |value|
+            value = value.to_value
+
+            @operands[index].remove_use self if @operands[index]
+            @operands[index] = value
+            value.add_use self if value
+
+            value
+          end
+        end
+
+        if splat
+          define_method splat do
+            @operands[operands.size..-1]
+          end
+
+          define_method(:"#{splat}=") do |values|
+            values = values.map(&:to_value)
+
+            update_use_lists do
+              @operands[operands.size, @operands.size - operands.size] = values
+            end
+
+            values
+          end
+        end
+
+        define_method(:operands=) do |values|
+          if splat && values.size < operands.size
+            raise ArgumentError, "Not enough operands provided: #{values.size} for #{operands.size}"
+          elsif !splat && values.size != operands.size
+            raise ArgumentError, "Incorrect number of operands provided: #{values.size} for #{operands.size}"
+          end
+
+          values = values.map(&:to_value)
+
+          update_use_lists do
+            @operands = values
+          end
+
+          verify!
+
+          values
+        end
+
+        define_method(:verify!) do |ignore_nil_types=true|
+          return if @operands.nil?
+
+          operands.each_with_index do |(operand, type), index|
+            next if type.nil?
+
+            value = send operand
+            next if ignore_nil_types && value.type.nil?
+
+            if value.type.nil? || !value.type.subtype_of?(type)
+              raise TypeError, "Wrong type for operand ##{index + 1} `#{operand}': #{SSA.inspect_type type} is expected, #{SSA.inspect_type value.type} is present"
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/furnace/ssa/instructions/branch.rb

@@ -0,0 +1,11 @@
+module Furnace
+  class SSA::BranchInsn < SSA::TerminatorInstruction
+    syntax do |s|
+      s.operand :target, SSA::BasicBlock
+    end
+
+    def exits?
+      false
+    end
+  end
+end

data/lib/furnace/ssa/instructions/phi.rb

@@ -0,0 +1,63 @@
+module Furnace
+  class SSA::PhiInsn < SSA::GenericInstruction
+    def initialize(basic_block, type, operands={}, name=nil)
+      super(basic_block, type, operands, name)
+    end
+
+    def each_operand(&block)
+      return to_enum(:each_operand) if block.nil?
+
+      if @operands
+        @operands.each do |basic_block, value|
+          yield basic_block
+          yield value
+        end
+      end
+    end
+
+    def operands=(operands)
+      update_use_lists do
+        @operands = operands
+      end
+    end
+
+    def translate_operands(map)
+      Hash[@operands.map do |basic_block, value|
+        [ map[basic_block], map[value] ]
+      end]
+    end
+
+    protected
+
+    def pretty_operands(p)
+      @operands.each_with_index do |(basic_block, value), index|
+        p.name basic_block.name
+        p.text '=>'
+        value.inspect_as_value p
+
+        p << ',' if index < @operands.count - 1
+      end
+    end
+
+    def replace_uses_of_operands(use, new_use)
+      if @operands.include? use
+        value = @operands[use]
+        @operands.delete use
+        @operands[new_use] = value
+
+        true
+      else
+        found = false
+
+        @operands.each do |basic_block, operand|
+          if operand == use
+            found = true
+            @operands[basic_block] = new_use
+          end
+        end
+
+        found
+      end
+    end
+  end
+end

data/lib/furnace/ssa/instructions/return.rb

@@ -0,0 +1,11 @@
+module Furnace
+  class SSA::ReturnInsn < SSA::TerminatorInstruction
+    syntax do |s|
+      s.operand :value
+    end
+
+    def exits?
+      true
+    end
+  end
+end

data/lib/furnace/ssa/module.rb

@@ -0,0 +1,52 @@
+module Furnace
+  class SSA::Module
+    def initialize
+      @functions = {}
+      @next_id   = 0
+    end
+
+    def to_a
+      @functions.values
+    end
+
+    def each(&block)
+      @functions.values.each(&block)
+    end
+
+    def include?(name)
+      @functions.include? name
+    end
+
+    def [](name)
+      unless @functions.include? name
+        raise ArgumentError, "function #{name} is not found"
+      end
+
+      @functions[name]
+    end
+
+    def add(function, name_prefix=nil)
+      if name_prefix ||
+          function.name.nil? ||
+          @functions.include?(function.name)
+
+        basename = name_prefix || function.name || 'function'
+        basename = basename.gsub /;\d+$/, ''
+
+        function.name = "#{basename};#{make_id}"
+      end
+
+      @functions[function.name] = function
+    end
+
+    def remove(name)
+      @functions.delete name
+    end
+
+    protected
+
+    def make_id
+      @next_id += 1
+    end
+  end
+end

data/lib/furnace/ssa/named_value.rb

@@ -0,0 +1,25 @@
+module Furnace
+  class SSA::NamedValue < SSA::Value
+    attr_accessor :function
+    attr_reader   :name
+
+    def initialize(function, name)
+      super()
+
+      @function = function
+      self.name = name
+    end
+
+    def name=(name)
+      @name = @function.make_name(name)
+    end
+
+    def inspect_as_value(p=SSA::PrettyPrinter.new)
+      p.name name
+    end
+
+    def inspect
+      pretty_print
+    end
+  end
+end

data/lib/furnace/ssa/pretty_printer.rb

@@ -0,0 +1,113 @@
+require 'ansi'
+
+module Furnace
+  class SSA::PrettyPrinter
+    @colorize = true
+
+    class << self
+      attr_accessor :colorize
+    end
+
+    def initialize(colorize=self.class.colorize)
+      @colorize   = colorize
+      @buffer     = ""
+      @need_space = false
+
+      yield self if block_given?
+    end
+
+    def to_s
+      @buffer
+    end
+
+    alias to_str to_s
+
+    def ==(other)
+      to_s == other
+    end
+
+    def =~(other)
+      to_s =~ other
+    end
+
+    def <<(what)
+      @buffer << what
+
+      self
+    end
+
+    def text(*what)
+      what = what.map(&:to_s)
+      return if what.all?(&:empty?)
+
+      ensure_space do
+        self << what.join
+      end
+    end
+
+    def newline
+      @need_space = false
+
+      self << "\n"
+    end
+
+    def name(what)
+      text '%', what
+    end
+
+    def type(what)
+      text with_ansi(:green) { Furnace::SSA.inspect_type(what) }
+    end
+
+    def keyword(what)
+      text with_ansi(:bright, :white) { what.to_s }
+    end
+
+    def keyword_invalid(what)
+      if @colorize
+        text with_ansi(:bright, :red) { what.to_s }
+      else
+        text "!#{what}".to_s
+      end
+    end
+
+    def objects(objects, separator=",", printer=:pretty_print)
+      objects.each_with_index do |object, index|
+        object.send(printer, self)
+
+        self << separator if index < objects.count - 1
+      end
+
+      self
+    end
+
+    def values(values, separator=",")
+      objects(values, separator, :inspect_as_value)
+    end
+
+    protected
+
+    def with_ansi(*colors)
+      string = yield
+
+      if @colorize
+        ANSI::Code.ansi(yield, *colors)
+      else
+        yield
+      end
+    end
+
+    def ensure_space(need_space_after=true)
+      if @need_space
+        self << " "
+        @need_space = false
+      end
+
+      yield
+
+      @need_space = need_space_after
+
+      self
+    end
+  end
+end

data/lib/furnace/ssa/terminator_instruction.rb

@@ -0,0 +1,24 @@
+module Furnace
+  class SSA::TerminatorInstruction < SSA::Instruction
+    def has_side_effects?
+      true
+    end
+
+    def terminator?
+      true
+    end
+
+    def exits?
+      raise NotImplementedError, "reimplement SSA::TerminatorInstruction#exits? in a subclass"
+    end
+
+    def successors
+      operands.
+        select do |value|
+          value.type == SSA::BasicBlockType.instance
+        end.map do |value|
+          value.name
+        end
+    end
+  end
+end

data/lib/furnace/ssa/type.rb

@@ -0,0 +1,27 @@
+module Furnace
+  class SSA::Type
+    def to_type
+      self
+    end
+
+    def monotype?
+      true
+    end
+
+    def ==(other)
+      other.instance_of?(self.class)
+    end
+
+    def hash
+      [self.class].hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def subtype_of?(other)
+      self == other
+    end
+  end
+end

data/lib/furnace/ssa/types/basic_block.rb

@@ -0,0 +1,11 @@
+module Furnace
+  class SSA::BasicBlockType < SSA::Type
+    def self.instance
+      @instance ||= new
+    end
+
+    def inspect
+      "label"
+    end
+  end
+end

data/lib/furnace/ssa/types/function.rb

@@ -0,0 +1,11 @@
+module Furnace
+  class SSA::FunctionType < SSA::Type
+    def self.instance
+      @instance ||= new
+    end
+
+    def inspect
+      "function"
+    end
+  end
+end

data/lib/furnace/ssa/types/void.rb

@@ -0,0 +1,15 @@
+module Furnace
+  class SSA::VoidType < SSA::Type
+    def inspect
+      'void'
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.value
+      @value ||= SSA::Constant.new(instance, nil)
+    end
+  end
+end

data/lib/furnace/ssa/user.rb

@@ -0,0 +1,84 @@
+module Furnace
+  class SSA::User < SSA::NamedValue
+    attr_reader :operands
+
+    def initialize(function, operands=[], name=nil)
+      super(function, name)
+
+      self.operands = operands
+    end
+
+    def each_operand(&block)
+      @operands.each &block if @operands
+    end
+
+    def operands=(operands)
+      update_use_lists do
+        @operands = operands.map(&:to_value)
+      end
+    end
+
+    def detach
+      update_use_lists do
+        @operands = nil
+      end
+    end
+
+    def translate_operands(map)
+      @operands.map do |operand|
+        map[operand]
+      end
+    end
+
+    def replace_uses_of(value, new_value)
+      if replace_uses_of_operands(value, new_value)
+        value.remove_use(self)
+        new_value.add_use(self)
+      else
+        raise ArgumentError, "#{value.inspect} is not used in #{self.inspect}"
+      end
+
+      self
+    end
+
+    def valid?(*args)
+      verify!(*args)
+      true
+    rescue TypeError
+      false
+    end
+
+    def verify!
+      # do nothing
+    end
+
+    protected
+
+    def update_use_lists
+      each_operand do |operand|
+        operand.remove_use(self)
+      end
+
+      value = yield
+
+      each_operand do |operand|
+        operand.add_use(self)
+      end
+
+      value
+    end
+
+    def replace_uses_of_operands(value, new_value)
+      found = false
+
+      @operands.each_with_index do |operand, index|
+        if operand == value
+          found = true
+          @operands[index] = new_value
+        end
+      end
+
+      found
+    end
+  end
+end