rubinius-coverage 2.0.3 → 2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1b280b252772cabd1b6dae2f74cf7015922d8b8
-  data.tar.gz: 6c0595e0f08af7f85c9fcfe9b3919ecee56f1626
+  metadata.gz: 22c19371e1c8ec5d8177165d91c12f992ebe7d3e
+  data.tar.gz: 893646e9c62de4bcc66de954693a37d3c6ff5615
 SHA512:
-  metadata.gz: 980cc32e4a44471cf67f227f39d8f466ebcdf65b461b64947909df29af10eff230d806b21e3c2e34d42d2282b7deefa147413249de3102ac80283157c2c67598
-  data.tar.gz: bcbc07ec393f6dba5189091382493d9e6d7c4197b7e346089890b3a2713d0c6a8a73bb2a5417158c7e2d9dc0f56eb0dfa501fdb114936f9bf541b8c6ebcf7263
+  metadata.gz: 02895b2ce0adefd94c062611273d0715be55416eb502ce557982141f2e6bff475dda338c0372e0f1e20b3bd674e805448ccc355154ba8d11bf43f759a385ade7
+  data.tar.gz: 12a4dcddd1d91c319186f4ae52edc46dbb404e089101563e60c86e5b2beb58ad1c71e185952e265750fb16213d5c51e8e5b2b677d6116ece850bed4b89c45278

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+
+desc "Run the specs"
+task :spec do
+  sh "rspec -I spec spec"
+end
+
+task :default => :spec

data/lib/rubinius/coverage.rb

@@ -2,39 +2,186 @@ require "rubinius/coverage/version"
 
 module Rubinius
   class Coverage
-    def self.loaded(flag)
-      @loaded = flag
-    end
+    class CFG
+      attr_accessor :code, :call_sites, :basic_blocks, :enter, :exit
 
-    def self.loaded?
-      @loaded == true
-    end
+      def initialize(code, call_sites)
+        @code = code
+        @call_sites = call_sites
+        @basic_blocks = Hash.new { |h, k| h[k] = BasicBlock.new k }
+      end
 
-    def self.load
-      return if loaded?
+      def graph
+        iseq = @code.iseq
+        total = iseq.size
+        i = 0
 
-      Rubinius::Tooling.load File.expand_path('../coverage/coverage', __FILE__)
-      loaded true
+        @enter = BasicBlock.new 0
+        @enter.left = bb = @basic_blocks[0]
 
-      self
-    end
+        @exit = @basic_blocks[total]
+
+        while i < total
+          opcode = InstructionSet[iseq[i]]
+
+          if @basic_blocks.has_key? i
+            bb.exit_ip = i-1
+            bb = bb.left = @basic_blocks[i]
+          else
+            bb.exit_ip = i+opcode.width-1
+
+            case opcode.control_flow
+            when :branch
+              bb.left = @basic_blocks[iseq[i+1]]
+              bb.left.exit_ip = total
+
+              next_bb = @basic_blocks[i+opcode.width]
+              bb.right = next_bb if opcode.name != :goto
+
+              bb = next_bb
+            when :raise, :return
+              bb.left = @exit
+              bb = @basic_blocks[i+opcode.width]
+            end
+          end
+
+          i += opcode.width
+        end
+
+        @basic_blocks.values.each do |bb|
+          # Split if a jump target intersects our range
+          i = bb.enter_ip
+          while i < bb.exit_ip
+            opcode = InstructionSet[iseq[i]]
+            i += opcode.width
+
+            if @basic_blocks.has_key? i
+              bb.exit_ip = i-1
+
+              if opcode.control_flow != :branch
+                bb.left = @basic_blocks[i]
+                bb.right = nil
+              end
+
+              break
+            end
+          end
+
+          bb.coverage @code, @call_sites
+        end
+
+        stack = [@enter]
+        cycles = {}
+
+        until stack.empty?
+          bb = stack.shift
+
+          if left = bb.left
+            left.count = bb.count if bb.count > left.count
+            unless cycles.has_key? left
+              stack << left
+              cycles[left] = true
+            end
+          end
 
