seafoam 0.15 → 0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30a5f036d6ae3873ad70b1f113fe00015678efe83e5e2dfdbac8e7a2556e76ec
-  data.tar.gz: f8ee8f98c42e1d3a82a47fa58f50867553b5ffe1d532ed4ccebba9224314a4c0
+  metadata.gz: f1fc3a85c02d7d1af7d3835e43359cff6032b617cf3dee449f1519549aef1262
+  data.tar.gz: d5a947fe97c401206f51b56fcdbc1fd97afda7b6c8924c6b842cbb67043dcc4c
 SHA512:
-  metadata.gz: 0bd1f351f0e43737ba6182d156afd405b2d3d69b4b2804c8ef7d556062d857787b7d278a8edfb26462ed65add584a08741968244e9ab47b082a28783a16064a0
-  data.tar.gz: 4da1e9d9c3a5d27c94efbd37fb698820d3d44344b27f2eb030223f045b0f4ba358df2df9e0a0d4becb0b50e862700f493f8c6e587a3cf6b38b58df703468bd99
+  metadata.gz: 7c98e42cf49caa080482e60bd92560b8e3c4eb3a9f2f9f57f50c2c3ff75132d10a6e96a08310865a6d6647dd2d2a1a6be81f86c432404129a37969e1b5866966
+  data.tar.gz: 64213bcdb28b5951839d0d4a2e3eef51cac840880f6707849d9bd7830ad517192dd4b0542530d1d15c439d5d14c4f19fddc758e4f0096d5940d7207f82a4c674

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

@@ -394,11 +394,12 @@ module Seafoam
             description.node_counts[simple_node_class] += 1
 
             case node_class
-            when "org.graalvm.compiler.nodes.IfNode"
+            when "org.graalvm.compiler.nodes.IfNode", "jdk.graal.compiler.nodes.IfNode"
               description.branches = true
-            when "org.graalvm.compiler.nodes.LoopBeginNode"
+            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"
+            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]
@@ -406,7 +407,7 @@ module Seafoam
           end
 
           description.deopts = graph.nodes[0].outputs.map(&:to)
-            .all? { |t| t.node_class == "org.graalvm.compiler.nodes.DeoptimizeNode" }
+            .all? { |t| t.node_class.end_with?(".compiler.nodes.DeoptimizeNode") }
         end
 
         formatter = formatter_module::DescribeFormatter.new(graph, description)

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

@@ -63,7 +63,11 @@ module Seafoam
     end
 
     def node_class
-      @props.dig(:node_class, :node_class)
+      if @props[:synthetic] == true
+        @props[:synthetic_class]
+      else
+        @props.dig(:node_class, :node_class)
+      end
     end
 
     # All edges - input and output.

data/lib/seafoam/json_writer.rb

@@ -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,10 +251,10 @@ 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 |_|
+        string = string.gsub("{x#state}") do |_|
           "#{node.props.dig(
             "code",
             :declaring_class,
@@ -220,7 +263,7 @@ module Seafoam
             :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)
@@ -234,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|
@@ -282,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"
@@ -424,15 +467,27 @@ module Seafoam
       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",
+        "jdk.graal.compiler.nodes.FrameState",
+        "jdk.graal.compiler.virtual.nodes.MaterializedObjectState",
       ]
 
-      BEGIN_END_NODES = ["org.graalvm.compiler.nodes.BeginNode", "org.graalvm.compiler.nodes.EndNode"]
+      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

@@ -26,13 +26,13 @@ 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
 
@@ -69,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|
@@ -95,7 +95,7 @@ module Seafoam
             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
@@ -132,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
@@ -147,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
@@ -168,7 +168,7 @@ module Seafoam
       # Hide reachability fences - they're just really boring.
       def hide_reachability_fences(graph)
         graph.nodes.each_value do |node|
-          next unless node.node_class == "org.graalvm.compiler.nodes.java.ReachabilityFenceNode"
+          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" }

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

@@ -21,6 +21,16 @@ module Seafoam
               subpackage = declaring_class[:declaring_class].match(/^(\w+\.\w+)\./)[1]
               translator = TRUFFLE_LANGUAGES[subpackage]
 
+              unless translator
+                Seafoam::Graal::Source.walk(entry.props.dig("nodeSourcePosition")) do |method|
+                  declaring_class = method[:declaring_class]
+                  subpackage = declaring_class.match(/^(\w+\.\w+)\./)[1]
+                  translator = TRUFFLE_LANGUAGES[subpackage]
+
+                  break if translator
+                end
+              end
+
               break const_get(translator).new if translator
             end
           end

data/lib/seafoam/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seafoam
 version: !ruby/object:Gem::Version
-  version: '0.15'
+  version: '0.17'
 platform: ruby
 authors:
 - Chris Seaton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-04 00:00:00.000000000 Z
+date: 2024-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -114,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.6
 signing_key: 
 specification_version: 4
 summary: A tool for working with compiler graphs