seafoam 0.14 → 0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44f9af9b54052ddbfc03bc99833eb0af6e2e5f2bd0a5612a77ea10e3d30b3fca
-  data.tar.gz: 7d1613577c3e033c69149eb51845540b88adc0c05bda3327c59a41c700647181
+  metadata.gz: 953c4b8d8e9c803df82cf0806f64ad775016ff3aaac16e96b602e15b28ec9fe4
+  data.tar.gz: a933e3faf9effa97b4a48ae38b7ce48ebaa6eba50db5b675442ad2431c93be83
 SHA512:
-  metadata.gz: f35b3f93409e92be806e793817461900f66d7d1a8e91e6ae95fc52f66fa61955d7c48f0de1899ad15b35e88fa2b6b4cbb70fed976accb9f20ee7725f201828fe
-  data.tar.gz: 03d4b654e6f2001128aa711ccddb4cccf09aed480d65578e0e49edb3d59c2acb5b594e3ef4f32b972e9821862aa24b9daa12c4fb7f1cef838a46c43c2c3b4fa9
+  metadata.gz: 369ab75e67c67eaf58d4628875579b84e132a2462212f95c656c8d4c69031297a3f3c3c6652e1dd08bebc367077a6b0fdeb2d56c2c115908d55255a0be54457c
+  data.tar.gz: e6f2fca576c55ce24ad5d27d67b88f4b1f9e70e68eb76bee473492a8ee1148db4ed3b7c6294bc615c5399d94c0dc7e2009ab13b39ee96940b042e08b6e0518a5

data/lib/seafoam/bgv/bgv_parser.rb

@@ -59,7 +59,7 @@ module Seafoam
       # Move to the next graph in the file, and return its index and ID, or nil if
       # there are no more graphs.
       def read_graph_preheader
-        return nil unless read_groups
+        return unless read_groups
 
         # Already read BEGIN_GRAPH
         index = @index
@@ -161,7 +161,7 @@ module Seafoam
       def graph_name(graph_header)
         groups_names = graph_header[:group].map { |g| g[:short_name] }
         count = 0
-        name = graph_header[:format].sub(/%s/) do
+        name = graph_header[:format].sub("%s") do
           arg = graph_header[:args][count]
           count += 1
           arg

data/lib/seafoam/commands.rb

@@ -350,10 +350,20 @@ module Seafoam
     def describe(name, formatter_module, *args)
       file, graph_index, *rest = parse_name(name)
 
+      pass_options = DEFAULT_PASS_OPTIONS.dup
+      until args.empty?
+        arg = args.shift
+        case arg
+        when "--no-simplify"
+          pass_options.merge!(NO_SIMPLIFY_PASS_OPTIONS)
+        else
+          raise ArgumentError, "unexpected option #{arg}"
+        end
+      end
+
       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
@@ -371,26 +381,34 @@ module Seafoam
         end
 
         graph = parser.read_graph
+        Passes.apply(graph, pass_options)
+
         description = Seafoam::Graal::GraphDescription.new
 
         graph.nodes.each_value do |node|
-          node_class = node.node_class
+          next if node.props[:hidden]
 
-          simple_node_class = node_class[/([^.]+)$/, 1]
-          description.node_counts[simple_node_class] += 1
-
-          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
+          node_class = node.node_class
+          if node_class
+            simple_node_class = node_class[/([^.]+)$/, 1]
+            description.node_counts[simple_node_class] += 1
+
+            case node_class
+            when "org.graalvm.compiler.nodes.IfNode", "jdk.graal.compiler.nodes.IfNode"
+              description.branches = true
+            when "org.graalvm.compiler.nodes.LoopBeginNode", "jdk.graal.compiler.nodes.LoopBeginNode"
+              description.loops = true
+            when "org.graalvm.compiler.nodes.InvokeNode", "org.graalvm.compiler.nodes.InvokeWithExceptionNode",
+              "jdk.graal.compiler.nodes.InvokeNode", "jdk.graal.compiler.nodes.InvokeWithExceptionNode"
+              description.calls = true
+            end
+          elsif node.props[:synthetic_class]
+            description.node_counts["*" + node.props[:synthetic_class]] += 1
           end
