debug 1.0.0.alpha1 → 1.0.0.beta1

data/Rakefile

@@ -7,4 +7,24 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task :default => :test
+require "rake/extensiontask"
+
+task :build => :compile
+
+Rake::ExtensionTask.new("debug") do |ext|
+  ext.lib_dir = "lib/debug"
+end
+
+task :default => [:clobber, :compile, :test, 'README.md']
+
+file 'README.md' => ['lib/debug/session.rb', 'exe/rdbg', 'misc/README.md.erb'] do
+  require_relative 'lib/debug/session'
+  require 'erb'
+  File.write 'README.md', ERB.new(File.read('misc/README.md.erb')).result
+  puts 'README.md is updated.'
+end
+
+task :run => :compile do
+  system(RbConfig.ruby, *%w(-I ./lib test.rb))
+end
+

data/debug.gemspec

@@ -6,17 +6,14 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Koichi Sasada"]
   spec.email         = ["ko1@atdot.net"]
 
-  spec.summary       = %q{debug.rb}
-  spec.description   = %q{debug.rb}
-  spec.homepage      = "https://github.com/ko1/debug"
-  spec.license       = "MIT"
+  spec.summary       = %q{Debugging functionality for Ruby}
+  spec.description   = %q{Debugging functionality for Ruby. This is completely rewritten debug.rb which was contained by the encient Ruby versions.}
+  spec.homepage      = "https://github.com/ruby/debug"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
   spec.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/ko1/debug"
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["source_code_uri"] = spec.homepage
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -26,7 +23,5 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
-  spec.add_runtime_dependency 'debug_inspector'
-  spec.add_runtime_dependency 'iseq_collector'
+  spec.extensions    = ['ext/debug/extconf.rb']
 end

data/exe/rdbg

@@ -1,3 +1,34 @@
 #!/usr/bin/env ruby
 
-require "debug"
+require_relative '../lib/debug/client'
+
+config = DEBUGGER__.parse_argv(ARGV)
+
+case config[:mode]
+when :start
+  require 'rbconfig'
+
+  if config[:remote]
+    start_mode = "debug/open"
+  else
+    start_mode = "debug/run"
+  end
+
+  ::DEBUGGER__.config_to_env(config)
+  exec("#{RbConfig.ruby}", "-I#{File.expand_path(File.dirname(__dir__))}/lib", "-r" + start_mode, *ARGV)
+
+when :attach
+  require_relative "../lib/debug/client"
+
+  begin
+    if ARGV.empty? && config[:port]
+      connect [config[:host], config[:port]].compact
+    else
+      connect ARGV
+    end
+  rescue DEBUGGER__::CommandLineOptionError
+    puts opt.help
+  end
+else
+  raise # assert
+end

data/ext/debug/debug.c