-    attr_reader :results
+          if right = bb.right
+            right.count = bb.count if bb.count > right.count
+            unless cycles.has_key? right
+              stack << right
+              cycles[right] = true
+            end
+          end
+        end
 
-    def initialize
-      self.class.load
+        # Flow coverage counts backwards
+        @basic_blocks.values.each do |bb|
+          if bb.count == 0
+            if (bb.left and bb.left.count > 0) or
+               (bb.right and bb.right.count > 0)
+              bb.count = 1
+            end
+          end
+        end
+      end
+
+      class BasicBlock
+        attr_accessor :enter_ip, :exit_ip, :left, :right, :lines, :count
+
+        def initialize(enter_ip)
+          @enter_ip = @exit_ip = enter_ip
+          @lines = []
+          @count = 0
+        end
+
+        def coverage(code, call_sites)
+          total = code.lines.size - 2
+          i = 0
+
+          while i < total
+            if (@enter_ip < code.lines[i+2] and @exit_ip >= code.lines[i]) or
+               (code.lines[i+2] == 0 and @enter_ip == 0)
+              line = code.lines[i+1]
+              @lines << line unless @lines.include? line
+            end
+
+            i += 2
+          end
+
+          call_sites.each do |cs|
+            if cs.ip >= @enter_ip and cs.ip <= @exit_ip
+              cs_count = cs.invokes + cs.hits + cs.misses
+              @count = cs_count if cs_count > @count
+            end
+          end
+        end
+      end
     end
 
+    # Coverage methods
+
     def start
-      Rubinius::Tooling.enable
+      ObjectSpace.each_object(Rubinius::CallSite) { |cs| cs.reset }
 
-      self
+      nil
     end
 
-    def stop
-      @results = Rubinius::Tooling.disable
+    def coverage(code)
+      call_sites = code.call_sites
+      return unless call_sites.any? { |cs| cs.invokes + cs.hits + cs.misses > 0 }
+
+      cfg = CFG.new code, call_sites
+      cfg.graph
+
+      counts = {}
+
+      total = code.lines.size
+      i = 1
+
+      while i < total
+        counts[code.lines[i]] = 0
+        i += 2
+      end
+
+      cfg.basic_blocks.values.each do |bb|
+        bb.lines.each { |l| counts[l] = bb.count }
+      end
+
+      counts
+    end
+
+    def result
+      code_coverage = Hash.new { |h, k| h[k] = [] }
+
+      ObjectSpace.each_object(Rubinius::CompiledCode) do |code|
+        lines = code_coverage[code.file.to_s]
+        counts = coverage code
+        next unless counts
+
+        counts.each { |line, count| lines[line] = count }
+      end
 
-      self
+      code_coverage.delete_if { |k, v| v.empty? }
+      code_coverage
     end
   end
 end

data/lib/rubinius/coverage/version.rb

@@ -1,5 +1,5 @@
 module Rubinius
   class Coverage
-    VERSION = "2.0.3"
+    VERSION = "2.1"
   end
 end

data/rubinius-coverage.gemspec

