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

data/lib/furnace/ssa.rb

@@ -1,21 +1,9 @@
 module Furnace
   module SSA
-    def self.void
-      SSA::VoidType.instance
-    end
-
-    def self.void_value
-      SSA::VoidType.value
-    end
-
     def self.class_name_to_opcode(klass)
-      klass.to_s.split('::').last.gsub(/([a-z]|^)([A-Z])/) do
-        if $1.empty?
-          $2.downcase
-        else
-          "#{$1}_#{$2.downcase}"
-        end
-      end.gsub(/_insn$/, '')
+      klass.to_s.split('::').last.
+        gsub(/([A-Z])/) { '_' + $1.downcase }.
+        gsub(/^_(.+)_insn$/, '\1')
     end
 
     def self.opcode_to_class_name(opcode)
@@ -27,18 +15,11 @@ module Furnace
         end
       end + 'Insn'
     end
-
-    def self.inspect_type(type)
-      type ?  type.inspect : '<?>'
-    end
   end
 
-  require_relative 'ssa/pretty_printer'
-
-  require_relative 'ssa/type'
-  require_relative 'ssa/generic_type'
+  require_relative 'ssa/event_stream'
+  require_relative 'ssa/instrumentation'
 
-  require_relative 'ssa/types/void'
   require_relative 'ssa/types/basic_block'
   require_relative 'ssa/types/function'
 
@@ -59,8 +40,9 @@ module Furnace
   require_relative 'ssa/instructions/phi'
   require_relative 'ssa/instructions/branch'
   require_relative 'ssa/instructions/return'
+  require_relative 'ssa/instructions/return_value'
 
   require_relative 'ssa/module'
 
   require_relative 'ssa/builder'
-end
+end

data/lib/furnace/ssa/argument.rb

@@ -2,22 +2,26 @@ module Furnace
   class SSA::Argument < SSA::NamedValue
     attr_reader :type
 
-    def initialize(function, type, name)
-      super(function, name)
-      self.type = type
+    def initialize(type, name)
+      @type = type.to_type
+
+      super(name)
     end
 
     def type=(type)
-      @type = type.to_type if type
+      @type = type.to_type
+
+      SSA.instrument(self)
     end
 
-    def has_side_effects?
-      true
+    def replace_type_with(type, replacement)
+      self.type = self.type.
+          replace_type_with(type, replacement)
     end
 
-    def pretty_print(p=SSA::PrettyPrinter.new)
-      p.type type
-      p.name name
+    def awesome_print(p=AwesomePrinter.new)
+      p.nest(@type).
+        name(name)
     end
   end
-end
+end

data/lib/furnace/ssa/basic_block.rb

@@ -1,32 +1,41 @@
 module Furnace
   class SSA::BasicBlock < SSA::NamedValue
-    def initialize(function, name=nil, insns=[])
-      super(function, name)
+    def initialize(insns=[], name=nil)
       @instructions = insns.to_a
+
+      super(name)
     end
 
     def initialize_copy(original)
-      super
-
       @instructions = []
+
+      super
     end
 
     def to_a
       @instructions.dup
     end
 
+    def function=(function)
+      if @function && @function != function
+        @function.remove self
+      end
+
+      super
+    end
+
     def include?(instruction)
       @instructions.include? instruction
     end
 
-    def each(type=nil, &proc)
-      if type.nil?
+    def each(*types, &proc)
+      if types.empty?
         @instructions.each(&proc)
       else
-        return to_enum(:each, type) if proc.nil?
+        return to_enum(:each, *types) if proc.nil?
 
         @instructions.each do |insn|
-          if insn.instance_of? type
+          if types.include?(insn.class)
             yield insn
           end
         end
@@ -35,18 +44,42 @@ module Furnace
 
     alias each_instruction each
 
+    def prepend(instruction)
+      instruction.basic_block = self
+      @instructions.unshift instruction
+
+      SSA.instrument(self)
+    end
+
     def append(instruction)
+      instruction.basic_block = self
       @instructions.push instruction
+
+      SSA.instrument(self)
     end
 
     alias << append
 
+    def index(instruction)
+      @instructions.index(instruction)
+    end
+
     def insert(before, instruction)
-      unless index = @instructions.index(before)
+      unless (idx = index(before))
         raise ArgumentError, "Instruction #{before} is not found"
       end
 
-      @instructions.insert index, instruction
+      instruction.basic_block = self
+      @instructions.insert idx, instruction
+
+      SSA.instrument(self)
+    end
+
+    def remove(instruction)
+      @instructions.delete instruction
+      instruction.detach
+
+      SSA.instrument(self)
     end
 
     def replace(instruction, replace_with)
@@ -54,8 +87,19 @@ module Furnace
       remove instruction
     end
 
-    def remove(instruction)
-      @instructions.delete instruction
+    def splice(after)
+      unless (idx = index(after))
+        raise ArgumentError, "Instruction #{after} is not found"
+      end
+
+      result = []
+
+      @instructions[idx + 1..-1].each do |insn|
+        result << insn
+        remove insn
+      end
+
+      result
     end
 
     def terminator
@@ -85,7 +129,7 @@ module Furnace
     end
 
     def self.to_type
-      SSA::BasicBlockType.instance
+      SSA::BasicBlockType.new
     end
 
     def type
@@ -96,22 +140,23 @@ module Furnace
       true
     end
 
-    def pretty_print(p=SSA::PrettyPrinter.new)
-      p.text    @name, ":"
-      p.newline
+    def awesome_print(p=AwesomePrinter.new)
+      p.text(@name).
+        append(":").
+        newline
 
-      each do |insn|
-        p << '   '
-        insn.pretty_print(p)
-        p.newline
+      p.collection(@instructions) do |insn|
+        p.append('   ').
+          nest(insn).
+          newline
       end
 