-        end
 
-        description.deopts = graph.nodes[0].outputs.map(&:to)
-          .all? { |t| t.node_class == "org.graalvm.compiler.nodes.DeoptimizeNode" }
+          description.deopts = graph.nodes[0].outputs.map(&:to)
+            .all? { |t| t.node_class.end_with?(".compiler.nodes.DeoptimizeNode") }
+        end
 
         formatter = formatter_module::DescribeFormatter.new(graph, description)
         @out.puts formatter.format
@@ -405,16 +423,7 @@ module Seafoam
       raise ArgumentError, "render needs at least a graph" unless graph_index
       raise ArgumentError, "render only works with a graph" unless rest == [nil, nil]
 
-      pass_options = {
-        simplify_truffle_args: true,
-        hide_frame_state: true,
-        hide_pi: true,
-        hide_begin_end: true,
-        hide_floating: false,
-        reduce_edges: true,
-        simplify_alloc: true,
-        hide_null_fields: true,
-      }
+      pass_options = DEFAULT_PASS_OPTIONS.dup
       spotlight_nodes = nil
       args = args.dup
       out_file = nil
@@ -456,6 +465,8 @@ module Seafoam
           spotlight_nodes = spotlight_arg.split(",").map { |n| Integer(n) }
         when "--full-truffle-args"
           pass_options[:simplify_truffle_args] = false
+        when "--show-reachability-fences"
+          pass_options[:hide_reachability_fences] = false
         when "--no-simplify-alloc"
           pass_options[:simplify_alloc] = false
         when "--show-null-fields"
@@ -470,6 +481,8 @@ module Seafoam
           pass_options[:hide_floating] = true
         when "--no-reduce-edges"
           pass_options[:reduce_edges] = false
+        when "--no-simplify"
+          pass_options.merge!(NO_SIMPLIFY_PASS_OPTIONS)
         when "--draw-blocks"
           draw_blocks = true
         when "--option"
@@ -477,7 +490,7 @@ module Seafoam
           raise ArgumentError, "no key for --option" unless key
 
           value = args.shift
-          raise ArgumentError, "no value for --option #{key}" unless out_file
+          raise ArgumentError, "no value for --option #{key}" unless value
 
           value = { "true" => true, "false" => "false" }.fetch(key, value)
           pass_options[key.to_sym] = value
@@ -644,6 +657,7 @@ module Seafoam
       @out.puts "               --show-begin-end"
       @out.puts "               --hide-floating"
       @out.puts "               --no-reduce-edges"
+      @out.puts "               --no-simplify"
       @out.puts "               --draw-blocks"
       @out.puts "               --option key value"
       @out.puts "        --help"
@@ -693,5 +707,27 @@ module Seafoam
       end
       # Don't worry if it fails.
     end
+
+    DEFAULT_PASS_OPTIONS = {
+      simplify_truffle_args: true,
+      hide_reachability_fences: true,
+      hide_frame_state: true,
+      hide_pi: true,
+      hide_begin_end: true,
+      hide_floating: false,
+      reduce_edges: true,
+      simplify_alloc: true,
+      hide_null_fields: true,
+    }
+
+    NO_SIMPLIFY_PASS_OPTIONS = {
+      simplify_truffle_args: false,
+      hide_reachability_fences: false,
+      simplify_alloc: false,
+      hide_null_fields: false,
+      hide_pi: false,
+      hide_begin_end: false,
+      reduce_edges: false,
+    }
   end
 end

data/lib/seafoam/formatters/json.rb

@@ -9,7 +9,7 @@ module Seafoam
       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[:node_count] = graph.nodes.values.count { |n| !n.props[:hidden] }
           ret[:node_counts] = description.sorted_node_counts
 
           ret.to_json

data/lib/seafoam/formatters/text.rb

@@ -7,9 +7,10 @@ module Seafoam
       class DescribeFormatter < Seafoam::Formatters::Base::DescribeFormatter
         def format
           notes = Seafoam::Graal::GraphDescription::ATTRIBUTES.select { |attr| description.send(attr) }