@@ -0,0 +1,118 @@
+
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+#include "ruby/encoding.h"
+
+//
+static VALUE rb_mDebugger;
+
+// iseq
+typedef struct rb_iseq_struct rb_iseq_t;
+VALUE rb_iseq_realpath(const rb_iseq_t *iseq);
+
+static VALUE
+iseq_realpath(VALUE iseqw)
+{
+    rb_iseq_t *iseq = DATA_PTR(iseqw);
+    return rb_iseq_realpath(iseq);
+}
+
+static VALUE rb_cFrameInfo;
+
+static VALUE
+di_entry(VALUE loc, VALUE self, VALUE binding, VALUE iseq, VALUE klass, VALUE depth)
+{
+    return rb_struct_new(rb_cFrameInfo, loc, self, binding, iseq, klass, depth, Qnil, Qnil, Qnil);
+}
+
+static int
+str_start_with(VALUE str, VALUE prefix)
+{
+    StringValue(prefix);
+    rb_enc_check(str, prefix);
+    if (RSTRING_LEN(str) >= RSTRING_LEN(prefix) &&
+        memcmp(RSTRING_PTR(str), RSTRING_PTR(prefix), RSTRING_LEN(prefix)) == 0) {
+        return 1;
+    }
+    else {
+        return 0;
+    }
+}
+
+static VALUE
+di_body(const rb_debug_inspector_t *dc, void *ptr)
+{
+    VALUE skip_path_prefix = (VALUE)ptr;
+    VALUE locs = rb_debug_inspector_backtrace_locations(dc);
+    VALUE ary = rb_ary_new();
+    long len = RARRAY_LEN(locs);
+    long i;
+
+    for (i=1; i<len; i++) {
+        VALUE iseq = rb_debug_inspector_frame_iseq_get(dc, i);
+
+        if (!NIL_P(iseq)) {
+            VALUE path = iseq_realpath(iseq);
+            if (!NIL_P(path) && str_start_with(path, skip_path_prefix)) continue;
+        }
+
+        VALUE loc = RARRAY_AREF(locs, i);
+        VALUE e = di_entry(loc,
+                           rb_debug_inspector_frame_self_get(dc, i),
+                           rb_debug_inspector_frame_binding_get(dc, i),
+                           iseq,
+                           rb_debug_inspector_frame_class_get(dc, i),
+                           INT2FIX(len - i));
+        rb_ary_push(ary, e);
+    }
+
+    return ary;
+}
+
+static VALUE
+capture_frames(VALUE self, VALUE skip_path_prefix)
+{
+    return rb_debug_inspector_open(di_body, (void *)skip_path_prefix);
+}
+
+static VALUE
+frame_depth(VALUE self)
+{
+    // TODO: more efficient API
+    VALUE bt = rb_make_backtrace();
+    return INT2FIX(RARRAY_LEN(bt));
+}
+
+static void
+method_added_tracker(VALUE tpval, void *ptr)
+{
+    rb_trace_arg_t *arg = rb_tracearg_from_tracepoint(tpval);
+    VALUE mid = rb_tracearg_callee_id(arg);
+
+    if (RB_UNLIKELY(mid == ID2SYM(rb_intern("method_added")) ||
+                    mid == ID2SYM(rb_intern("singleton_method_method_added")))) {
+        VALUE args[] = {
+            tpval,
+        };
+        rb_funcallv(rb_mDebugger, rb_intern("method_added"), 1, args);
+    }
+}
+
+static VALUE
+create_method_added_tracker(VALUE self)
+{
+    return rb_tracepoint_new(0, RUBY_EVENT_CALL, method_added_tracker, NULL);
+}
+
+void Init_iseq_collector(void);
+
+void
+Init_debug(void)
+{
+    rb_mDebugger = rb_const_get(rb_cObject, rb_intern("DEBUGGER__"));
+    rb_cFrameInfo = rb_const_get(rb_mDebugger, rb_intern("FrameInfo"));
+    rb_define_singleton_method(rb_mDebugger, "capture_frames", capture_frames, 1);
+    rb_define_singleton_method(rb_mDebugger, "frame_depth", frame_depth, 0);
+    rb_define_singleton_method(rb_mDebugger, "create_method_added_tracker", create_method_added_tracker, 0);
+    Init_iseq_collector();
+}

data/ext/debug/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile 'debug'

data/ext/debug/iseq_collector.c

