furnace 0.4.0.beta.1 → 0.4.0.beta.2

data/lib/furnace/ssa/function.rb

@@ -1,40 +1,42 @@
 module Furnace
   class SSA::Function
     attr_reader   :original_name
-    attr_accessor :name
+    attr_reader   :name
     attr_reader   :arguments
-    attr_accessor :return_type
+    attr_reader   :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
+    def initialize(name=nil, arguments=[], return_type=Type::Bottom.new)
+      @original_name   = name
+      @name            = name
+      @return_type     = return_type.to_type
+      @arguments       = arguments
 
-      @basic_blocks  = Set.new
+      @basic_blocks    = Set.new
 
-      @name_prefixes = [""].to_set
-      @next_name     = 0
+      @name_prefixes   = [""].to_set
+      @next_name       = 0
+
+      SSA.instrument(self)
     end
 
     def initialize_copy(original)
-      @name = @original_name
+      @name_prefixes = [""].to_set
+      @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|
+      self.arguments = @arguments.map do |arg|
         new_arg = arg.dup
         new_arg.function = self
         value_map[arg] = new_arg
@@ -42,13 +44,16 @@ module Furnace
         new_arg
       end
 
-      @basic_blocks = @basic_blocks.map do |bb|
+      old_basic_blocks = @basic_blocks
+      @basic_blocks    = Set[]
+
+      old_basic_blocks.each do |bb|
         new_bb = bb.dup
         new_bb.function = self
 
         value_map[bb] = new_bb
 
-        new_bb
+        add new_bb
       end
 
       @entry = value_map[@entry]
@@ -64,8 +69,26 @@ module Furnace
       end
     end
 
+    def name=(name)
+      @name = name
+
+      SSA.instrument(self)
+    end
+
     def arguments=(arguments)
       @arguments = sanitize_arguments(arguments)
+
+      @arguments.each do |arg|
+        arg.function = self
+      end
+
+      SSA.instrument(self)
+    end
+
+    def return_type=(return_type)
+      @return_type = return_type.to_type
+
+      SSA.instrument(self)
     end
 
     def make_name(prefix=nil)
@@ -89,6 +112,10 @@ module Furnace
 
     alias each_basic_block each
 
+    def size
+      @basic_blocks.count
+    end
+
     def include?(name)
       @basic_blocks.any? { |n| n.name == name }
     end
@@ -102,23 +129,43 @@ module Furnace
     end
 
     def add(block)
+      block.function = self
       @basic_blocks.add block
+
+      SSA.instrument(self)
     end
 
     alias << add
 
     def remove(block)
       @basic_blocks.delete block
+      block.detach
+
+      SSA.instrument(self)
     end
 
-    def each_instruction(type=nil, &proc)
-      return to_enum(:each_instruction, type) if proc.nil?
+    def each_instruction(*types, &proc)
+      return to_enum(:each_instruction, *types) if proc.nil?
 
       each do |block|
-        block.each(type, &proc)
+        block.each(*types, &proc)
       end
     end
 
+    def replace_type_with(type, replacement)
+      @arguments.each do |arg|
+        arg.replace_type_with(type, replacement)
+      end
+
+      each_instruction do |insn|
+        insn.replace_type_with(type, replacement)
+      end
+
+      self.return_type = return_type.replace_type_with(type, replacement)
+
+      self
+    end
+
     def predecessors_for(name)
       predecessors = Set[]
 
@@ -132,51 +179,25 @@ module Furnace
     end
 
     def self.to_type
-      SSA::FunctionType.instance
+      SSA::FunctionType.new
     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
+    def awesome_print(p=AwesomePrinter.new)
+      p.keyword('function').
+        nest(@return_type).
+        text(@name).
+        collection('(', ', ', ') {', @arguments).
+        newline.
+        collection(@basic_blocks).
+        append('}').
+        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
+    alias inspect awesome_print
 
     protected
 
@@ -185,7 +206,7 @@ module Furnace
         if !argument.is_a?(SSA::Argument)
           raise ArgumentError, "function #{@name} arguments: #{argument.inspect} (at #{index}) is not an Argument"
         end
-      end
+      end.dup.freeze
     end
   end
-end
+end

data/lib/furnace/ssa/generic_instruction.rb

@@ -2,13 +2,20 @@ 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
+    def initialize(type, operands=[], name=nil)
+      @type = type.to_type
+
+      super(operands, name)
     end
 
     def type=(type)