@@ -13,10 +13,10 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.extensions    = ["ext/rubinius/coverage/extconf.rb"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3"
 end

data/spec/basic_block/double_branch_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+module CoverageSpecs
+  class DoubleBranch
+    def m
+      a = 1
+      if a == 2
+        3
+      else
+        2
+      end
+
+      4
+    end
+  end
+end
+
+describe Rubinius::Coverage do
+  context "with a single branch" do
+    let(:obj) { CoverageSpecs::DoubleBranch.new }
+    let(:code) { obj.method(:m).executable }
+
+    describe Rubinius::Coverage::CFG do
+      let(:cfg) { Rubinius::Coverage::CFG.new code, code.call_sites }
+
+      before do
+        cfg.graph
+      end
+
+      describe "#graph" do
+        it "creates five BasicBlock instances" do
+          expect(cfg.basic_blocks.size).to eql(5)
+        end
+
+        it "creates a basic block at IP 0-13" do
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.enter_ip).to eql(0)
+          expect(bb.exit_ip).to eql(13)
+        end
+
+        it "creates a basic block at IP 14-17" do
+          bb = cfg.basic_blocks[14]
+
+          expect(bb.enter_ip).to eql(14)
+          expect(bb.exit_ip).to eql(17)
+        end
+
+        it "creates a basic block at IP 18-19" do
+          bb = cfg.basic_blocks[18]
+
+          expect(bb.enter_ip).to eql(18)
+          expect(bb.exit_ip).to eql(19)
+        end
+
+        it "creates a basic block at IP 20-23" do
+          bb = cfg.basic_blocks[20]
+
+          expect(bb.enter_ip).to eql(20)
+          expect(bb.exit_ip).to eql(23)
+        end
+
+        it "set the count of the times the basic block was executed" do
+          obj.m
+          cfg.graph
+
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.count).to eql(1)
+        end
+
+        it "sets the lines covered by the basic block" do
+          lines = cfg.basic_blocks[0].lines
+
+          expect(lines.size).to eql(3)
+          expect(lines[0]).to eql(5)
+          expect(lines[1]).to eql(6)
+          expect(lines[2]).to eql(7)
+        end
+      end
+    end
+
+    describe "#coverage" do
+      it "returns a map of source code lines to execution counts" do
+        coverage = Rubinius::Coverage.new.coverage code
+
+        expect(coverage.size).to eql(7)
+        expect(coverage[5]).to eql(1)
+        expect(coverage[6]).to eql(1)
+        expect(coverage[7]).to eql(1)
+        expect(coverage[8]).to eql(1)
+        # TODO: fix bug generating line info for lines 9, 11, 12 in the code
+        # above.
+        expect(coverage[10]).to eql(1)
+        expect(coverage[13]).to eql(1)
+      end
+    end
+  end
+end

data/spec/basic_block/loop_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+module CoverageSpecs
+  class LoopBranch
+    def m
+      i = 1
+      while i < 10
+        2
+        i += 1
+      end
+
+      4
+    end
+  end
+end
+
+describe Rubinius::Coverage do
+  context "with a loop branch" do
+    let(:obj) { CoverageSpecs::LoopBranch.new }
+    let(:code) { obj.method(:m).executable }
+
+    describe Rubinius::Coverage::CFG do
+      let(:cfg) { Rubinius::Coverage::CFG.new code, code.call_sites }
+
+      before do
+        cfg.graph
+      end
+
+      describe "#graph" do
+        it "creates five BasicBlock instances" do
+          expect(cfg.basic_blocks.size).to eql(5)
+        end
+
+        it "creates a basic block at IP 0-4" do
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.enter_ip).to eql(0)
+          expect(bb.exit_ip).to eql(4)
+        end
+
+        it "creates a basic block at IP 5-13" do
+          bb = cfg.basic_blocks[5]
+
+          expect(bb.enter_ip).to eql(5)
+          expect(bb.exit_ip).to eql(13)
+        end
+
+        it "creates a basic block at IP 14-29" do
+          bb = cfg.basic_blocks[14]
+
+          expect(bb.enter_ip).to eql(14)
+          expect(bb.exit_ip).to eql(29)
+        end
+
+        it "creates a basic block at IP 30-34" do
+          bb = cfg.basic_blocks[30]
+
+          expect(bb.enter_ip).to eql(30)
+          expect(bb.exit_ip).to eql(34)
+        end
+
+        it "set the count of the times the basic block was executed" do
+          obj.m
+          cfg.graph
+
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.count).to eql(1)
+        end
+
+        it "sets the lines covered by the basic block" do
+          lines = cfg.basic_blocks[0].lines
+
+          expect(lines.size).to eql(2)
+          expect(lines[0]).to eql(5)
+          expect(lines[1]).to eql(6)
+        end
+      end
+    end
+
+    describe "#coverage" do
+      it "returns a map of source code lines to execution counts" do
+        coverage = Rubinius::Coverage.new.coverage code
+
+        expect(coverage.size).to eql(7)
+        expect(coverage[5]).to eql(1)
+        expect(coverage[6]).to eql(1)
+        expect(coverage[7]).to eql(10)
+        expect(coverage[8]).to eql(9)
+        expect(coverage[9]).to eql(9)
+        # TODO: fix bug generating line info for lines 10, 11, 12 in the code
+        # above.
+      end
+    end
+  end
+end

