seafoam 0.11 → 0.14

data/lib/seafoam/passes/truffle.rb

@@ -1,15 +1,22 @@
+# frozen_string_literal: true
+
+require "tsort"
+
 module Seafoam
   module Passes
     # The Truffle pass applies if it looks like it was compiled by Truffle.
     class TrufflePass < Pass
-      def self.applies?(graph)
-        graph.props.values.any? do |v|
-          TRIGGERS.any? { |t| v.to_s.include?(t) }
+      class << self
+        def applies?(graph)
+          graph.props.values.any? do |v|
+            TRIGGERS.any? { |t| v.to_s.include?(t) }
+          end
         end
       end
 
       def apply(graph)
-        simplify_truffle_args graph if @options[:simplify_truffle_args]
+        simplify_truffle_args(graph) if @options[:simplify_truffle_args]
+        simplify_alloc(graph) if @options[:simplify_alloc]
       end
 
       private
@@ -18,41 +25,132 @@ module Seafoam
       # like a Graal parameter node.
       def simplify_truffle_args(graph)
         graph.nodes.dup.each_value do |node|
-          next unless node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.java.LoadIndexedNode'
+          next unless node.node_class == "org.graalvm.compiler.nodes.java.LoadIndexedNode"
 
-          index_node = node.inputs.find { |edge| edge.props[:name] == 'index' }.from
-          array_node = Graal::Pi.follow_pi_object(node.inputs.find { |edge| edge.props[:name] == 'array' }.from)
+          index_node = node.inputs.find { |edge| edge.props[:name] == "index" }.from
+          array_node = Graal::Pi.follow_pi_object(node.inputs.find { |edge| edge.props[:name] == "array" }.from)
 
-          next unless index_node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.ConstantNode'
-          next unless array_node.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.ParameterNode'
+          next unless index_node.node_class == "org.graalvm.compiler.nodes.ConstantNode"
+          next unless array_node.node_class == "org.graalvm.compiler.nodes.ParameterNode"
 
           node.props[:truffle_arg_load] = true
 
-          index = index_node.props['rawvalue']
+          index = index_node.props["rawvalue"]
 
-          arg_node = graph.create_node(graph.new_id, { synthetic: true, inlined: true, label: "T(#{index})", kind: 'input' })
+          arg_node = graph.create_node(graph.new_id,
+            { synthetic: true, inlined: true, label: "T(#{index})", kind: "input" })
 
           node.outputs.each do |output|
-            next if output.props[:name] == 'next'
+            next if output.props[:name] == "next"
 
-            graph.create_edge arg_node, output.to, output.props.dup
-            graph.remove_edge output
+            graph.create_edge(arg_node, output.to, output.props.dup)
+            graph.remove_edge(output)
           end
         end
 
         graph.nodes.each_value.select { |node| node.props[:truffle_arg_load] }.each do |node|
