seafoam 0.3 → 0.8

data/docs/bgv.md

@@ -57,7 +57,8 @@ GraphBody {
   Props props
   sint32 nodes_count
   Node[nodes_count] nodes
-  Blocks blocks
+  sint32 blocks_count
+  Blocks[blocks_count] blocks
 }
 
 Node {

data/docs/getting-graphs.md

@@ -53,3 +53,11 @@ You may want to disable on-stack-replacement and inlining with
 easier to understand.
 
 You may need to use `--experimental-options`.
+
+## Getting basic blocks
+
+To get the graph when scheduled, so that you can see basic blocks, use `-Dgraal.PrintGraphWithSchedule=true`. Truffle graphs beyond the initial stages have scheduling information by default.
+
+## Getting CFG files
+
+To also get CFG files, add `-Dgraal.PrintBackendCFG=true`, or `--vm.Dgraal.PrintBackendCFG=true` for Truffle.

data/examples/Fib.java

@@ -1,6 +1,6 @@
 /*
  * % javac Fib.java
- * % java -XX:CompileOnly=::fib -Dgraal.Dump=:2 Fib 14
+ * % java -XX:CompileOnly=::fib -Dgraal.Dump=:2 -Dgraal.PrintGraphWithSchedule=true Fib 14
  */
 
 class Fib {

data/examples/fib.js

@@ -1,4 +1,4 @@
-// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 -f fib.js 14
+// % node --experimental-options --engine.CompileOnly=fib --engine.Inlining=false --vm.Dgraal.Dump=Truffle:2 fib.js 14
 
 function fib(n) {
   if (n <= 1) {

data/examples/java/JavaExamples.java

@@ -1,6 +1,6 @@
 /*
  * % javac JavaExamples.java
- * % java -XX:-UseOnStackReplacement '-XX:CompileCommand=dontinline,*::*' -XX:+PrintCompilation -Dgraal.Dump=:3 JavaExamples
+ * % java -XX:-UseOnStackReplacement '-XX:CompileCommand=dontinline,*::*' -XX:+PrintCompilation -Dgraal.PrintBackendCFG=true -Dgraal.Dump=:3 JavaExamples
  */
 
 import java.lang.reflect.Field;

data/examples/ruby/clamps.rb

@@ -0,0 +1,20 @@
+# ruby --experimental-options --engine.CompileOnly=clamp_low,clamp_high --vm.Dgraal.Dump=Truffle:2 --vm.Dgraal.PrintBackendCFG=true clamps.rb 
+
+def clamp_high(min, max, value)
+  [min, max, value].sort[1]
+end
+
+def clamp_low(min, max, value)
+  if value > max
+    max
+  elsif value < min
+    min
+  else
+    value
+  end
+end
+
+loop do
+  clamp_high(10, 90, rand(100))
+  clamp_low(10, 90, rand(100))
+end

data/examples/ruby/graal.patch

@@ -0,0 +1,15 @@
+diff --git a/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java b/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
+index ffe01c1688f..d662a7096c4 100644
+--- a/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
++++ b/compiler/src/org.graalvm.compiler.truffle.compiler/src/org/graalvm/compiler/truffle/compiler/phases/inlining/DefaultInliningPolicy.java
+@@ -114,6 +114,10 @@ final class DefaultInliningPolicy implements InliningPolicy {
+         final PriorityQueue<CallNode> inlineQueue = getQueue(tree, CallNode.State.Expanded);
+         CallNode candidate;
+         while ((candidate = inlineQueue.poll()) != null) {
++            if (candidate.getName().startsWith("Object#opaque_") || candidate.getName().equals("Object#static_call") || candidate.getName().equals("ExampleObject#instance_call")) {
++                continue;
++            }
++
+             if (candidate.isTrivial()) {
+                 candidate.inline();
+                 continue;

data/examples/ruby/ruby_examples.rb

@@ -0,0 +1,278 @@
+# truffleruby_primitives: true
+
+# We're using Graal with graal.patch, to disable some inlining.
+
+# % ruby --jvm --experimental-options --engine.OSR=false --engine.MultiTier=false --engine.TraceCompilation --vm.Dgraal.Dump=Truffle:1 ruby_examples.rb
+
+RANDOM = Random.new
+EXCEPTION = Exception.new
+
+def example_local_variables(x, y)
+  a = x + y
+  a * 2 + a
+end
+
+def example_local_variables_state(x, y)
+  a = x + y
+  opaque_call
+  a * 2 + a
+end
+
+def example_arith_operator(x, y)
+  x + y
+end
+
+def example_compare_operator(x, y)
+  x <= y
+end
+
+def example_phi(condition, x)
+  if condition
+    a = opaque_call_a
+  else
+    a = opaque_call_b
+  end
+  a + x
+end
+
+def example_simple_call(object, x)
+  object.instance_call(x)
+end
+
+def example_stamp(x)
+  x & 0x1234
+end
+
+def example_full_escape(x)
+  a = [x]
+  Primitive.blackhole a
+  a[0]
+end
+
+def example_no_escape(x)
+  a = [x]
+  a[0]
+end
+
+def example_partial_escape(condition, x)
+  a = [x]
+  if condition
+    Primitive.blackhole a
+    a[0]
+  else
+    a[0]
+  end
+end
+
+def example_if(condition, x, y)
+  if condition
+    Primitive.blackhole x
+    a = x
+  else
+    Primitive.blackhole y
+    a = y
+  end
+  a
+end
+
+def example_if_never_taken(condition, x, y)
+  if condition
+    Primitive.blackhole x
+    a = x
+  else
+    Primitive.blackhole y
+    a = y
+  end
+  a
+end
+
+def example_int_switch(value, x, y, z)
+  case value
+  when 0
+    Primitive.blackhole x
+    a = x
+  when 1
+    Primitive.blackhole y
+    a = y
+  else
+    Primitive.blackhole z
+    a = z
+  end
+  a
+end
+
+def example_string_switch(value, x, y, z)
+  case value
+  when 'foo'
+    Primitive.blackhole x
+    a = x
+  when 'bar'
+    Primitive.blackhole y
+    a = y
+  else
+    Primitive.blackhole z
+    a = z
+  end
+  a
+end
+
+def example_while(count)
+  a = count
+  while a > 0
+    Primitive.blackhole a
+    a -= 1
+  end
+  count
+end
+
+def example_for(count)
+  count.times do |a|
+    Primitive.blackhole a
+  end
+end
+
+def example_nested_while(count)
+  a = count
+  while (a > 0)
+    y = count
+    while (y > 0)
+      Primitive.blackhole a
+      y -= 1
+    end
+    a -= 1
+  end
+  count
+end
+
+def example_while_break(count)
+  a = count
+  while a > 0
+    if a == 4
+      break
+    end
+    Primitive.blackhole a
+    a -= 1
+  end
+  count
+end
+
+def example_raise
+  raise EXCEPTION
+end
+
+def example_rescue
+  begin
+    opaque_raise
+  rescue Exception => e
+    Primitive.blackhole e
+  end
+end
+
+def example_raise_rescue
+  begin
+    raise EXCEPTION
+  rescue Exception => e
+    Primitive.blackhole e
+  end
+end
+
+def example_object_allocation(x)
+  ExampleObject.new(x)
+end
+
+def example_array_allocation(x, y)
+  [x, y]
+end
+
+def example_field_write(object, x)
+  object.x = x
+end
+
+def example_field_read(object)
+  object.x
+end
+
+def example_array_write(array, n, x)
+  array[n] = x
+end
+
+def example_array_read(array, n)
+  array[n]
+end
+
+def example_instance_of(x)
+  x.is_a?(ExampleObject)
+end
+
+# no inline
+def opaque_call
+  RANDOM.rand(1000)
+end
+
+# no inline
+def opaque_call_a
+  opaque_call
+end
+
+# no inline
+def opaque_call_b
+  opaque_call
+end
+
+# no inline
+def opaque_raise
+  raise EXCEPTION
+end
+
+# no inline
+def static_call(x)
+  x
+end
+
+class ExampleObject
+  attr_accessor :x
+  
+  def initialize(x)
+    @x = x
+  end
+
+  # no inline
+  def instance_call(y)
+    @x + y
+  end
+end
+
+loop do
+  example_local_variables RANDOM.rand(1000), RANDOM.rand(1000)
+  example_local_variables_state RANDOM.rand(1000), RANDOM.rand(1000)
+  example_arith_operator RANDOM.rand(1000), RANDOM.rand(1000)
+  example_compare_operator RANDOM.rand(1000), RANDOM.rand(1000)
+  example_phi [true, false].sample, RANDOM.rand(1000)
+  example_simple_call ExampleObject.new(RANDOM.rand(1000)), RANDOM.rand(1000)
+  example_stamp RANDOM.rand(1000)
+  example_full_escape RANDOM.rand(1000)
+  example_no_escape RANDOM.rand(1000)
+  example_partial_escape [true, false].sample, RANDOM.rand(1000)
+  example_if [true, false].sample, RANDOM.rand(1000), RANDOM.rand(1000)
+  example_if_never_taken false, RANDOM.rand(1000), RANDOM.rand(1000)
+  example_int_switch RANDOM.rand(3), RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)
+  example_string_switch ['foo', 'bar', 'baz'].sample, RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)
+  example_while RANDOM.rand(10)
+  example_for RANDOM.rand(10)
+  example_nested_while RANDOM.rand(10)
+  example_while_break RANDOM.rand(10)
+  begin
+    example_raise
+  rescue Exception => e
+    #
+  end
+  example_rescue
+  example_raise_rescue
+  example_object_allocation RANDOM.rand(1000)
+  example_array_allocation RANDOM.rand(1000), RANDOM.rand(1000)
+  example_field_write ExampleObject.new(RANDOM.rand(1000)), RANDOM.rand(1000)
+  example_field_read ExampleObject.new(RANDOM.rand(1000))
+  example_array_write [RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)], RANDOM.rand(3), RANDOM.rand(1000)
+  example_array_read [RANDOM.rand(1000), RANDOM.rand(1000), RANDOM.rand(1000)], RANDOM.rand(3)
+  example_instance_of [Object.new, ExampleObject.new(0)].sample
+end

data/lib/seafoam.rb

@@ -1,13 +1,17 @@
 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'
+require 'seafoam/graal/source'
 require 'seafoam/annotators'
 require 'seafoam/annotators/graal'
 require 'seafoam/annotators/fallback'
 require 'seafoam/spotlight'
+require 'seafoam/isabelle_writer'
+require 'seafoam/json_writer'
 require 'seafoam/graphviz_writer'
 require 'seafoam/config'
 require 'seafoam/commands'

data/lib/seafoam/annotators/graal.rb

@@ -357,7 +357,7 @@ module Seafoam
       TRIGGERS = %w[
         HostedGraphBuilderPhase
         GraalCompiler
-        TruffleCompilerThread
+        TruffleCompiler
       ]
 
       # Simple input node classes that may be inlined.

data/lib/seafoam/bgv/bgv_parser.rb

@@ -127,13 +127,21 @@ module Seafoam
             end
           end
         end
-        skip_blocks
+
+        # Read block information.
+        @reader.read_sint32.times do
+          block_id = @reader.read_sint32
+          block_nodes = @reader.read_sint32.times.map { @reader.read_sint32 }
+          # Followers aren't used but could be.
+          @reader.read_sint32.times.map { @reader.read_sint32 }
+          graph.create_block block_id, block_nodes
+        end
         graph
       end
 
       # Skip over a graph, having read or skipped its headers.
       def skip_graph
-        # Already read BEGIN_GRAPH, id, format, args, and props
+        # Already read BEGIN_GRAPH, id, format, args, and props.
         @reader.read_sint32.times do
           @reader.skip_int32
           node_class = read_pool_object

data/lib/seafoam/cfg/cfg_parser.rb

@@ -0,0 +1,93 @@
+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