data/spec/basic_block/single_branch_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+module CoverageSpecs
+  class SingleBranch
+    def m
+      a = 1
+      if a == 2
+        3
+      end
+
+      4
+    end
+  end
+end
+
+describe Rubinius::Coverage do
+  context "with a single branch" do
+    let(:obj) { CoverageSpecs::SingleBranch.new }
+    let(:code) { obj.method(:m).executable }
+
+    describe Rubinius::Coverage::CFG do
+      let(:cfg) { Rubinius::Coverage::CFG.new code, code.call_sites }
+
+      before do
+        cfg.graph
+      end
+
+      describe "#graph" do
+        it "creates five BasicBlock instances" do
+          expect(cfg.basic_blocks.size).to eql(5)
+        end
+
+        it "creates a basic block at IP 0-13" do
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.enter_ip).to eql(0)
+          expect(bb.exit_ip).to eql(13)
+        end
+
+        it "creates a basic block at IP 14-17" do
+          bb = cfg.basic_blocks[14]
+
+          expect(bb.enter_ip).to eql(14)
+          expect(bb.exit_ip).to eql(17)
+        end
+
+        it "creates a basic block at IP 18-18" do
+          bb = cfg.basic_blocks[18]
+
+          expect(bb.enter_ip).to eql(18)
+          expect(bb.exit_ip).to eql(18)
+        end
+
+        it "creates a basic block at IP 19-22" do
+          bb = cfg.basic_blocks[19]
+
+          expect(bb.enter_ip).to eql(19)
+          expect(bb.exit_ip).to eql(22)
+        end
+
+        it "set the count of the times the basic block was executed" do
+          obj.m
+          cfg.graph
+
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.count).to eql(1)
+        end
+
+        it "sets the lines covered by the basic block" do
+          lines = cfg.basic_blocks[0].lines
+
+          expect(lines.size).to eql(3)
+          expect(lines[0]).to eql(5)
+          expect(lines[1]).to eql(6)
+          expect(lines[2]).to eql(7)
+        end
+      end
+    end
+
+    describe "#coverage" do
+      it "returns a map of source code lines to execution counts" do
+        coverage = Rubinius::Coverage.new.coverage code
+
+        expect(coverage.size).to eql(6)
+        expect(coverage[5]).to eql(1)
+        expect(coverage[6]).to eql(1)
+        expect(coverage[7]).to eql(1)
+        expect(coverage[8]).to eql(1)
+        # TODO: fix bug generating line info for lines 9, 10 in the code
+        # above.
+        expect(coverage[11]).to eql(1)
+      end
+    end
+  end
+end