-          control_in = node.inputs.find { |edge| edge.props[:name] == 'next' }
-          control_out = node.outputs.find { |edge| edge.props[:name] == 'next' }
-          graph.create_edge control_in.from, control_out.to, { name: 'next' }
-          graph.remove_edge control_in
-          graph.remove_edge control_out
+          control_in = node.inputs.find { |edge| edge.props[:name] == "next" }
+          control_out = node.outputs.find { |edge| edge.props[:name] == "next" }
+          graph.create_edge(control_in.from, control_out.to, { name: "next" })
+          graph.remove_edge(control_in)
+          graph.remove_edge(control_out)
+        end
+      end
+
+      # Hide nodes that are uninteresting inputs to an allocation node. These
+      # are constants that are null or 0.
+      def simplify_alloc(graph)
+        commit_allocation_nodes = graph.nodes.each_value.select do |node|
+          node.node_class == "org.graalvm.compiler.nodes.virtual.CommitAllocationNode"
+        end
+
+        commit_allocation_nodes.each do |commit_allocation_node|
+          control_flow_pred = commit_allocation_node.inputs.first
+          control_flow_next = commit_allocation_node.outputs.first
+
+          objects = []
+          virtual_to_object = {}
+
+          # First step to fill virtual_to_object and avoid ordering issues
+          commit_allocation_node.props.each_pair do |key, value|
+            m = /^object\((\d+)\)$/.match(key)
+            next unless m
+
+            virtual_id = m[1].to_i
+
+            (m = /^(\w+(?:\[\])?)\[([0-9,]+)\]$/.match(value)) || raise(value)
+            class_name, values = m.captures
+            values = values.split(",").map(&:to_i)
+            virtual_node = graph.nodes[virtual_id]
+            if virtual_node.node_class == "org.graalvm.compiler.nodes.virtual.VirtualArrayNode"
+              label = "New #{class_name[0...-1]}#{virtual_node.props["length"]}]"
+              fields = values.size.times.to_a
+            else
+              label = "New #{class_name}"
+              fields = virtual_node.props["fields"].map { |field| field[:name] }
+            end
+            raise unless fields.size == values.size
+
+            new_node = graph.create_node(graph.new_id, { synthetic: true, label: label, kind: "alloc" })
+
+            object = [new_node, virtual_node, fields, values]
+            objects << object
+            virtual_to_object[virtual_id] = object
+          end
+
+          # Topological sort of the new nodes in the control flow according to data dependencies
+          # There can be cycles (e.g., instances referring one another),
+          # so we use TSort.strongly_connected_components instead of TSort.tsort.
+          objects = TSort.strongly_connected_components(
+            objects.method(:each),
+            lambda do |(_new_node, _virtual_node, _fields, values), &b|
+              values.each do |value_id|
+                usage = virtual_to_object[value_id]
+                b.call(usage) if usage
+              end
+            end
+          ).reduce(:concat)
+
+          prev = control_flow_pred.from
+          objects.each do |new_node, virtual_node, fields, values|
+            graph.create_edge(prev, new_node, control_flow_pred.props)
+
+            allocated_object_node = virtual_node.outputs.find do |output|
+              output.to.node_class == "org.graalvm.compiler.nodes.virtual.AllocatedObjectNode"
+            end
+            if allocated_object_node
+              allocated_object_node = allocated_object_node.to
+
+              allocated_object_node.outputs.each do |edge|
+                graph.create_edge(new_node, edge.to, edge.props)
+              end
+
+              allocated_object_node.props[:hidden] = true
+            end
+
+            fields.zip(values) do |field, value_id|
+              value_node = virtual_to_object[value_id]&.first || graph.nodes[value_id]
+              if @options[:hide_null_fields] &&
+                  (value_node.node_class == "org.graalvm.compiler.nodes.ConstantNode") &&
+                  ["Object[null]", "0"].include?(value_node.props["rawvalue"])
+                value_node.props[:hidden] = true
+              else
+                graph.create_edge(value_node, new_node, { name: field })
+              end
+            end
+
+            virtual_node.props[:hidden] = true
+
+            prev = new_node
+          end
+          graph.create_edge(prev, control_flow_next.to, control_flow_next.props)
+
+          commit_allocation_node.props[:hidden] = true
         end
       end
 
       # If we see these in the graph properties it's probably a Truffle graph.
-      TRIGGERS = %w[
-        TruffleCompiler
-      ]
+      TRIGGERS = ["TruffleCompiler"]
     end
   end
 end

data/lib/seafoam/passes.rb

@@ -1,39 +1,43 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Passes are routines to read the graph and apply properties which tools,
   # such as the render command, can use to show more understandable output.
   module Passes