-      p
+      p.newline
     end
 
-    def inspect_as_value(p=SSA::PrettyPrinter.new)
-      p.keyword 'label'
-      p.name    name
+    def awesome_print_as_value(p=AwesomePrinter.new)
+      p.keyword('label').
+        name(name)
     end
   end
-end
+end

data/lib/furnace/ssa/builder.rb

@@ -10,7 +10,7 @@ module Furnace
     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)
+        SSA::Argument.new(type, name)
       end
 
       @block = @function.entry = add_block
@@ -21,7 +21,7 @@ module Furnace
     end
 
     def add_block
-      block = SSA::BasicBlock.new(@function)
+      block = SSA::BasicBlock.new
       @function.add block
 
       if block_given?
@@ -35,7 +35,7 @@ module Furnace
     end
 
     def append(instruction, *args)
-      insn = lookup_insn(instruction).new(@block, *args)
+      insn = lookup_insn(instruction).new(*args)
       @block.append insn
 
       insn
@@ -64,7 +64,7 @@ module Furnace
       @block    = old_block
     end
 
-    def control_flow_op(instruction, type=nil, uses)
+    def control_flow_op(instruction, type=Type::Variable.new, uses)
       cond_block = @block
       post_block = add_block
 
@@ -83,8 +83,12 @@ module Furnace
                 end)
     end
 
-    def return(value)
-      append(:return, [ value ])
+    def return
+      append(:return)
+    end
+
+    def return_value(value)
+      append(:return_value, [ value ])
     end
 
     def method_missing(opcode, *args)
@@ -97,4 +101,4 @@ module Furnace
       end
     end
   end
-end
+end

data/lib/furnace/ssa/constant.rb

@@ -1,17 +1,25 @@
 module Furnace
   class SSA::Constant < SSA::Value
-    attr_reader   :type
-    attr_accessor :value
+    attr_reader :type
+    attr_reader :value
 
     def initialize(type, value)
-      super()
+      @value = value
+      @type  = type.to_type
 
-      self.type = type
-      @value    = value
+      super()
     end
 
     def type=(type)
-      @type     = type.to_type
+      @type  = type.to_type
+
+      SSA.instrument(self)
+    end
+
+    def value=(value)
+      @value = value
+
+      SSA.instrument(self)
     end
 
     def constant?
@@ -30,14 +38,14 @@ module Furnace
       end
     end
 
-    def inspect_as_value(p=SSA::PrettyPrinter.new)
-      p.type type
-      p.text @value.inspect unless type == SSA.void
+    def awesome_print_as_value(p=AwesomePrinter.new)
+      type.awesome_print(p)
+      p.text @value.inspect
       p
     end
 
     def inspect
-      pretty_print
+      awesome_print
     end
   end
-end
+end

data/lib/furnace/ssa/event_stream.rb

@@ -0,0 +1,145 @@
+module Furnace
+  class SSA::EventStream
+    def initialize
+      @events    = []
+      @types     = Set[]
+      @annotator = Type::Variable::Annotator.new
+    end
+
+    def data
+      @events
+    end
+
+    def process(object)
+      case object
+      # Types
+      when Type::Bottom
+        event = {
+          kind:             "type_bottom",
+          name:             "bottom",
+        }
+
+      when Type::Top
+        event = {
+          kind:             "type",
+          name:             object.awesome_print(printer).to_s,
+        }
+
+      when Type::Variable
+        event = {
+          kind:             "type_variable",
+          name:             object.awesome_print(printer).to_s,
+        }
+
+      # Entities
+      when SSA::Constant
+        event = {
+          kind:             "constant",
+          type:             type(object.type),
+          value:            object.value.inspect,
+        }
+
+      when SSA::Argument
+        event = {
+          kind:             "argument",
+          name:             object.name,
+          type:             type(object.type),
+        }
+
+      when SSA::BasicBlock
+        event = {
+          kind:             "basic_block",
+          name:             object.name,
+          instruction_ids:  ids(object.each),
+        }
+
+      when SSA::PhiInsn
+        if object.operands
+          operand_ids = object.operands.
+              map do |block, value|
+                [ id(block), id(value) ]
+              end
+        end
+
+        event = {
+          kind:             "phi",
+          name:             object.name,
+          type:             type(object.type),
+          operand_ids:      operand_ids,
+        }
+
+      when SSA::Instruction
+        event = {
+          kind:             "instruction",
+          name:             object.name,
+          opcode:           object.opcode,
+          type:             type(object.type),
+          operand_ids:      ids(object.operands),
+        }
+
+      when SSA::Function
+        event = {
+          kind:             "function",
+          name:             object.name,
+          argument_ids:     ids(object.arguments),
+          return_type:      type(object.return_type),
+          entry_id:         id(object.entry),
+          basic_block_ids:  ids(object.each),
+        }
+
+      when SSA::Module
+        event = {
+          kind:             "module",
+          function_ids:     ids(object.each),
+        }
+
+      else
+        raise "Cannot instrument #{object.class}"
+      end
+
+      @events << { id: id(object) }.merge(event)
+
+      nil
+    end
+
+    def mark_transform(function, name)
+      @events << {
+        kind:        "transform",
+        function_id: id(function),
+        name:        name
+      }
+    end
+
+    protected
+
+    def id(object)
+      if object
+        object.object_id
+      end
+    end
+
+    def ids(objects)
+      if objects
+        objects.map do |object|
+          id(object)
+        end
+      end
+    end
+
+    def type(type)
+      if @types.include?(type)
+        type.object_id
+      else
+        @types.add type
+
+        process(type)
+
+        type.object_id
+      end
+    end
+
+    def printer
+      AwesomePrinter.new(false, @annotator)
+    end
+  end
+end