+          unhidden_count = graph.nodes.values.count { |n| !n.props[:hidden] }
           node_counts = description.sorted_node_counts.map { |node_class, count| "#{node_class}: #{count}" }.join("\n")
 
-          ["#{graph.nodes.size} nodes", *notes].join(", ") + "\n#{node_counts}"
+          ["#{unhidden_count} nodes", *notes].join(", ") + "\n#{node_counts}"
         end
       end
 

data/lib/seafoam/graal/pi.rb

@@ -16,6 +16,8 @@ module Seafoam
       PI_NODES = [
         "org.graalvm.compiler.nodes.PiNode",
         "org.graalvm.compiler.nodes.PiArrayNode",
+        "jdk.graal.compiler.nodes.PiNode",
+        "jdk.graal.compiler.nodes.PiArrayNode",
       ]
     end
   end

data/lib/seafoam/graph.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "set"
+
 module Seafoam
   # A graph, with properties, nodes, and edges. We don't encapsulate the graph
   # too much - be careful.
@@ -61,7 +63,7 @@ module Seafoam
     end
 
     def node_class
-      @props.dig(:node_class, :node_class)
+      @props.dig(:node_class, :node_class) || ""
     end
 
     # All edges - input and output.
@@ -87,6 +89,18 @@ module Seafoam
     def inspect
       "<Node #{id} #{node_class}>"
     end
+
+    def visit(&block)
+      block.call(self)
+    end
+
+    def visit_outputs(search_strategy, &block)
+      if search_strategy == :bfs
+        BFS.new(self).search(&block)
+      else
+        raise "Unknown search strategy: #{search_strategy}"
+      end
+    end
   end
 
   # A directed edge, with a node it's from and a node it's going to, and

data/lib/seafoam/json_writer.rb

@@ -16,14 +16,14 @@ module Seafoam
       graph.nodes.each_value do |node|
         nodes.push(
           id: node.id,
-          props: node.props
+          props: node.props,
         )
 
         node.outputs.each do |edge|
           edges.push(
             from: edge.from.id,
             to: edge.to.id,
-            props: edge.props
+            props: edge.props,
           )
         end
       end
@@ -35,7 +35,7 @@ module Seafoam
         edges: edges,
       }
 
-      @out.puts JSON.pretty_generate(prepare_json(object))
+      @out.puts JSON.pretty_generate(self.class.prepare_json(object))
     end
 
     class << self

data/lib/seafoam/mermaid_writer.rb

@@ -38,7 +38,7 @@ module Seafoam
       when "diamond"
         shape = ["{{", "}}"]
       end
-      @stream.puts "#{indent}#{id}#{shape[0]}#{attrs[:label].inspect}#{shape[1]}"
+      @stream.puts "#{indent}#{id}#{shape[0]}#{attrs[:label].gsub('"', "#quot;").inspect}#{shape[1]}"
       @stream.puts "#{indent}style #{id} fill:#{attrs[:fillcolor]},stroke:#{attrs[:color]},color:#{attrs[:fontcolor]};"
     end
 

data/lib/seafoam/passes/graal.rb

@@ -42,7 +42,7 @@ module Seafoam
           # For constant nodes, the rawvalue is a truncated version of the
           # actual value, which is fully qualified. Instead, produce a simple
           # version of the value and don't truncate it.
-          if node_class == "org.graalvm.compiler.nodes.ConstantNode"
+          if node_class.end_with?(".compiler.nodes.ConstantNode")
             if node.props["value"] =~ /Object\[Instance<(\w+\.)+(\w*)>\]/
               node.props["rawvalue"] = "instance:#{Regexp.last_match(2)}"
             end
@@ -59,63 +59,63 @@ module Seafoam
           end
 
           # The template for InvokeNode could be simpler.
-          if node_class == "org.graalvm.compiler.nodes.InvokeNode"
+          if node_class.end_with?(".compiler.nodes.InvokeNode")
             name_template = "Call {p#targetMethod/s}"
           end
 
           # The template for InvokeWithExceptionNode could be simpler.
-          if node_class == "org.graalvm.compiler.nodes.InvokeWithExceptionNode"
+          if node_class.end_with?(".compiler.nodes.InvokeWithExceptionNode")
             name_template = "Call {p#targetMethod/s} !"
           end
 
           # The template for CommitAllocationNode could be simpler.
