seafoam 0.8 → 0.12

data/examples/ruby/ruby_examples.rb

@@ -1,278 +0,0 @@
-# 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/annotators.rb

@@ -1,54 +0,0 @@
-module Seafoam
-  # Annotators are routines to read the graph and apply properties which tools,
-  # such as the render command, can use to show more understandable output.
-  module Annotators
-    # Apply all applicable annotators to a graph.
-    def self.apply(graph, options = {})
-      annotators.each do |annotator|
-        next unless annotator.applies?(graph)
-
-        # Record for information that the annotator annotated this graph.
-        annotated_by = graph.props[:annotated_by] ||= []
-        annotated_by.push annotator
-
-        # Run the annotator.
-        instance = annotator.new(options)
-        instance.annotate graph
-      end
-    end
-
-    # Get a list of all annotators in the system.
-    def self.annotators
-      # Get all subclasses of Annotator.
-      annotators = Annotator::SUBCLASSES.dup
-
-      # We want the FallbackAnnotator to run last.
-      annotators.delete FallbackAnnotator
-      annotators.push FallbackAnnotator
-
-      annotators
-    end
-  end
-
-  # The base class for all annotators. You must subclass this to be recognized
-  # as an annotator.
-  class Annotator
-    SUBCLASSES = []
-
-    def initialize(options = {})
-      @options = options
-    end
-
-    def applies?(_graph)
-      raise NotImplementedError
-    end
-
-    def annotate(_graph)
-      raise NotImplementedError
-    end
-
-    def self.inherited(annotator)
-      SUBCLASSES.push annotator
-    end
-  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

data/lib/seafoam/config.rb

@@ -1,34 +0,0 @@
-module Seafoam
-  # Finds and loads configuration.
-  class Config
-    def initialize
-      @dot_dir = find_dot_dir
-    end
-
-    # Load the configuration.
-    def load_config
-      config_file = File.expand_path('config', @dot_dir)
-      if File.exist?(config_file)
-        puts "loading config #{config_file}" if $DEBUG
-        load config_file
-      end
-    end
-
-    private
-
-    # Walk up the directory chain from the current directory to root, looking
-    # for .seafoam.
-    def find_dot_dir
-      dir = Dir.getwd
-      loop do
-        dot_dir = File.expand_path('.seafoam', dir)
-        return dot_dir if Dir.exist?(dot_dir)
-
-        new_dir = File.expand_path('..', dir)
-        break if new_dir == dir
-
-        dir = new_dir
-      end
-    end
-  end
-end

data/seafoam.gemspec

@@ -1,22 +0,0 @@
-require_relative 'lib/seafoam/version'
-
-Gem::Specification.new do |spec|
-  spec.name     = 'seafoam'
-  spec.version  = Seafoam::VERSION
-  spec.summary  = 'A tool for working with compiler graphs'
-  spec.authors  = ['Chris Seaton']
-  spec.homepage = 'https://github.com/Shopify/seafoam'
-  spec.license = 'MIT'
-
-  spec.files = `git ls-files`.split("\n").reject { |f| f.end_with?('.bgv') || f.end_with?('.cfg') }
-  spec.bindir = 'bin'
-  spec.executables = %w[seafoam bgv2json bgv2isabelle cfg2asm]
-
-  spec.required_ruby_version = '>= 2.5.8'
-
-  spec.add_dependency 'crabstone', '~> 4.0'
-
-  spec.add_development_dependency 'benchmark-ips', '~> 2.7'
-  spec.add_development_dependency 'rspec', '~> 3.8'
-  spec.add_development_dependency 'rubocop', '~> 0.74'
-end

data/spec/seafoam/annotators/fallback_spec.rb

@@ -1,69 +0,0 @@
-require 'seafoam'
-
-require 'rspec'
-
-describe Seafoam::Annotators::FallbackAnnotator do
-  it 'always applies' do
-    expect(Seafoam::Annotators::FallbackAnnotator.applies?(Seafoam::Graph.new)).to be true
-  end
-
-  it 'adds a label annotation when there is a label property' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'label' => 'foo')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to eq 'foo'
-  end
-
-  it 'does not overwrite an existing label annotation' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'label' => 'foo', :label => 'bar')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to eq 'bar'
-  end
-
-  it 'adds nothing when there is no label property' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, 'xlabel' => 'foo')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:label]).to be nil
-  end
-
-  it 'sets node kind to other when there is no kind' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0)
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:kind]).to eq 'other'
-  end
-
-  it 'does not overwrite an existing node kind annotations' do
-    graph = Seafoam::Graph.new
-    node = graph.create_node(0, kind: 'control')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(node.props[:kind]).to eq 'control'
-  end
-
-  it 'sets edge kind to other when there is no kind' do
-    graph = Seafoam::Graph.new
-    node_a = graph.create_node(0)
-    node_b = graph.create_node(1)
-    edge = graph.create_edge(node_a, node_b)
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(edge.props[:kind]).to eq 'other'
-  end
-
-  it 'does not overwrite an existing edge kind annotations' do
-    graph = Seafoam::Graph.new
-    node_a = graph.create_node(0)
-    node_b = graph.create_node(1)
-    edge = graph.create_edge(node_a, node_b, kind: 'control')
-    annotator = Seafoam::Annotators::FallbackAnnotator.new
-    annotator.annotate graph
-    expect(edge.props[:kind]).to eq 'control'
-  end
-end