data/spec/basic_block/single_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+module CoverageSpecs
+  class Single
+    def m
+      a = 1
+      b = 2
+      c = a + b
+      c.to_s
+    end
+  end
+end
+
+describe Rubinius::Coverage do
+  context "with a single basic block" do
+    let(:obj) { CoverageSpecs::Single.new }
+    let(:code) { obj.method(:m).executable }
+
+    describe Rubinius::Coverage::CFG do
+      let(:cfg) { Rubinius::Coverage::CFG.new code, code.call_sites }
+
+      before do
+        cfg.graph
+      end
+
+      describe "#graph" do
+        it "creates a single BasicBlock instance" do
+          expect(cfg.basic_blocks.size).to eql(2)
+        end
+
+        it "sets the enter and exit IP for the basic block" do
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.enter_ip).to eql(0)
+          expect(bb.exit_ip).to eql(24)
+        end
+
+        it "set the count of the times the basic block was executed" do
+          obj.m
+          cfg.graph
+
+          bb = cfg.basic_blocks[0]
+
+          expect(bb.count).to eql(1)
+        end
+
+        it "sets the lines covered by the basic block" do
+          lines = cfg.basic_blocks[0].lines
+
+          expect(lines.size).to eql(5)
+          expect(lines[0]).to eql(5)
+          expect(lines[1]).to eql(6)
+          expect(lines[2]).to eql(7)
+          expect(lines[3]).to eql(8)
+          expect(lines[4]).to eql(9)
+        end
+      end
+    end
+
+    describe "#coverage" do
+      it "returns a map of source code lines to execution counts" do
+        coverage = Rubinius::Coverage.new.coverage code
+
+        expect(coverage.size).to eql(5)
+        expect(coverage[5]).to eql(1)
+        expect(coverage[6]).to eql(1)
+        expect(coverage[7]).to eql(1)
+        expect(coverage[8]).to eql(1)
+        expect(coverage[9]).to eql(1)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require "rubinius/coverage"

metadata

@@ -1,22 +1,22 @@
 --- !ruby/object:Gem::Specification
 name: rubinius-coverage
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: '2.1'
 platform: ruby
 authors:
 - Brian Shirai
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-15 00:00:00.000000000 Z
+date: 2016-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+  name: bundler
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -25,12 +25,12 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
-  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+  name: rake
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -38,12 +38,25 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  name: rspec
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
 description: Rubinius coverage tool.
 email:
 - brixen@gmail.com
 executables: []
-extensions:
-- ext/rubinius/coverage/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
@@ -51,11 +64,14 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- ext/rubinius/coverage/coverage.cpp
-- ext/rubinius/coverage/extconf.rb
 - lib/rubinius/coverage.rb
 - lib/rubinius/coverage/version.rb
 - rubinius-coverage.gemspec
+- spec/basic_block/double_branch_spec.rb
+- spec/basic_block/loop_spec.rb
+- spec/basic_block/single_branch_spec.rb
+- spec/basic_block/single_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/rubinius/rubinius-coverage
 licenses:
 - BSD
@@ -76,9 +92,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.7
+rubygems_version: 2.6.2
 signing_key: 
 specification_version: 4
 summary: Rubinius coverage tool.
-test_files: []
-has_rdoc: 
+test_files:
+- spec/basic_block/double_branch_spec.rb
+- spec/basic_block/loop_spec.rb
+- spec/basic_block/single_branch_spec.rb
+- spec/basic_block/single_spec.rb
+- spec/spec_helper.rb

data/ext/rubinius/coverage/coverage.cpp

