seafoam 0.9 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49d090779b04322f8c82aae0cf11ea2e39cd4cef1f3d9dc2b51de1f27e565f9c
-  data.tar.gz: 121f1c7bb327c30f1a388960012c43dab49e0f1079d5a420811ab2332de9663b
+  metadata.gz: 3bd98e20ee30268f65b81cdee7e286133d09d3daa1a5906500e46391fb8a77e8
+  data.tar.gz: 19e94f385a5e0b056b0431f9385b0ca75796b368e5b767a537406c4f87f83329
 SHA512:
-  metadata.gz: dd13ee2efe4fe4118fc5f6bdb56c55b3c1c5f28b86a3d37ce3cf4fc72bcdcbeb161968260b62626047b9f9f9eedec53cbc743d79512a11bd77b195f054c54262
-  data.tar.gz: 67e06a4e89fdf9e6297e3d68da7f7b0e7d4f1de95a97c9be17c12e6c9114476ee6e747c6306c3bc472e549317f20c19c315c9789d1814c68fdd85501327c432b
+  metadata.gz: 91d9279f98008fd449f4be3ecf4d45fdf2ddac3e3eb1f6eae0b0451a2dbb58d3a52b95fa12be3a805aa208ccb56033fe32b093f653331907cbc3d51b3d033f56
+  data.tar.gz: f2bb55b41d82f3176dcfc1bbfc46bdd01711ac8a4e61995338e5e127a196f43b40eff3ef81b2e16448dd86f4535a215d83accf7643f5f92787ff9b1d74c964b9

data/lib/seafoam/bgv/bgv_parser.rb

@@ -162,8 +162,7 @@ module Seafoam
           count += 1
           arg
         end
-        components = groups_names + [name]
-        components.join('/')
+        groups_names + [name]
       end
 
       private

data/lib/seafoam/commands.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'set'
 
 module Seafoam
   # Implementations of the command-line commands that you can run in Seafoam.
@@ -10,6 +11,14 @@ module Seafoam
     # Run the general seafoam command.
     def seafoam(*args)
       first, *args = args
+
+      if first == '--json'
+        formatter_module = Seafoam::Formatters::Json
+        first, *args = args
+      else
+        formatter_module = Seafoam::Formatters::Text
+      end
+
       case first
       when nil, 'help', '-h', '--help', '-help'
         raise ArgumentError, "unexpected arguments #{args.join(' ')}" unless args.empty?
@@ -24,21 +33,23 @@ module Seafoam
         when nil
           help(*args)
         when 'info'
-          info name, *args
+          info name, formatter_module, *args
         when 'list'
-          list name, *args
+          list name, formatter_module, *args
         when 'search'
           search name, *args
         when 'edges'
-          edges name, *args
+          edges name, formatter_module, *args
         when 'props'
           props name, *args
         when 'source'
-          source name, *args
+          source name, formatter_module, *args
         when 'render'
           render name, *args
         when 'debug'
           debug name, *args
+        when 'describe'
+          describe name, formatter_module, *args
         else
           raise ArgumentError, "unknown command #{command}"
         end
@@ -136,82 +147,42 @@ module Seafoam
       end
     end
 
-    def cfg2asm(*args)
-      case args.first
-      when nil, 'help', '-h', '--help', '-help'
-        args = args.drop(1)
-        raise ArgumentError, "unexpected arguments #{args.join(' ')}" unless args.empty?
-
-        @out.puts 'cfg2asm file.bgv...'
-        @out.puts '            --no-comments'
-        @out.puts '        --help'
-        @out.puts '        --version'
-      when 'version', '-v', '-version', '--version'
-        args = args.drop(1)
-        version(*args)
-      else
-        comments = true
-        files = []
-
-        until args.empty?
-          arg = args.shift
-          if arg.start_with?('-')
-            case arg
-            when '--no-comments'
-              comments = false
-            else
-              raise ArgumentError, "unknown option #{arg}"
-            end
-          else
-            files.push arg
-          end
-        end
-
-        files.each_with_index do |file, n|
-          parser = Seafoam::CFG::CFGParser.new(@out, file)
-          parser.skip_over_cfg 'After code installation'
-          nmethod = parser.read_nmethod
-
-          disassembler = Seafoam::CFG::Disassembler.new(@out)
-          @out.puts if n.positive?
-          @out.puts "[#{file}]"
-          disassembler.disassemble(nmethod, comments)
-        end
-      end
-    end
-
     private
 
     # seafoam file.bgv info