-          if node_class == "org.graalvm.compiler.nodes.virtual.CommitAllocationNode"
+          if node_class.end_with?(".compiler.nodes.virtual.CommitAllocationNode")
             name_template = "Alloc"
           end
 
           # The template for org.graalvm.compiler.nodes.virtual.VirtualArrayNode
           # includes an ID that we don't normally need.
-          if node_class == "org.graalvm.compiler.nodes.virtual.VirtualArrayNode"
+          if node_class.end_with?(".compiler.nodes.virtual.VirtualArrayNode")
             name_template = "VirtualArray {p#componentType/s}[{p#length}]"
           end
 
           # The template for LoadField could be simpler.
-          if node_class == "org.graalvm.compiler.nodes.java.LoadFieldNode"
+          if node_class.end_with?(".compiler.nodes.java.LoadFieldNode")
             name_template = "LoadField {x#field}"
           end
 
           # The template for StoreField could be simpler.
-          if node_class == "org.graalvm.compiler.nodes.java.StoreFieldNode"
+          if node_class.end_with?(".compiler.nodes.java.StoreFieldNode")
             name_template = "StoreField {x#field}"
           end
 
           # We want to see keys for IntegerSwitchNode.
-          if node_class == "org.graalvm.compiler.nodes.extended.IntegerSwitchNode"
+          if node_class.end_with?(".compiler.nodes.extended.IntegerSwitchNode")
             name_template = "IntegerSwitch {p#keys}"
           end
 
           # Use a symbol for PiNode.
-          if node_class == "org.graalvm.compiler.nodes.PiNode"
+          if node_class.end_with?(".compiler.nodes.PiNode")
             name_template = "π"
           end
 
           # Use a symbol for PiArrayNode.
-          if node_class == "org.graalvm.compiler.nodes.PiArrayNode"
+          if node_class.end_with?(".compiler.nodes.PiArrayNode")
             name_template = "[π]"
           end
 
           # Use a symbol for PhiNode.
-          if node_class == "org.graalvm.compiler.nodes.ValuePhiNode"
+          if node_class.end_with?(".compiler.nodes.ValuePhiNode")
             name_template = "ϕ"
           end
 
           # Better template for frame states.
-          if node_class == "org.graalvm.compiler.nodes.FrameState"
+          if node_class.end_with?(".compiler.nodes.FrameState")
             name_template = "FrameState {x#state}"
           end
 
           # Show the stamp in an InstanceOfNode.
-          if node_class == "org.graalvm.compiler.nodes.java.InstanceOfNode"
+          if node_class.end_with?(".compiler.nodes.java.InstanceOfNode")
             name_template = "InstanceOf {x#simpleStamp}"
           end
 
@@ -194,6 +194,49 @@ module Seafoam
         "org.graalvm.compiler.replacements.nodes.ReadRegisterNode" => "memory",
         "org.graalvm.compiler.replacements.nodes.WriteRegisterNode" => "memory",
         "org.graalvm.compiler.word.WordCastNode" => "memory",