@@ -0,0 +1,91 @@
+#include <ruby/ruby.h>
+
+VALUE rb_iseqw_new(VALUE v);
+void rb_objspace_each_objects(
+    int (*callback)(void *start, void *end, size_t stride, void *data),
+    void *data);
+size_t rb_obj_memsize_of(VALUE);
+
+// implementation specific.
+enum imemo_type {
+    imemo_iseq = 7,
+    imemo_mask = 0x07
+};
+
+static inline enum imemo_type
+imemo_type(VALUE imemo)
+{
+    return (RBASIC(imemo)->flags >> FL_USHIFT) & imemo_mask;
+}
+
+static inline int
+rb_obj_is_iseq(VALUE iseq)
+{
+    return RB_TYPE_P(iseq, T_IMEMO) && imemo_type(iseq) == imemo_iseq;
+}
+
+struct iseq_i_data {
+    void (*func)(VALUE v, void *data);
+    void *data;
+};
+
+int
+iseq_i(void *vstart, void *vend, size_t stride, void *ptr)
+{
+    VALUE v;
+    struct iseq_i_data *data = (struct iseq_i_data *)ptr;
+
+    for (v = (VALUE)vstart; v != (VALUE)vend; v += stride) {
+	if (RBASIC(v)->flags) {
+	    switch (BUILTIN_TYPE(v)) {
+	      case T_IMEMO:
+		if (rb_obj_is_iseq(v)) {
+		    data->func(v, data->data);
+		}
+		continue;
+	      default:
+		continue;
+	    }
+	}
+    }
+
+    return 0;
+}
+
+static void
+each_iseq_i(VALUE v, void *ptr)
+{
+    rb_yield(rb_iseqw_new(v));
+}
+
+static VALUE
+each_iseq(VALUE self)
+{
+    struct iseq_i_data data = {each_iseq_i, NULL};
+    rb_objspace_each_objects(iseq_i, &data);
+    return Qnil;
+}
+
+static void
+count_iseq_i(VALUE v, void *ptr)
+{
+    size_t *sizep = (size_t *)ptr;
+    *sizep += 1;
+}
+
+static VALUE
+count_iseq(VALUE self)
+{
+    size_t size = 0;
+    struct iseq_i_data data = {count_iseq_i, &size};
+    rb_objspace_each_objects(iseq_i, &data);
+    return SIZET2NUM(size);
+}
+
+void
+Init_iseq_collector(void)
+{
+    VALUE rb_mObjSpace = rb_const_get(rb_cObject, rb_intern("ObjectSpace"));
+    rb_define_singleton_method(rb_mObjSpace, "each_iseq", each_iseq, 0);
+    rb_define_singleton_method(rb_mObjSpace, "count_iseq", count_iseq, 0);
+}

data/lib/debug.rb

@@ -1 +1 @@
-require_relative 'debug/repl'
+require_relative 'debug/run'

data/lib/debug/breakpoint.rb

@@ -1,17 +1,12 @@
 module DEBUGGER__
-  class LineBreakpoint
-    attr_reader :path, :line, :key
+  class Breakpoint
+    attr_reader :key
+
+    def initialize do_enable = true
+      @deleted = false
 
-    def initialize type, iseq, line, cond = nil, oneshot: false
-      @iseq = iseq
-      @path = iseq.path
-      @line = line
-      @type = type
-      @cond = cond
-      @oneshot = oneshot
-      @key = [@path, @line].freeze
       setup
-      enable
+      enable if do_enable
     end
 
     def safe_eval b, expr
@@ -20,46 +15,178 @@ module DEBUGGER__
       puts "[EVAL ERROR]"
       puts "  expr: #{expr}"
       puts "  err: #{e} (#{e.class})"
+      puts "Error caused by #{self}."
       nil
     end
 
     def setup
+      raise "not implemented..."
+    end
+
+    def enable
+      @tp.enable
+    end
+
+    def disable
+      @tp.disable
+    end
+
+    def enabled?
+      @tp.enabled?
+    end
+
+    def delete
+      disable
+      @deleted = true
+    end
+
+    def deleted?
+      @deleted
+    end
+
+    def suspend
+      ThreadClient.current.on_breakpoint @tp, self
+    end
+
+    def to_s
+      if @cond
+        " if #{@cond}"
+      else
+        ""
+      end
+    end
+  end
+
+  class LineBreakpoint < Breakpoint
+    attr_reader :path, :line, :iseq
+
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true
+      @path = path
+      @line = line
+      @cond = cond
+      @oneshot = oneshot
+      @hook_call = hook_call
+
+      @iseq = nil
+      @type = nil
+
+      @key = [@path, @line].freeze
+
+      super()
+      try_activate
+    end
+
+    def setup
+      return unless @type
+
       if !@cond
         @tp = TracePoint.new(@type) do |tp|