-    def info(name, *args)
+    def info(name, formatter_module, *args)
       file, *rest = parse_name(name)
       raise ArgumentError, 'info only works with a file' unless rest == [nil, nil, nil]
-
       raise ArgumentError, 'info does not take arguments' unless args.empty?
 
       parser = BGV::BGVParser.new(file)
       major, minor = parser.read_file_header(version_check: false)
-      @out.puts "BGV #{major}.#{minor}"
+      formatter = formatter_module::InfoFormatter.new(major, minor)
+
+      @out.puts formatter.format
     end
 
     # seafoam file.bgv list
-    def list(name, *args)
+    def list(name, formatter_module, *args)
       file, *rest = parse_name(name)
       raise ArgumentError, 'list only works with a file' unless rest == [nil, nil, nil]
-
       raise ArgumentError, 'list does not take arguments' unless args.empty?
 
       parser = BGV::BGVParser.new(file)
       parser.read_file_header
       parser.skip_document_props
+      entries = []
       loop do
         index, = parser.read_graph_preheader
         break unless index
 
         graph_header = parser.read_graph_header
-        @out.puts "#{file}:#{index}  #{parser.graph_name(graph_header)}"
+        entries << formatter_module::ListFormatter::Entry.new(file, parser.graph_name(graph_header), index)
         parser.skip_graph
       end
+
+      formatter = formatter_module::ListFormatter.new(entries)
+      @out.puts formatter.format
     end
 
     # seafoam file.bgv:n... search term...
@@ -270,12 +241,13 @@ module Seafoam
     end
 
     # seafoam file.bgv:n... edges
-    def edges(name, *args)
+    def edges(name, formatter_module, *args)
       file, graph_index, node_id, edge_id = parse_name(name)
       raise ArgumentError, 'edges needs at least a graph' unless graph_index
-
       raise ArgumentError, 'edges does not take arguments' unless args.empty?
 
+      entry = nil
+
       with_graph(file, graph_index) do |parser|
         parser.read_graph_header
         graph = parser.read_graph
@@ -291,24 +263,18 @@ module Seafoam
             edges = node.outputs.select { |edge| edge.to == to }
             raise ArgumentError, 'edge not found' if edges.empty?
 
-            edges.each do |edge|
-              @out.puts "#{edge.from.id_and_label} ->(#{edge.props[:label]}) #{edge.to.id_and_label}"
-            end
+            entry = formatter_module::EdgesFormatter::EdgesEntry.new(edges)
           else
-            @out.puts 'Input:'
-            node.inputs.each do |input|
-              @out.puts "  #{node.id_and_label} <-(#{input.props[:label]}) #{input.from.id_and_label}"
-            end
-            @out.puts 'Output:'
-            node.outputs.each do |output|
-              @out.puts "  #{node.id_and_label} ->(#{output.props[:label]}) #{output.to.id_and_label}"
-            end
+            entry = formatter_module::EdgesFormatter::NodeEntry.new(node)
           end
           break
         else
-          @out.puts "#{graph.nodes.count} nodes, #{graph.edges.count} edges"
+          entry = formatter_module::EdgesFormatter::SummaryEntry.new(graph.nodes.count, graph.edges.count)
         end
       end
+
+      formatter = formatter_module::EdgesFormatter.new(entry)
+      @out.puts formatter.format
     end
 
     # seafoam file.bgv... props
@@ -357,7 +323,7 @@ module Seafoam
     end
 
     # seafoam file.bgv:n:n source
-    def source(name, *args)
+    def source(name, formatter_module, *args)
       file, graph_index, node_id, edge_id = parse_name(name)
       raise ArgumentError, 'source needs a node' unless node_id
       raise ArgumentError, 'source only works with a node' if edge_id