+        "jdk.graal.compiler.nodes.BeginNode" => "control",
+        "jdk.graal.compiler.nodes.ConstantNode" => "input",
+        "jdk.graal.compiler.nodes.DeoptimizeNode" => "control",
+        "jdk.graal.compiler.nodes.EndNode" => "control",
+        "jdk.graal.compiler.nodes.extended.IntegerSwitchNode" => "control",
+        "jdk.graal.compiler.nodes.extended.UnsafeMemoryLoadNode" => "memory",
+        "jdk.graal.compiler.nodes.extended.UnsafeMemoryStoreNode" => "memory",
+        "jdk.graal.compiler.nodes.FixedGuardNode" => "guard",
+        "jdk.graal.compiler.nodes.FrameState" => "info",
+        "jdk.graal.compiler.nodes.GuardNode" => "guard",
+        "jdk.graal.compiler.nodes.IfNode" => "control",
+        "jdk.graal.compiler.nodes.InvokeNode" => "call",
+        "jdk.graal.compiler.nodes.InvokeWithExceptionNode" => "call",
+        "jdk.graal.compiler.nodes.java.ArrayLengthNode" => "memory",
+        "jdk.graal.compiler.nodes.java.LoadFieldNode" => "memory",
+        "jdk.graal.compiler.nodes.java.LoadIndexedNode" => "memory",
+        "jdk.graal.compiler.nodes.java.MonitorEnterNode" => "sync",
+        "jdk.graal.compiler.nodes.java.MonitorExitNode" => "sync",
+        "jdk.graal.compiler.nodes.java.NewArrayNode" => "alloc",
+        "jdk.graal.compiler.nodes.java.NewInstanceNode" => "alloc",
+        "jdk.graal.compiler.nodes.java.RawMonitorEnterNode" => "sync",
+        "jdk.graal.compiler.nodes.java.StoreFieldNode" => "memory",
+        "jdk.graal.compiler.nodes.java.StoreIndexedNode" => "memory",
+        "jdk.graal.compiler.nodes.KillingBeginNode" => "control",
+        "jdk.graal.compiler.nodes.LoopBeginNode" => "control",
+        "jdk.graal.compiler.nodes.LoopEndNode" => "control",
+        "jdk.graal.compiler.nodes.LoopExitNode" => "control",
+        "jdk.graal.compiler.nodes.memory.ReadNode" => "memory",
+        "jdk.graal.compiler.nodes.memory.WriteNode" => "memory",
+        "jdk.graal.compiler.nodes.MergeNode" => "control",
+        "jdk.graal.compiler.nodes.ParameterNode" => "input",
+        "jdk.graal.compiler.nodes.PrefetchAllocateNode" => "alloc",
+        "jdk.graal.compiler.nodes.ReturnNode" => "control",
+        "jdk.graal.compiler.nodes.StartNode" => "control",
+        "jdk.graal.compiler.nodes.UnwindNode" => "control",
+        "jdk.graal.compiler.nodes.virtual.AllocatedObjectNode" => "virtual",
+        "jdk.graal.compiler.nodes.virtual.CommitAllocationNode" => "alloc",
+        "jdk.graal.compiler.nodes.virtual.VirtualArrayNode" => "virtual",
+        "jdk.graal.compiler.nodes.VirtualObjectState" => "info",
+        "jdk.graal.compiler.replacements.nodes.ArrayEqualsNode" => "memory",
+        "jdk.graal.compiler.replacements.nodes.ReadRegisterNode" => "memory",
+        "jdk.graal.compiler.replacements.nodes.WriteRegisterNode" => "memory",
+        "jdk.graal.compiler.word.WordCastNode" => "memory",
       }
 
       # Render a Graal 'name template'.
@@ -208,15 +251,19 @@ module Seafoam
             e.props[:name] == Regexp.last_match(1)
           end.map { |e| e.from.id }.join(", ")
         end
-        string = string.gsub(/\{x#field\}/) do |_|
+        string = string.gsub("{x#field}") do |_|
           "#{node.props.dig("field", :field_class).split(".").last}.#{node.props.dig("field", :name)}"
         end
-        string = string.gsub(/\{x#state\}/) do |_|
-          "#{node.props.dig("code",
-            :declaring_class)}##{node.props.dig("code",
-              :method_name)} #{node.props["sourceFile"]}:#{node.props["sourceLine"]}"
+        string = string.gsub("{x#state}") do |_|
+          "#{node.props.dig(
+            "code",
+            :declaring_class,
+          )}##{node.props.dig(
+            "code",
+            :method_name,
+          )} #{node.props["sourceFile"]}:#{node.props["sourceLine"]}"
         end