-    # Apply all applicable passes to a graph.
-    def self.apply(graph, options = {})
-      passes.each do |pass|
-        next unless pass.applies?(graph)
-
-        # Record for information that the pass was applied this graph.
-        passes_applied = graph.props[:passes_applied] ||= []
-        passes_applied.push pass
-
-        # Run the pass.
-        instance = pass.new(options)
-        instance.apply graph
+    class << self
+      # Apply all applicable passes to a graph.
+      def apply(graph, options = {})
+        passes.each do |pass|
+          next unless pass.applies?(graph)
+
+          # Record for information that the pass was applied this graph.
+          passes_applied = graph.props[:passes_applied] ||= []
+          passes_applied.push(pass)
+
+          # Run the pass.
+          instance = pass.new(options)
+          instance.apply(graph)
+        end
       end
-    end
 
-    # Get a list of all passes in the system.
-    def self.passes
-      # We have a defined order for passes to run - these passes at the start.
-      pre_passes = [
-        TrufflePass,
-        GraalPass
-      ]
+      # Get a list of all passes in the system.
+      def passes
+        # We have a defined order for passes to run - these passes at the start.
+        pre_passes = [
+          TrufflePass,
+          GraalPass,
+        ]
 
-      # The fallback pass runs last.
-      post_passes = [
-        FallbackPass
-      ]
+        # The fallback pass runs last.
+        post_passes = [
+          FallbackPass,
+        ]
 
-      # Any extra passes in the middle.
-      extra_passes = Pass::SUBCLASSES.dup - pre_passes - post_passes
+        # Any extra passes in the middle.
+        extra_passes = Pass::SUBCLASSES.dup - pre_passes - post_passes
 
-      pre_passes + extra_passes + post_passes
+        pre_passes + extra_passes + post_passes
+      end
     end
   end
 
@@ -54,8 +58,11 @@ module Seafoam
       raise NotImplementedError
     end
 
-    def self.inherited(pass)
-      SUBCLASSES.push pass
+    class << self
+      def inherited(pass)
+        super
+        SUBCLASSES.push(pass)
+      end
     end
   end
 end

data/lib/seafoam/spotlight.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Seafoam
   # Spotlight can *light* nodes, which makes them visible, their adjacent nodes
   # visible by grey, and other nodes invisible. Multiple nodes can be *lit*.
@@ -9,11 +11,11 @@ module Seafoam
     # Mark a node as lit by the spotlight.
     def light(node)
       # This node is lit.
-      node.props[:spotlight] = 'lit'
+      node.props[:spotlight] = "lit"
 
       # Adjacent nodes are shaded, if they haven't be lit themselvs.
       node.adjacent.each do |adjacent|
-        adjacent.props[:spotlight] ||= 'shaded'
+        adjacent.props[:spotlight] ||= "shaded"
       end
     end
 

data/lib/seafoam/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Seafoam
   MAJOR_VERSION = 0
-  MINOR_VERSION = 11
+  MINOR_VERSION = 14
   VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}"
 end

data/lib/seafoam.rb

@@ -1,20 +1,22 @@
-require 'seafoam/version'
-require 'seafoam/binary/io_binary_reader'
-require 'seafoam/bgv/bgv_parser'
-require 'seafoam/cfg/cfg_parser'
-require 'seafoam/cfg/disassembler'
-require 'seafoam/colors'
-require 'seafoam/graph'
-require 'seafoam/graal/graph_description'
-require 'seafoam/graal/source'
-require 'seafoam/graal/pi'
-require 'seafoam/passes'
-require 'seafoam/passes/truffle'
-require 'seafoam/passes/graal'
-require 'seafoam/passes/fallback'
-require 'seafoam/spotlight'
-require 'seafoam/isabelle_writer'
-require 'seafoam/json_writer'
-require 'seafoam/graphviz_writer'
-require 'seafoam/commands'
-require 'seafoam/formatters/formatters'
+# frozen_string_literal: true
+
+require "seafoam/version"
+require "seafoam/binary/io_binary_reader"
+require "seafoam/bgv/bgv_parser"
+require "seafoam/colors"
+require "seafoam/graph"
+require "seafoam/graal/graph_description"
+require "seafoam/graal/source"
+require "seafoam/graal/pi"
+require "seafoam/passes"
+require "seafoam/passes/truffle"
+require "seafoam/passes/graal"
+require "seafoam/passes/fallback"
+require "seafoam/spotlight"
+require "seafoam/isabelle_writer"
+require "seafoam/json_writer"
+require "seafoam/graphviz_writer"
+require "seafoam/mermaid_writer"
+require "seafoam/markdown_writer"
+require "seafoam/commands"
+require "seafoam/formatters/formatters"