-          tp.disable if @oneshot
-          ThreadClient.current.on_breakpoint tp
+          delete if @oneshot
+          suspend
         end
       else
         @tp = TracePoint.new(@type) do |tp|
           next unless safe_eval tp.binding, @cond
-          tp.disable if @oneshot
-          ThreadClient.current.on_breakpoint tp
+          delete if @oneshot
+          suspend
         end
       end
     end
 
     def enable
+      return unless @iseq
+
       if @type == :line
         @tp.enable(target: @iseq, target_line: @line)
       else
         @tp.enable(target: @iseq)
       end
+
     rescue ArgumentError
       puts @iseq.disasm # for debug
       raise
     end
 
-    def disable
-      @tp.disable
+    def activate iseq, event, line
+      @iseq = iseq
+      @type = event
+      @line = line
+      @path = iseq.absolute_path
+
+      @key = [@path, @line].freeze
+      SESSION.rehash_bps
+
+      setup
+      enable
     end
 
-    def to_s
-      "line bp #{@iseq.absolute_path}:#{@line} (#{@type})" +
-        if @cond
-          "if #{@cond}"
-        else
-          ""
+    def activate_exact iseq, events, line
+      case
+      when events.include?(:RUBY_EVENT_CALL)
+        # "def foo" line set bp on the beggining of method foo
+        activate(iseq, :call, line)
+      when events.include?(:RUBY_EVENT_LINE)
+        activate(iseq, :line, line)
+      when events.include?(:RUBY_EVENT_RETURN)
+        activate(iseq, :return, line)
+      when events.include?(:RUBY_EVENT_B_RETURN)
+        activate(iseq, :b_return, line)
+      when events.include?(:RUBY_EVENT_END)
+        activate(iseq, :end, line)
+      else
+        # not actiavated
+      end
+    end
+
+    NearestISeq = Struct.new(:iseq, :line, :events)
+
+    def try_activate
+      nearest = nil # NearestISeq
+
+      ObjectSpace.each_iseq{|iseq|
+        if (iseq.absolute_path || iseq.path) == self.path && iseq.first_lineno <= self.line
+          iseq.traceable_lines_norec(line_events = {})
+          lines = line_events.keys.sort
+
+          if !lines.empty? && lines.last >= line
+            nline = lines.bsearch{|l| line <= l}
+            events = line_events[nline]
+
+            next if events == [:RUBY_EVENT_B_CALL]
+
+            if @hook_call &&
+               events.include?(:RUBY_EVENT_CALL) &&
+               self.line == iseq.first_lineno
+              nline = iseq.first_lineno
+            end
+
+            if !nearest || ((line - nline).abs < (line - nearest.line).abs)
+              nearest = NearestISeq.new(iseq, nline, events)
+            else
+              if @hook_call && nearest.iseq.first_lineno <= iseq.first_lineno
+                if (nearest.line > line && !nearest.events.include?(:RUBY_EVENT_CALL)) ||
+                   (events.include?(:RUBY_EVENT_CALL))
+                  nearest = NearestISeq.new(iseq, nline, events)
+                end
+              end
+            end
+          end
         end
+      }
+
+      if nearest
+        activate_exact nearest.iseq, nearest.events, nearest.line
+      end
+    end
+
+    def to_s
+      oneshot = @oneshot ? " (oneshot)" : ""
+
+      if @iseq
+        "line bp #{@path}:#{@line} (#{@type})#{oneshot}" + super
+      else
+        "line bp (pending) #{@path}:#{@line}#{oneshot}" + super
+      end
     end
 
     def inspect
@@ -67,31 +194,178 @@ module DEBUGGER__
     end
   end
 
-  class CatchBreakpoint
-    attr_reader :key
-
+  class CatchBreakpoint < Breakpoint
     def initialize pat