-        string = string.gsub(/\{x#simpleStamp\}/) do |_|
+        string = string.gsub("{x#simpleStamp}") do |_|
           stamp = node.props.dig("checkedStamp")
           if stamp =~ /a!?# L(.*);/
             Regexp.last_match(1)
@@ -230,7 +277,7 @@ module Seafoam
       # Annotate edges with their label and kind.
       def apply_edges(graph)
         graph.edges.each do |edge|
-          if edge.to.node_class == "org.graalvm.compiler.nodes.ValuePhiNode" && edge.props[:name] == "values"
+          if edge.to.node_class.end_with?(".compiler.nodes.ValuePhiNode") && edge.props[:name] == "values"
             merge_node = edge.to.edges.find { |e| e.props[:name] == "merge" }.from
             control_into_merge = ["ends", "loopBegin"]
             merge_node_control_edges_in = merge_node.edges.select do |e|
@@ -278,11 +325,11 @@ module Seafoam
           # (break) to the LoopBeginNode. Both are drawn reversed.
           when "loopBegin"
             case edge.to.node_class
-            when "org.graalvm.compiler.nodes.LoopEndNode"
+            when "org.graalvm.compiler.nodes.LoopEndNode", "jdk.graal.compiler.nodes.LoopEndNode"
               # If it's from the LoopEnd then it's the control edge to follow.
               edge.props[:kind] = "loop"
               edge.props[:reverse] = true
-            when "org.graalvm.compiler.nodes.LoopExitNode"
+            when "org.graalvm.compiler.nodes.LoopExitNode", "jdk.graal.compiler.nodes.LoopExitNode"
               # If it's from the LoopExit then it's just for information - it's
               # not control flow to follow.
               edge.props[:kind] = "info"
@@ -417,16 +464,30 @@ module Seafoam
       end
 
       # If we see these in the graph properties it's probably a Graal graph.
-      TRIGGERS = ["HostedGraphBuilderPhase", "GraalCompiler", "TruffleCompiler"]
+      TRIGGERS = ["HostedGraphBuilderPhase", "GraalCompiler", "TruffleCompiler", "SubstrateCompilation"]
 
       # Simple input node classes that may be inlined.
-      SIMPLE_INPUTS = ["org.graalvm.compiler.nodes.ConstantNode", "org.graalvm.compiler.nodes.ParameterNode"]
+      SIMPLE_INPUTS = [
+        "org.graalvm.compiler.nodes.ConstantNode",
+        "org.graalvm.compiler.nodes.ParameterNode",
+        "jdk.graal.compiler.nodes.ConstantNode",
+        "jdk.graal.compiler.nodes.ParameterNode",
+      ]
 
       # Nodes just to maintain frame state.
-      FRAME_STATE_NODES = ["org.graalvm.compiler.nodes.FrameState",
-                           "org.graalvm.compiler.virtual.nodes.MaterializedObjectState",]
-
-      BEGIN_END_NODES = ["org.graalvm.compiler.nodes.BeginNode", "org.graalvm.compiler.nodes.EndNode"]
+      FRAME_STATE_NODES = [
+        "org.graalvm.compiler.nodes.FrameState",
+        "org.graalvm.compiler.virtual.nodes.MaterializedObjectState",
+        "jdk.graal.compiler.nodes.FrameState",
+        "jdk.graal.compiler.virtual.nodes.MaterializedObjectState",
+      ]
+
+      BEGIN_END_NODES = [
+        "org.graalvm.compiler.nodes.BeginNode",
+        "org.graalvm.compiler.nodes.EndNode",
+        "jdk.graal.compiler.nodes.BeginNode",
+        "jdk.graal.compiler.nodes.EndNode",
+      ]
     end
   end
 end

data/lib/seafoam/passes/truffle.rb

@@ -17,6 +17,7 @@ module Seafoam
       def apply(graph)
         simplify_truffle_args(graph) if @options[:simplify_truffle_args]
         simplify_alloc(graph) if @options[:simplify_alloc]
+        hide_reachability_fences(graph) if @options[:hide_reachability_fences]
       end
 
       private
@@ -25,27 +26,34 @@ module Seafoam
       # like a Graal parameter node.
       def simplify_truffle_args(graph)
         graph.nodes.dup.each_value do |node|
-          next unless node.node_class == "org.graalvm.compiler.nodes.java.LoadIndexedNode"
+          next unless node.node_class.end_with?(".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)
 
-          next unless index_node.node_class == "org.graalvm.compiler.nodes.ConstantNode"
-          next unless array_node.node_class == "org.graalvm.compiler.nodes.ParameterNode"
+          next unless index_node.node_class.end_with?(".compiler.nodes.ConstantNode")
+          next unless array_node.node_class.end_with?(".compiler.nodes.ParameterNode")
 
           node.props[:truffle_arg_load] = true
 
-          index = index_node.props["rawvalue"]
+          lang_formatter = Seafoam::Passes::TruffleTranslators.get_translator(node)
+          index = lang_formatter.translate_argument_load(index_node.props["rawvalue"].to_i)
 
-          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, synthetic_class: "TruffleArgument", inlined: true, label: "T(#{index})", kind: "input" },
+          )
+
+          edges_to_remove = []
 
           node.outputs.each do |output|
             next if output.props[:name] == "next"
 
             graph.create_edge(arg_node, output.to, output.props.dup)
-            graph.remove_edge(output)
+            edges_to_remove << output
           end
+
+          edges_to_remove.each { |edge| graph.remove_edge(edge) }
         end
 
         graph.nodes.each_value.select { |node| node.props[:truffle_arg_load] }.each do |node|
@@ -61,7 +69,7 @@ module Seafoam
       # 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"
+          node.node_class.end_with?(".compiler.nodes.virtual.CommitAllocationNode")
         end
 
         commit_allocation_nodes.each do |commit_allocation_node|
@@ -78,11 +86,16 @@ module Seafoam
 
             virtual_id = m[1].to_i
 
-            (m = /^(\w+(?:\[\])?)\[([0-9,]+)\]$/.match(value)) || raise(value)
+            m = /^([[:alnum:]$]+(?:\[\])?)\[([0-9,]+)\]$/.match(value)
+
+            unless m
+              raise "Unexpected value in allocation node: '#{value}'"
+            end
+
             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"
+            if virtual_node.node_class.end_with?(".compiler.nodes.virtual.VirtualArrayNode")
               label = "New #{class_name[0...-1]}#{virtual_node.props["length"]}]"
               fields = values.size.times.to_a
             else
@@ -91,7 +104,10 @@ module Seafoam
             end
             raise unless fields.size == values.size
 
-            new_node = graph.create_node(graph.new_id, { synthetic: true, label: label, kind: "alloc" })
+            new_node = graph.create_node(
+              graph.new_id,
+              { synthetic: true, synthetic_class: "TruffleNew", label: label, kind: "alloc" },
+            )
 
             object = [new_node, virtual_node, fields, values]
             objects << object
@@ -108,7 +124,7 @@ module Seafoam
                 usage = virtual_to_object[value_id]
                 b.call(usage) if usage
               end
-            end
+            end,
           ).reduce(:concat)
 
           prev = control_flow_pred.from