@@ -369,7 +335,57 @@ module Seafoam
         node = graph.nodes[node_id]
         raise ArgumentError, 'node not found' unless node
 
-        @out.puts Graal::Source.render(node.props['nodeSourcePosition'])
+        formatter = formatter_module::SourceFormatter.new(node.props['nodeSourcePosition'])
+        @out.puts formatter.format
+      end
+    end
+
+    # seafoam file.bgv:n describe
+    def describe(name, formatter_module, *args)
+      file, graph_index, *rest = parse_name(name)
+
+      if graph_index.nil? || !rest.all?(&:nil?)
+        raise ArgumentError, 'describe only works with a graph'
+      end
+      raise ArgumentError, 'describe does not take arguments' unless args.empty?
+
+      parser = BGV::BGVParser.new(file)
+      parser.read_file_header
+      parser.skip_document_props
+
+      loop do
+        index, = parser.read_graph_preheader
+        break unless index
+
+        parser.skip_graph_header
+
+        if index != graph_index
+          parser.skip_graph
+          next
+        end
+
+        graph = parser.read_graph
+        description = Seafoam::Graal::GraphDescription.new
+
+        graph.nodes.each_value do |node|
+          node_class = node.props.dig(:node_class, :node_class)
+          case node_class
+          when 'org.graalvm.compiler.nodes.IfNode'
+            description.branches = true
+          when 'org.graalvm.compiler.nodes.LoopBeginNode'
+            description.loops = true
+          when 'org.graalvm.compiler.nodes.InvokeNode', 'org.graalvm.compiler.nodes.InvokeWithExceptionNode'
+            description.calls = true
+          end
+        end
+
+        description.deopts = graph.nodes[0].outputs.map(&:to)
+                                  .all? { |t| t.props.dig(:node_class, :node_class) == 'org.graalvm.compiler.nodes.DeoptimizeNode' }
+
+        formatter = formatter_module::DescribeFormatter.new(graph, description)
+        @out.puts formatter.format
+
+        break
       end
     end
 
@@ -398,6 +414,28 @@ module Seafoam
           out_file = args.shift
           explicit_out_file = true
           raise ArgumentError, 'no file for --out' unless out_file
+
+          out_ext = File.extname(out_file).downcase
+          case out_ext
+          when '.pdf'
+            out_format = :pdf
+          when '.svg'
+            out_format = :svg
+          when '.png'
+            out_format = :png
+          when '.dot'
+            out_format = :dot
+          when '.mmd'
+            out_format = :mmd
+          when '.md'
+            out_format = :md
+          else
+            raise ArgumentError, "unknown render format #{out_ext}"
+          end
+        when '--md'
+          out_file = @out
+          out_format = :md
+          explicit_out_file = true
         when '--spotlight'
           spotlight_arg = args.shift
           raise ArgumentError, 'no list for --spotlight' unless spotlight_arg
@@ -429,20 +467,7 @@ module Seafoam
         end
       end
       out_file ||= 'graph.pdf'
-      out_ext = File.extname(out_file).downcase
-      case out_ext
-      when '.pdf'
-        out_format = :pdf
-      when '.svg'
-        out_format = :svg
-      when '.png'
-        out_format = :png
-      when '.dot'
-        out_format = :dot
-      else
-        raise ArgumentError, "unknown render format #{out_ext}"
-      end
-
+      out_format ||= :pdf
       with_graph(file, graph_index) do |parser|
         parser.skip_graph_header
         graph = parser.read_graph
@@ -457,10 +482,29 @@ module Seafoam
           end
           spotlight.shade
         end
-        if out_format == :dot
-          File.open(out_file, 'w') do |stream|
-            writer = GraphvizWriter.new(stream)
-            writer.write_graph graph, false, draw_blocks
+        case out_format
+        when :dot, :mmd, :md
+          action = lambda do |stream|
+            case out_format
+            when :dot
+              writer = GraphvizWriter.new(stream)
+              writer.write_graph graph, false, draw_blocks
+            when :mmd
+              writer = MermaidWriter.new(stream)
+              writer.write_graph graph
+            when :md
+              writer = MarkdownWriter.new(stream)
+              writer.write_graph graph
+            else
+              raise
+            end
+          end
+          if out_file.is_a?(String)
+            File.open(out_file, 'w') do |stream|
+              action.call stream
+            end
+          else
+            action.call out_file
           end
         else
           begin