-      @type = type.to_type if type
+      @type     = type.to_type
+
+      SSA.instrument(self)
+    end
+
+    def replace_type_with(type, replacement)
+      self.type = self.type.replace_type_with(type, replacement)
     end
   end
-end
+end

data/lib/furnace/ssa/instruction.rb

@@ -8,26 +8,39 @@ module Furnace
       SSA::InstructionSyntax.new(self).evaluate(&block)
     end
 
-    attr_accessor :basic_block
+    attr_reader :basic_block
 
-    def initialize(basic_block, operands=[], name=nil)
-      super(basic_block.function, operands, name)
-      @basic_block = basic_block
+    def opcode
+      self.class.opcode
     end
 
-    def initialize_copy(original)
-      super
+    def basic_block=(basic_block)
+      if @basic_block && @basic_block != basic_block
+        @basic_block.remove self
+      end
 
-      @operands = nil
+      if basic_block
+        self.function = basic_block.function
+      end
+
+      @basic_block = basic_block
+
+      SSA.instrument(self)
     end
 
-    def opcode
-      self.class.opcode
+    def detach
+      @basic_block = nil
+
+      super
     end
 
     def remove
-      @basic_block.remove self
-      detach
+      @basic_block.remove self if @basic_block
+    end
+
+    def erase
+      remove
+      drop_references
     end
 
     def replace_with(value)
@@ -35,12 +48,15 @@ module Furnace
 
       if value.is_a? SSA::Instruction
         @basic_block.replace self, value
-        detach
+        drop_references
       else
-        remove
+        erase
       end
     end
 
+    def replace_type_with(type, replacement)
+    end
+
     def has_side_effects?
       false
     end
@@ -49,44 +65,43 @@ module Furnace
       false
     end
 
-    def pretty_print(p=SSA::PrettyPrinter.new)
-      unless type == SSA.void
-        p.type  type
-        p.name  name
-        p.text  '='
+    def awesome_print(p=AwesomePrinter.new)
+      unless type == Type::Bottom.new
+        p.nest(type).
+          name(name).
+          text('=')
       end
 
-      if valid?
-        p.keyword opcode
-      else
-        p.keyword_invalid opcode
-      end
+      p.keyword(opcode)
 
-      pretty_parameters(p)
-      pretty_operands(p)
+      awesome_print_parameters(p)
+      awesome_print_operands(p)
 
       p
     end
 
-    def inspect_as_value(p=SSA::PrettyPrinter.new)
-      if type == SSA.void
-        p.type  type
+    def awesome_print_as_value(p=AwesomePrinter.new)
+      if type == Type::Bottom.new
+        p.nest(type)
       else
         super
       end
     end
 
-    protected
-
-    def pretty_parameters(p)
+    def awesome_print_parameters(p=AwesomePrinter.new)
+      p
     end
 
-    def pretty_operands(p)
+    def awesome_print_operands(p=AwesomePrinter.new)
       if @operands
-        p.values @operands
+        p.collection('', ', ', '', @operands) do |operand|
+          operand.awesome_print_as_value(p)
+        end
       else
-        p.text '<DETACHED>'
+        p.text('<DETACHED>')
       end
     end
+
+    protected :function=
   end
-end
+end

data/lib/furnace/ssa/instruction_syntax.rb

@@ -2,7 +2,7 @@ module Furnace
   class SSA::InstructionSyntax
     def initialize(klass)
       @klass    = klass
-      @operands = {}
+      @operands = []
       @splat    = nil
     end
 
@@ -12,11 +12,10 @@ module Furnace
       codegen
     end
 
-    def operand(name, type=nil)
+    def operand(name)
       check_for_splat
 
-      type = type.to_type unless type.nil?
-      @operands[name.to_sym] = type
+      @operands << name.to_sym
     end
 
     def splat(name)
@@ -37,7 +36,7 @@ module Furnace
       operands, splat = @operands, @splat
 
       @klass.class_eval do
-        operands.each_with_index do |(operand, type), index|
+        operands.each_with_index do |operand, index|
           define_method(operand) do
             @operands[index]
           end
@@ -45,10 +44,14 @@ module Furnace
           define_method(:"#{operand}=") do |value|
             value = value.to_value
 
+            return if @operands[index] == value
+
             @operands[index].remove_use self if @operands[index]
             @operands[index] = value
             value.add_use self if value
 
+            SSA.instrument(self)
+
             value
           end
         end
@@ -82,28 +85,9 @@ module Furnace
             @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
+end