@@ -116,7 +132,7 @@ module Seafoam
             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"
+              output.to.node_class.end_with?(".compiler.nodes.virtual.AllocatedObjectNode")
             end
             if allocated_object_node
               allocated_object_node = allocated_object_node.to
@@ -131,7 +147,7 @@ module Seafoam
             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") &&
+                  value_node.node_class.end_with?(".compiler.nodes.ConstantNode") &&
                   ["Object[null]", "0"].include?(value_node.props["rawvalue"])
                 value_node.props[:hidden] = true
               else
@@ -149,8 +165,24 @@ module Seafoam
         end
       end
 
+      # Hide reachability fences - they're just really boring.
+      def hide_reachability_fences(graph)
+        graph.nodes.each_value do |node|
+          next unless node.node_class.end_with?(".compiler.nodes.java.ReachabilityFenceNode")
+
+          pred = node.inputs.find { |edge| edge.props[:name] == "next" }
+          succ = node.outputs.find { |edge| edge.props[:name] == "next" }
+
+          graph.create_edge(pred.from, succ.to, pred.props.merge({ synthetic: true }))
+
+          node.props[:hidden] = true
+          pred.props[:hidden] = true
+          succ.props[:hidden] = true
+        end
+      end
+
       # If we see these in the graph properties it's probably a Truffle graph.
-      TRIGGERS = ["TruffleCompiler"]
+      TRIGGERS = ["TruffleCompiler", "TruffleFinal"]
     end
   end
 end