@@ -564,6 +608,7 @@ module Seafoam
       @out.puts '        file.bgv[:graph][:node[-edge]] edges'
       @out.puts '        file.bgv[:graph][:node[-edge]] props'
       @out.puts '        file.bgv:graph:node source'
+      @out.puts '        file.bgv:graph describe'
       @out.puts '        file.bgv:graph render'
       @out.puts '              --spotlight n,n,n...'
       @out.puts '              --out graph.pdf'

data/lib/seafoam/formatters/base.rb

@@ -0,0 +1,88 @@
+module Seafoam
+  module Formatters
+    module Base
+      # Formats the output of the `describe` command.
+      class DescribeFormatter
+        attr_reader :graph, :description
+
+        def initialize(graph, description)
+          @graph = graph
+          @description = description
+        end
+      end
+
+      # Formats the output of the `edges` command.
+      class EdgesFormatter
+        EdgesEntry = Struct.new(:edges) do
+          def render(formatter)
+            formatter.render_edges_entry(edges)
+          end
+        end
+
+        NodeEntry = Struct.new(:node) do
+          def render(formatter)
+            formatter.render_node_entry(node)
+          end
+        end
+
+        SummaryEntry = Struct.new(:node_count, :edge_count) do
+          def render(formatter)
+            formatter.render_summary_entry(node_count, edge_count)
+          end
+        end
+
+        attr_reader :entry
+
+        def initialize(entry)
+          @entry = entry
+        end
+
+        def format
+          entry.render(self)
+        end
+
+        def render_edges_entry(edges)
+          raise NotImplementedError
+        end
+
+        def render_node_entry(node)
+          raise NotImplementedError
+        end
+
+        def render_summary_entry(node_count, edge_count)
+          raise NotImplementedError
+        end
+      end
+
+      # Formats the output of the `info` command.
+      class InfoFormatter
+        attr_reader :major_version, :minor_version
+
+        def initialize(major_version, minor_version)
+          @major_version = major_version
+          @minor_version = minor_version
+        end
+      end
+
+      # Formats the output of the `list` command.
+      class ListFormatter
+        Entry = Struct.new(:file, :graph_name_components, :index)
+
+        attr_reader :entries
+
+        def initialize(entries)
+          @entries = entries
+        end
+      end
+
+      # Formats the output of the `source` command.
+      class SourceFormatter
+        attr_reader :source_position
+
+        def initialize(source_position)
+          @source_position = source_position
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/formatters/formatters.rb

@@ -0,0 +1,8 @@
+module Seafoam
+  # Formatters are the mechanism by which `seafoam` command output is presented to the user.
+  module Formatters
+    autoload :Base, 'seafoam/formatters/base'
+    autoload :Json, 'seafoam/formatters/json'
+    autoload :Text, 'seafoam/formatters/text'
+  end
+end

data/lib/seafoam/formatters/json.rb