metadata

@@ -1,43 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: seafoam
 version: !ruby/object:Gem::Version
-  version: '0.11'
+  version: '0.14'
 platform: ruby
 authors:
 - Chris Seaton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-01-26 00:00:00.000000000 Z
+date: 2022-09-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: crabstone
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !ruby/object:Gem::Dependency
-  name: benchmark-ips
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.7'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -67,38 +39,34 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.8'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-shopify
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
+        version: 2.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.74'
+        version: 2.9.0
 description: 
 email: 
 executables:
 - seafoam
 - bgv2json
 - bgv2isabelle
-- cfg2asm
 extensions: []
 extra_rdoc_files: []
 files:
 - bin/bgv2isabelle
 - bin/bgv2json
-- bin/cfg2asm
 - bin/seafoam
 - lib/seafoam.rb
 - lib/seafoam/bgv/bgv_parser.rb
 - lib/seafoam/binary/io_binary_reader.rb
-- lib/seafoam/cfg/cfg_parser.rb
-- lib/seafoam/cfg/disassembler.rb
 - lib/seafoam/colors.rb
 - lib/seafoam/commands.rb
 - lib/seafoam/formatters/base.rb
@@ -112,6 +80,8 @@ files:
 - lib/seafoam/graphviz_writer.rb
 - lib/seafoam/isabelle_writer.rb
 - lib/seafoam/json_writer.rb
+- lib/seafoam/markdown_writer.rb
+- lib/seafoam/mermaid_writer.rb
 - lib/seafoam/passes.rb
 - lib/seafoam/passes/fallback.rb
 - lib/seafoam/passes/graal.rb
@@ -130,15 +100,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.9
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: A tool for working with compiler graphs

data/bin/cfg2asm

@@ -1,20 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'seafoam'
-
-# This is the 'cfg2asm' command line entry point.
-
-begin
-  # Run the command line.
-  commands = Seafoam::Commands.new($stdout)
-  commands.cfg2asm(*ARGV)
-rescue StandardError => e
-  if $DEBUG
-    # Re-raise the exception so the user sees it, if debugging is
-    # enabled (ruby -d).
-    raise e
-  else
-    # Otherwise, just print the message.
-    warn "seafoam: #{e.message}"
-  end
-end

data/lib/seafoam/cfg/cfg_parser.rb