data/lib/seafoam/passes/truffle_translators/default.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Seafoam
+  module Passes
+    module TruffleTranslators
+      class Default
+        def translate_argument_load(index)
+          index.to_s
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/passes/truffle_translators/translators.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Seafoam
+  module Passes
+    module TruffleTranslators
+      autoload :Default, "seafoam/passes/truffle_translators/default"
+      autoload :TruffleRuby, "seafoam/passes/truffle_translators/truffleruby"
+
+      TRUFFLE_LANGUAGES = {
+        "org.truffleruby" => "TruffleRuby",
+      }
+
+      class << self
+        def get_translator(node)
+          translator = node.visit_outputs(:bfs) do |entry|
+            declaring_class = entry.props["code"] || entry.props.dig("nodeSourcePosition", :method)
+
+            if declaring_class
+              subpackage = declaring_class[:declaring_class].match(/^(\w+\.\w+)\./)[1]
+              translator = TRUFFLE_LANGUAGES[subpackage]
+
+              break const_get(translator).new if translator
+            end
+          end
+
+          translator || Default.new
+        end
+      end
+
+      class Default
+        def translate_argument_load(index)
+          index.to_s
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/passes/truffle_translators/truffleruby.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Seafoam
+  module Passes
+    module TruffleTranslators
+      class TruffleRuby < Default
+        TRUFFLERUBY_ARGS = [
+          "DECLARATION_FRAME",
+          "CALLER_SPECIAL_VARIABLES",
+          "METHOD",
+          "DECLARATION_CONTEXT",
+          "FRAME_ON_STACK_MARKER",
+          "SELF",
+          "BLOCK",
+          "DESCRIPTOR",
+        ]
+
+        def translate_argument_load(index)
+          index >= TRUFFLERUBY_ARGS.size ? "args[#{index - TRUFFLERUBY_ARGS.size}]" : TRUFFLERUBY_ARGS[index]
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/search.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "set"
+
+module Seafoam
+  class BFS
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    def search(&block)
+      queue = root.outputs.collect(&:to)
+      visited = Set.new
+
+      until queue.empty?
+        entry = queue.shift
+        visited << entry
+
+        result = entry.visit(&block)
+
+        if result
+          return result
+        else
+          entry.outputs.collect(&:to).each do |child|
+            queue << child unless visited.include?(child)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seafoam/version.rb

@@ -2,6 +2,6 @@
 
 module Seafoam
   MAJOR_VERSION = 0
-  MINOR_VERSION = 14
+  MINOR_VERSION = 16
   VERSION = "#{MAJOR_VERSION}.#{MINOR_VERSION}"
 end

data/lib/seafoam.rb

@@ -9,6 +9,7 @@ require "seafoam/graal/graph_description"
 require "seafoam/graal/source"
 require "seafoam/graal/pi"
 require "seafoam/passes"
+require "seafoam/passes/truffle_translators/translators"
 require "seafoam/passes/truffle"
 require "seafoam/passes/graal"
 require "seafoam/passes/fallback"
@@ -20,3 +21,4 @@ require "seafoam/mermaid_writer"
 require "seafoam/markdown_writer"
 require "seafoam/commands"
 require "seafoam/formatters/formatters"
+require "seafoam/search"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seafoam
 version: !ruby/object:Gem::Version
-  version: '0.14'
+  version: '0.16'
 platform: ruby
 authors:
 - Chris Seaton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-02 00:00:00.000000000 Z
+date: 2024-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -42,14 +42,14 @@ dependencies:
   name: rubocop-shopify
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 2.9.0
 description: 
@@ -86,12 +86,19 @@ files:
 - lib/seafoam/passes/fallback.rb
 - lib/seafoam/passes/graal.rb
 - lib/seafoam/passes/truffle.rb
+- lib/seafoam/passes/truffle_translators/default.rb
+- lib/seafoam/passes/truffle_translators/translators.rb
+- lib/seafoam/passes/truffle_translators/truffleruby.rb
+- lib/seafoam/search.rb
 - lib/seafoam/spotlight.rb
 - lib/seafoam/version.rb
 homepage: https://github.com/Shopify/seafoam
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/Shopify/seafoam/issues
+  source_code_uri: https://github.com/Shopify/seafoam
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -107,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: A tool for working with compiler graphs