@@ -0,0 +1,82 @@
+require 'json'
+
+module Seafoam
+  module Formatters
+    module Json
+      # A JSON-based formatter for the `describe` command.
+      class DescribeFormatter < Seafoam::Formatters::Base::DescribeFormatter
+        def format
+          ret = Seafoam::Graal::GraphDescription::ATTRIBUTES.map { |attr| [attr, description.send(attr)] }.to_h
+          ret[:node_count] = graph.nodes.size
+
+          ret.to_json
+        end
+      end
+
+      # A JSON-based formatter for the `edges` command.
+      class EdgesFormatter < Seafoam::Formatters::Base::EdgesFormatter
+        def render_edges_entry(edges)
+          edges.map { |edge| build_edge(edge) }.to_json
+        end
+
+        def render_node_entry(node)
+          {
+            input: node.inputs.map { |input| build_edge(input) },
+            output: node.outputs.map { |output| build_edge(output) }
+          }.to_json
+        end
+
+        def render_summary_entry(node_count, edge_count)
+          { node_count: node_count, edge_count: edge_count }.to_json
+        end
+
+        def build_node(node)
+          { id: node.id.to_s, label: node.props[:label] }
+        end
+
+        def build_edge(edge)
+          { from: build_node(edge.from), to: build_node(edge.to), label: edge.props[:label] }
+        end
+      end
+
+      # A JSON-based formatter for the `info` command.
+      class InfoFormatter < Seafoam::Formatters::Base::InfoFormatter
+        def format
+          {
+            major_version: major_version,
+            minor_version: minor_version
+          }.to_json
+        end
+      end
+
+      # A JSON-based formatter for the `list` command.
+      class ListFormatter < Seafoam::Formatters::Base::ListFormatter
+        def format
+          entries.map do |entry|
+            {
+              graph_index: entry.index,
+              graph_file: entry.file,
+              graph_name_components: entry.graph_name_components
+            }
+          end.to_json
+        end
+      end
+
+      # A JSON-based formatter for the `source` command.
+      class SourceFormatter < Seafoam::Formatters::Base::SourceFormatter
+        def format
+          Seafoam::Graal::Source.walk(source_position, &method(:render_method)).to_json
+        end
+
+        def render_method(method)
+          declaring_class = method[:declaring_class]
+          name = method[:method_name]
+          {
+            class: declaring_class,
+            method: name
+          }
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/formatters/text.rb

@@ -0,0 +1,70 @@
+module Seafoam
+  module Formatters
+    module Text
+      # A plain-text formatter for the `describe` command.
+      class DescribeFormatter < Seafoam::Formatters::Base::DescribeFormatter
+        def format
+          notes = Seafoam::Graal::GraphDescription::ATTRIBUTES.select { |attr| description.send(attr) }
+
+          ["#{graph.nodes.size} nodes", *notes].join(', ')
+        end
+      end
+
+      # A plain-text formatter for the `edges` command.
+      class EdgesFormatter < Seafoam::Formatters::Base::EdgesFormatter
+        def render_edges_entry(edges)
+          edges.map do |edge|
+            "#{edge.from.id_and_label} ->(#{edge.props[:label]}) #{edge.to.id_and_label}"
+          end.join("\n")
+        end
+
+        def render_node_entry(node)
+          ret = ['Input:']
+          ret += node.inputs.map do |input|
+            "  #{node.id_and_label} <-(#{input.props[:label]}) #{input.from.id_and_label}"
+          end
+
+          ret << 'Output:'
+          ret += node.outputs.map do |output|
+            "  #{node.id_and_label} ->(#{output.props[:label]}) #{output.to.id_and_label}"
+          end
+
+          ret.join("\n")
+        end
+
+        def render_summary_entry(node_count, edge_count)
+          "#{node_count} nodes, #{edge_count} edges"
+        end
+      end
+
+      # A plain-text formatter for the `info` command.
+      class InfoFormatter < Seafoam::Formatters::Base::InfoFormatter
+        def format
+          "BGV #{major_version}.#{minor_version}"
+        end
+      end
+
+      # A plain-text formatter for the `list` command.
+      class ListFormatter < Seafoam::Formatters::Base::ListFormatter
+        def format
+          entries.map do |entry|
+            "#{entry.file}:#{entry.index}  #{entry.graph_name_components.join('/')}"
+          end.join("\n")
+        end
+      end
+
+      # A plain-text formatter for the `source` command.
+      class SourceFormatter < Seafoam::Formatters::Base::SourceFormatter
+        def format
+          Seafoam::Graal::Source.walk(source_position, &method(:render_method)).join("\n")
+        end
+
+        def render_method(method)
+          declaring_class = method[:declaring_class]
+          name = method[:method_name]
+          "#{declaring_class}##{name}"
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/graal/graph_description.rb