@@ -1,163 +0,0 @@
-#include <rbxti.hpp>
-#include <rbxti/atomic.hpp>
-#include <rbx_config.h>
-
-#include <iostream>
-#ifdef RBX_HAVE_TR1
-#include <tr1/unordered_map>
-#define std_unordered_map std::tr1::unordered_map
-#else
-#include <unordered_map>
-#define std_unordered_map std::unordered_map
-#endif
-
-using namespace rbxti;
-
-#if defined(RBX_HAVE_TR1) && !defined(RBX_HAVE_TR1_HASH)
-namespace std {
-  namespace tr1 {
-    template <>
-      struct hash<r_mint> {
-        size_t operator()(const r_mint id) const {
-          return id;
-        }
-      };
-  }
-}
-#endif
-
-namespace coverage {
-
-  typedef std_unordered_map<int, int> InstructionCoverageMap;
-  typedef std_unordered_map<r_mint, InstructionCoverageMap*> CoverageMap;
-
-  class Coverage {
-    CoverageMap coverage_map_;
-    rbxti::SpinLock lock_;
-
-  public:
-    Coverage() { }
-    ~Coverage();
-
-    void lock() {
-      lock_.lock();
-    }
-
-    void unlock() {
-      lock_.unlock();
-    }
-
-    void add(Env* env, r_mint id, int ip);
-    robject results(Env* env);
-  };
-
-  Coverage::~Coverage() {
-    for(CoverageMap::iterator i = coverage_map_.begin();
-        i != coverage_map_.end();
-        i++) {
-      delete i->second;
-    }
-  }
-
-  void Coverage::add(Env* env, r_mint id, int ip) {
-    lock();
-
-    InstructionCoverageMap *map;
-    CoverageMap::iterator i = coverage_map_.find(id);
-
-    if(i == coverage_map_.end()) {
-      map = new InstructionCoverageMap;
-      coverage_map_[id] = map;
-    } else {
-      map = i->second;
-    }
-
-    InstructionCoverageMap::iterator j = map->find(ip);
-
-    if(j == map->end()) {
-      (*map)[ip] = 1;
-    } else {
-      (*map)[ip] += 1;
-    }
-
-    unlock();
-  }
-
-  static void ccode_iterator(Env* env, rcompiled_code code, void* data) {
-    rtable map = (rtable)data;
-    r_mint id = env->method_id(code);
-
-    bool found = false;
-    robject obj = env->table_fetch(map, env->integer_new(id), &found);
-    if(!found) return;
-
-    rtable attr = env->cast_to_rtable(obj);
-    if(!attr) return;
-
-    env->table_store(attr, env->symbol("code"), code);
-  }
-
-  robject Coverage::results(Env* env) {
-    rtable coverage_map = env->table_new();
-
-    for(CoverageMap::iterator i = coverage_map_.begin();
-        i != coverage_map_.end();
-        i++) {
-      InstructionCoverageMap* map = i->second;
-      rtable method_map = env->table_new();
-
-      for(InstructionCoverageMap::iterator j = map->begin();
-          j != map->end();
-          j++) {
-        env->table_store(method_map,
-                         env->integer_new(j->first),
-                         env->integer_new(j->second));
-      }
-
-      rtable attr = env->table_new();
-      env->table_store(attr, env->symbol("counts"), method_map);
-
-      env->table_store(coverage_map, env->integer_new(i->first), attr);
-    }
-
-    env->find_all_compiled_code(ccode_iterator, (void*)coverage_map);
-
-    return coverage_map;
-  }
-
-  namespace {
-    void coverage_enable(Env* env) {
-      Coverage* coverage = new Coverage;
-      env->set_global_tool_data(coverage);
-    }
-
-    robject coverage_results(Env* env) {
-      Coverage* coverage = reinterpret_cast<Coverage*>(env->global_tool_data());
-
-      env->set_tool_at_ip(NULL);
-      env->set_global_tool_data(NULL);
-
-      robject results = coverage->results(env);
-      delete coverage;
-
-      return results;
-    }
-
-    void coverage_at_ip(Env* env, rmachine_code mcode, int ip) {
-      Coverage* coverage = reinterpret_cast<Coverage*>(env->global_tool_data());
-
-      if(!coverage) return;
-
-      coverage->add(env, env->machine_code_id(mcode), ip);
-    }
-  }
-
-  extern "C" int Tool_Init(Env* env) {
-    env->set_tool_enable(coverage_enable);
-    env->set_tool_results(coverage_results);
-
-    env->set_tool_at_ip(coverage_at_ip);
-
-    return 1;
-  }
-}

data/ext/rubinius/coverage/extconf.rb

@@ -1,3 +0,0 @@
-require 'mkmf'
-
-create_makefile 'rubinius/coverage/coverage'