-      @pat = pat
+      @pat = pat.freeze
+      @key = [:catch, @pat].freeze
+
+      super()
+    end
+
+    def setup
       @tp = TracePoint.new(:raise){|tp|
         exc = tp.raised_exception
         exc.class.ancestors.each{|cls|
-          if pat === cls.name
-            puts "catch #{exc.class.inspect} by #{@pat.inspect}"
-            ThreadClient.current.on_suspend :catch
-          end
+          suspend if pat === cls.name
         }
       }
-      @tp.enable
+    end
 
-      @key = pat.freeze
+    def to_s
+      "catch bp #{@pat.inspect}"
     end
+  end
 
-    def disable
-      @tp.disable
+  class CheckBreakpoint < Breakpoint
+    def initialize expr
+      @expr = expr.freeze
+      @key = [:check, @expr].freeze
+
+      super()
+    end
+
+    def setup
+      @tp = TracePoint.new(:line){|tp|
+        next if tp.path.start_with? __dir__
+        next if tp.path.start_with? '<internal:'
+
+        if safe_eval tp.binding, @expr
+          suspend
+        end
+      }
     end
 
     def to_s
-      "catch bp #{@pat.inspect}"
+      "check bp: #{@expr}"
+    end
+  end
+
+  class WatchExprBreakpoint < Breakpoint
+    def initialize expr, current
+      @expr = expr.freeze
+      @key = [:watch, @expr].freeze
+
+      @current = current
+      super()
+    end
+
+    def watch_eval b
+      result = b.eval(@expr)
+      if result != @current
+        begin
+          @prev = @current
+          @current = result
+          suspend
+        ensure
+          remove_instance_variable(:@prev)
+        end
+      end
+    rescue Exception => e
+      false
+    end
+
+    def setup
+      @tp = TracePoint.new(:line, :return, :b_return){|tp|
+        next if tp.path.start_with? __dir__
+        next if tp.path.start_with? '<internal:'
+
+        watch_eval(tp.binding)
+      }
+    end
+
+    def to_s
+      if defined? @prev
+        "watch bp: #{@expr} = #{@prev} -> #{@current}"
+      else
+        "watch bp: #{@expr} = #{@current}"
+      end
+    end
+  end
+
+  class MethodBreakpoint < Breakpoint
+    attr_reader :sig_method_name, :method
+
+    def initialize b, klass_name, op, method_name, cond
+      @sig_klass_name = klass_name
+      @sig_op = op
+      @sig_method_name = method_name
+      @klass_eval_binding = b
+
+      @klass = nil
+      @method = nil
+      @cond = cond
+      @key = "#{klass_name}#{op}#{method_name}".freeze
+
+      super(false)
+    end
+
+    def setup
+      if @cond
+        @tp = TracePoint.new(:call){|tp|
+          next unless safe_eval tp.binding, @cond
+          suspend
+        }
+      else
+        @tp = TracePoint.new(:call){|tp|
+          suspend
+        }
+      end
+    end
+
+    def eval_class_name
+      return @klass if @klass
+      @klass = @klass_eval_binding.eval(@sig_klass_name)
+      @klass_eval_binding = nil
+      @klass
+    end
+
+    def search_method
+      case @sig_op
+      when '.'
+        @method = @klass.method(@sig_method_name)
+      when '#'
+        @method = @klass.instance_method(@sig_method_name)
+      else
+        raise "Unknown op: #{@sig_op}"
+      end
+    end
+
+    def enable quiet: false
+      eval_class_name
+      search_method
+
+      begin
+        retried = false
+        @tp.enable(target: @method)
+
+      rescue ArgumentError => e
+        raise if retried
+        retried = true
+
+        # maybe C method
+        @klass.module_eval do
+          orig_name = @sig_method_name + '__orig__'
+          alias_method orig_name, @sig_method_name
+          define_method(@sig_method_name) do |*args|
+            send(orig_name, *args)
+          end
+        end
+        retry
+      end
+    rescue Exception
+      raise unless quiet
+    end
+
+    def sig
+      @key
+    end
+
+    def to_s
+      if @method
+        "method bp: #{sig}"
+      else
+        "method bp (pending): #{sig}"
+      end + super
     end
   end
 end