@@ -0,0 +1,21 @@
+module Seafoam
+  module Graal
+    # Provides a high level description of a Graal graph's features.
+    class GraphDescription
+      ATTRIBUTES = %i[branches calls deopts linear loops]
+
+      ATTRIBUTES.each { |attr| attr_accessor(attr) unless attr == :linear }
+
+      def initialize
+        @branches = false
+        @calls = false
+        @deopts = false
+        @loops = false
+      end
+
+      def linear
+        !branches && !loops
+      end
+    end
+  end
+end

data/lib/seafoam/graal/source.rb

@@ -2,21 +2,17 @@ module Seafoam
   module Graal
     # Routines for understanding source positions in Graal.
     module Source
-      def self.render(source_position)
-        lines = []
+      def self.walk(source_position, &block)
+        results = []
+
         caller = source_position
         while caller
           method = caller[:method]
-          lines.push render_method(method)
+          results.push block.call(method)
           caller = caller[:caller]
         end
-        lines.join("\n")
-      end
 
-      def self.render_method(method)
-        declaring_class = method[:declaring_class]
-        name = method[:method_name]
-        "#{declaring_class}##{name}"
+        results
       end
     end
   end

data/lib/seafoam/markdown_writer.rb

@@ -0,0 +1,16 @@
+module Seafoam
+  # A writer from graphs to Markdown format, with an embedded Mermaid graph.
+  class MarkdownWriter
+    def initialize(stream)
+      @stream = stream
+    end
+
+    # Write a graph.
+    def write_graph(graph)
+      @stream.puts '```mermaid'
+      mermaid = MermaidWriter.new(@stream)
+      mermaid.write_graph graph
+      @stream.puts '```'
+    end
+  end
+end

data/lib/seafoam/mermaid_writer.rb

@@ -0,0 +1,40 @@
+module Seafoam
+  # A writer from graphs to the Mermaid format.
+  class MermaidWriter
+    def initialize(stream)
+      @stream = stream
+    end
+
+    # Write a graph.
+    def write_graph(graph)
+      @stream.puts 'flowchart TD'
+      write_nodes graph
+      write_edges graph
+    end
+
+    private
+
+    # Write node declarations.
+    def write_nodes(graph)
+      graph.nodes.each_value do |node|
+        write_node node
+      end
+    end
+
+    def write_node(node)
+      @stream.puts "  node#{node.id}[#{node.props[:label].inspect}]"
+    end
+
+    # Write edge declarations.
+
+    def write_edges(graph)
+      graph.edges.each do |edge|
+        write_edge edge
+      end
+    end
+
+    def write_edge(edge)
+      @stream.puts "  node#{edge.from.id} --> node#{edge.to.id}"
+    end
+  end
+end

data/lib/seafoam/passes/graal.rb

@@ -262,8 +262,6 @@ module Seafoam
           # loopBegin edges point from LoopEndNode (continue) and LoopExitNode
           # (break) to the LoopBeginNode. Both are drawn reversed.
           when 'loopBegin'
-            edge.props[:hidden] = true
-
             case edge.to.props.dig(:node_class, :node_class)
             when 'org.graalvm.compiler.nodes.LoopEndNode'
               # If it's from the LoopEnd then it's the control edge to follow.

data/lib/seafoam/version.rb

@@ -1,5 +1,5 @@
 module Seafoam
   MAJOR_VERSION = 0
-  MINOR_VERSION = 9
+  MINOR_VERSION = 13
   VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}"
 end

data/lib/seafoam.rb

@@ -1,10 +1,9 @@
 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'
@@ -15,4 +14,7 @@ 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.9'
+  version: '0.13'
 platform: ruby
 authors:
 - Chris Seaton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-27 00:00:00.000000000 Z
+date: 2022-02-16 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
@@ -86,27 +58,30 @@ 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
+- lib/seafoam/formatters/formatters.rb
+- lib/seafoam/formatters/json.rb
+- lib/seafoam/formatters/text.rb
+- lib/seafoam/graal/graph_description.rb
 - lib/seafoam/graal/pi.rb
 - lib/seafoam/graal/source.rb
 - lib/seafoam/graph.rb
 - 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
@@ -132,7 +107,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.3.3
 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