@@ -1,93 +0,0 @@
-require 'stringio'
-require 'zlib'
-
-module Seafoam
-  module CFG
-    Code = Struct.new(:arch, :arch_width, :base, :code)
-    Comment = Struct.new(:offset, :comment)
-    NMethod = Struct.new(:code, :comments)
-
-    # A parser for CFG files.
-    class CFGParser
-      def initialize(out, file)
-        @out = out
-        data = File.read(file, encoding: Encoding::ASCII_8BIT)
-        if data[0..1].bytes == [0x1f, 0x8b]
-          data = Zlib.gunzip(data)
-        end
-        @reader = StringIO.new(data)
-        @state = :any
-        @cfg_name = nil
-      end
-
-      def skip_over_cfg(name)
-        loop do
-          line = @reader.readline("\n")
-          case line
-          when "begin_cfg\n"
-            @state = :cfg
-            @cfg_name = nil
-          when /  name "(.*)"\n/
-            if @state == :cfg
-              @cfg_name = Regexp.last_match(1)
-            end
-          when "end_cfg\n"
-            raise unless @state == :cfg
-
-            @state = :any
-            break if @cfg_name == name
-          else
-            next
-          end
-        end
-      end
-
-      def read_nmethod
-        raise unless @state == :any
-
-        arch = nil
-        arch_width = nil
-        code = nil
-        comments = []
-        raise unless @reader.readline == "begin_nmethod\n"
-
-        loop do
-          line = @reader.readline("\n")
-          case line
-          when /  Platform (.*) (.*)  <\|\|@\n/
-            arch = Regexp.last_match(1)
-            arch_width = Regexp.last_match(2)
-          when /  HexCode (.*) (.*)  <\|\|@\n/
-            base = Regexp.last_match(1).to_i(16)
-            code = [Regexp.last_match(2)].pack('H*')
-            raise if arch.nil? || arch_width.nil?
-
-            code = Code.new(arch, arch_width, base, code)
-          when /  Comment (\d*) (.*)  <\|\|@\n/
-            offset = Regexp.last_match(1).to_i
-            comment = Regexp.last_match(2)
-            comments.push Comment.new(offset, comment)
-          when "  <<<HexCodeFile\n"
-            next
-          when "  HexCodeFile>>> <|@\n"
-            next
-          when "end_nmethod\n"
-            break
-          when /  (.*)  <\|\|@\n/
-            offset = -1
-            comment = Regexp.last_match(1)
-            comments.push Comment.new(offset, comment)
-          when /  (.*)\n/
-            offset = -1
-            comment = Regexp.last_match(1)
-            comments.push Comment.new(offset, comment)
-          else
-            # In case anything was missed
-            raise 'There is currently no case for this line. Please open an issue so it can be addressed.'
-          end
-        end
-        NMethod.new(code, comments)
-      end
-    end
-  end
-end

data/lib/seafoam/cfg/disassembler.rb

@@ -1,70 +0,0 @@
-require 'stringio'
-
-module Seafoam
-  module CFG
-    # Disassemble and print comments from cfg files
-    class Disassembler
-      def initialize(out)
-        @out = out
-      end
-
-      def disassemble(nmethod, print_comments)
-        require_crabstone
-
-        comments = nmethod.comments
-        comments_n = 0
-
-        case [nmethod.code.arch, nmethod.code.arch_width]
-        when %w[AMD64 64]
-          crabstone_arch = [Crabstone::ARCH_X86, Crabstone::MODE_64]
-        else
-          raise "Unknown architecture #{nmethod.code.arch} and bit width #{nmethod.code.arch_width}"
-        end
-
-        cs = Crabstone::Disassembler.new(*crabstone_arch)
-        begin
-          cs.disasm(nmethod.code.code, nmethod.code.base).each do |i|
-            if print_comments
-              # Print comments associated to the instruction.
-              last_comment = i.address + i.bytes.length - nmethod.code.base
-              while comments_n < comments.length && comments[comments_n].offset < last_comment
-                if comments[comments_n].offset == -1
-                  @out.printf("\t\t\t\t;%<comment>s\n", comment: comments[comments_n].comment)
-                else
-                  @out.printf(
-                    "\t\t\t\t;Comment %<loc>i:\t%<comment>s\n",
-                    loc: comments[comments_n].offset,
-                    comment: comments[comments_n].comment
-                  )
-                end
-                comments_n += 1
-              end
-            end
-
-            # Print the instruction.
-            @out.printf(
-              "\t0x%<address>x:\t%<instruction>s\t%<details>s\n",
-              address: i.address,
-              instruction: i.mnemonic,
-              details: i.op_str
-            )
-          end
-        rescue StandardError => e
-          raise "Disassembly error: #{e.message}"
-        ensure
-          cs.close
-        end
-      end
-
-      def require_crabstone
-        require 'crabstone'
-      rescue LoadError => e
-        if $DEBUG
-          raise e
-        else
-          raise 'Could not load Capstone - is it installed?'
-        end
-      end
-    end
-  end
-end