debug 1.3.4 → 1.6.0

data/exe/rdbg

@@ -3,7 +3,9 @@
 require_relative '../lib/debug/config'
 config = DEBUGGER__::Config::parse_argv(ARGV)
 
-case config[:mode]
+# mode is not an actual configuration option
+# it's only used to carry the result of parse_argv here
+case config.delete(:mode)
 when :start
   require 'rbconfig'
 
@@ -12,13 +14,15 @@ when :start
   cmd = config[:command] ? ARGV.shift : (ENV['RUBY'] || RbConfig.ruby)
 
   env = ::DEBUGGER__::Config.config_to_env_hash(config)
-  env['RUBYOPT'] = "-r #{libpath}/#{start_mode}"
+  rubyopt = env['RUBYOPT']
+  env['RUBY_DEBUG_ADDED_RUBYOPT'] = added = "-r #{libpath}/#{start_mode}"
+  env['RUBYOPT'] = "#{added} #{rubyopt}"
 
   exec(env, cmd, *ARGV)
 
 when :attach
   require_relative "../lib/debug/client"
-  ::DEBUGGER__::CONFIG.update config
+  ::DEBUGGER__::CONFIG.set_config **config
 
   begin
     if ARGV.empty? && config[:port]

data/ext/debug/debug.c

@@ -32,7 +32,10 @@ di_entry(VALUE loc, VALUE self, VALUE binding, VALUE iseq, VALUE klass, VALUE de
                          // :show_line, :local_variables
                          Qnil,
                          // :_local_variables, :_callee # for recorder
-                         Qnil, Qnil);
+                         Qnil, Qnil,
+                         // :dupped_binding
+                         Qnil
+                         );
 }
 
 static int
@@ -94,32 +97,82 @@ frame_depth(VALUE self)
     return INT2FIX(RARRAY_LEN(bt));
 }
 
-static void
-method_added_tracker(VALUE tpval, void *ptr)
+// iseq
+
+const struct rb_iseq *rb_iseqw_to_iseq(VALUE iseqw);
+
+#ifdef HAVE_RB_ISEQ_TYPE
+VALUE rb_iseq_type(const struct rb_iseq *);
+
+static VALUE
+iseq_type(VALUE iseqw)
 {
-    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_added")))) {
-        VALUE args[] = {
-            tpval,
-        };
-        rb_funcallv(rb_mDebugger, rb_intern("method_added"), 1, args);
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    return rb_iseq_type(iseq);
+}
+#endif
+
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+VALUE rb_iseq_parameters(const struct rb_iseq *, int is_proc);
+
+static VALUE
+iseq_parameters_symbols(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    VALUE params = rb_iseq_parameters(iseq, 0);
+    VALUE ary = rb_ary_new();
+
+    static VALUE sym_ast, sym_astast, sym_amp;
+
+    if (sym_ast == 0) {
+        sym_ast = ID2SYM(rb_intern("*"));
+        sym_astast = ID2SYM(rb_intern("**"));
+        sym_amp = ID2SYM(rb_intern("&"));
+    }
+
+    for (long i=0; i<RARRAY_LEN(params); i++) {
+        VALUE e = RARRAY_AREF(params, i);
+        if (RARRAY_LEN(e) == 2) {
+            VALUE sym = RARRAY_AREF(e, 1);
+            if (sym != sym_ast &&
+                sym != sym_astast &&
+                sym != sym_amp) rb_ary_push(ary, RARRAY_AREF(e, 1));
+        }
     }
+
+    return ary;
 }
+#endif
+
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+void rb_iseq_code_location(const struct rb_iseq *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);
 
 static VALUE
-create_method_added_tracker(VALUE self)
+iseq_first_line(VALUE iseqw)
 {
-    return rb_tracepoint_new(0, RUBY_EVENT_CALL, method_added_tracker, NULL);
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, &line, NULL, NULL, NULL);
+    return INT2NUM(line);
 }
 
+static VALUE
+iseq_last_line(VALUE iseqw)
+{
+    const struct rb_iseq *iseq = rb_iseqw_to_iseq(iseqw);
+    int line;
+    rb_iseq_code_location(iseq, NULL, NULL, &line, NULL);
+    return INT2NUM(line);
+}
+#endif
+
 void Init_iseq_collector(void);
 
 void
 Init_debug(void)
 {
+    VALUE rb_mRubyVM = rb_const_get(rb_cObject, rb_intern("RubyVM"));
+    VALUE rb_cISeq = rb_const_get(rb_mRubyVM, rb_intern("InstructionSequence"));
     rb_mDebugger = rb_const_get(rb_cObject, rb_intern("DEBUGGER__"));
     rb_cFrameInfo = rb_const_get(rb_mDebugger, rb_intern("FrameInfo"));
 
@@ -129,7 +182,19 @@ Init_debug(void)
     rb_gc_register_mark_object(rb_cFrameInfo);
     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);
     rb_define_const(rb_mDebugger, "SO_VERSION", rb_str_new2(RUBY_DEBUG_VERSION));
+
+    // iseq
+#ifdef HAVE_RB_ISEQ_TYPE
+    rb_define_method(rb_cISeq, "type", iseq_type, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_PARAMETERS
+    rb_define_method(rb_cISeq, "parameters_symbols", iseq_parameters_symbols, 0);
+#endif
+#ifdef HAVE_RB_ISEQ_CODE_LOCATION
+    rb_define_method(rb_cISeq, "first_line", iseq_first_line, 0);
+    rb_define_method(rb_cISeq, "last_line", iseq_last_line, 0);
+#endif
+
     Init_iseq_collector();
 }

data/ext/debug/extconf.rb

@@ -1,4 +1,26 @@
 require 'mkmf'
 require_relative '../../lib/debug/version'
 File.write("debug_version.h", "#define RUBY_DEBUG_VERSION \"#{DEBUGGER__::VERSION}\"\n")
+
+
+if defined? RubyVM
+  $defs << '-DHAVE_RB_ISEQ_PARAMETERS'
+  $defs << '-DHAVE_RB_ISEQ_CODE_LOCATION'
+
+  if RUBY_VERSION >= '3.1.0'
+    $defs << '-DHAVE_RB_ISEQ_TYPE'
+  end
+else
+  # not on MRI
+
+  have_func "rb_iseq_parameters(NULL, 0)",
+             [["VALUE rb_iseq_parameters(void *, int is_proc);"]]
+
+  have_func "rb_iseq_code_location(NULL, NULL, NULL, NULL, NULL)",
+            [["void rb_iseq_code_location(void *, int *first_lineno, int *first_column, int *last_lineno, int *last_column);"]]
+  # from Ruby 3.1
+  have_func "rb_iseq_type(NULL)",
+            [["VALUE rb_iseq_type(void *);"]]
+end
+
 create_makefile 'debug/debug'

data/lib/debug/breakpoint.rb

@@ -4,11 +4,17 @@ require_relative 'color'
 
 module DEBUGGER__
   class Breakpoint
+    include SkipPathHelper
+
     attr_reader :key
 
-    def initialize do_enable = true
+    def initialize cond, command, path, do_enable: true
       @deleted = false
 
+      @cond = cond
+      @command = command
+      @path = path
+
       setup
       enable if do_enable
     end
@@ -23,6 +29,10 @@ module DEBUGGER__
       nil
     end
 
+    def oneshot?
+      defined?(@oneshot) && @oneshot
+    end
+
     def setup
       raise "not implemented..."
     end
@@ -75,6 +85,17 @@ module DEBUGGER__
       false
     end
 
+    def skip_path?(path)
+      case @path
+      when Regexp
+        !path.match?(@path)
+      when String
+        !path.include?(@path)
+      else
+        super
+      end
+    end
+
     include Color
 
     def generate_label(name)
@@ -87,26 +108,53 @@ module DEBUGGER__
     TracePoint.new(:line){}.enable{}
   end
 
+  class ISeqBreakpoint < Breakpoint
+    def initialize iseq, events, oneshot: false
+      @events = events
+      @iseq = iseq
+      @oneshot = oneshot
+      @key = [:iseq, @iseq.path, @iseq.first_lineno].freeze
+
+      super(nil, nil, nil)
+    end
+
+    def setup
+      @tp = TracePoint.new(*@events) do |tp|
+        delete if @oneshot
+        suspend
+      end
+    end
+
+    def enable
+      @tp.enable(target: @iseq)
+    end
+  end
+
   class LineBreakpoint < Breakpoint
-    attr_reader :path, :line, :iseq
+    attr_reader :path, :line, :iseq, :cond, :oneshot, :hook_call, :command
 
-    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil
-      @path = path
+    def self.copy bp, root_iseq
+      nbp = LineBreakpoint.new bp.path, bp.line,
+                               cond: bp.cond, oneshot: bp.oneshot, hook_call: bp.hook_call,
+                               command: bp.command, skip_activate: true
+      nbp.try_activate root_iseq
+      nbp
+    end
+
+    def initialize path, line, cond: nil, oneshot: false, hook_call: true, command: nil, skip_activate: false
       @line = line
-      @cond = cond
       @oneshot = oneshot
       @hook_call = hook_call
-      @command = command
       @pending = false
 
       @iseq = nil
       @type = nil
 
-      @key = [@path, @line].freeze
+      @key = [path, @line].freeze
 
-      super()
+      super(cond, command, path)
 
-      try_activate
+      try_activate unless skip_activate
       @pending = !@iseq
     end
 
@@ -166,7 +214,7 @@ module DEBUGGER__
       when events.include?(:RUBY_EVENT_END)
         activate(iseq, :end, line)
       else
-        # not actiavated
+        # not activated
       end
     end
 
@@ -176,42 +224,56 @@ module DEBUGGER__
 
     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.type != :ensure # ensure iseq is copied (duplicated)
+    def iterate_iseq root_iseq
+      if root_iseq
+        is = [root_iseq]
+        while iseq = is.pop
+          yield iseq
+          iseq.each_child do |child_iseq|
+            is << child_iseq
+          end
+        end
+      else
+        ObjectSpace.each_iseq do |iseq|
+          if DEBUGGER__.compare_path((iseq.absolute_path || iseq.path), self.path) &&
+             iseq.first_lineno <= self.line &&
+             iseq.type != :ensure # ensure iseq is copied (duplicated)
+            yield iseq
+          end
+        end
+      end
+    end
 
-          iseq.traceable_lines_norec(line_events = {})
-          lines = line_events.keys.sort
+    def try_activate root_iseq = nil
+      nearest = nil # NearestISeq
+      iterate_iseq root_iseq do |iseq|
+        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]
+        if !lines.empty? && lines.last >= line
+          nline = lines.bsearch{|l| line <= l}
+          events = line_events[nline]
 
-            next if events == [:RUBY_EVENT_B_CALL]
+          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 @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
+          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
@@ -235,24 +297,21 @@ module DEBUGGER__
 
   class CatchBreakpoint < Breakpoint
     attr_reader :last_exc
-    include SkipPathHelper
 
-    def initialize pat, cond: nil, command: nil
+    def initialize pat, cond: nil, command: nil, path: nil
       @pat = pat.freeze
       @key = [:catch, @pat].freeze
       @last_exc = nil
 
-      @cond = cond
-      @command = command
-
-      super()
+      super(cond, command, path)
     end
 
     def setup
       @tp = TracePoint.new(:raise){|tp|
-        next if skip_path?(tp.path)
         exc = tp.raised_exception
         next if SystemExit === exc
+        next if skip_path?(tp.path)
+
         next if !safe_eval(tp.binding, @cond) if @cond
         should_suspend = false
 
@@ -277,47 +336,65 @@ module DEBUGGER__
   end
 
   class CheckBreakpoint < Breakpoint
-    def initialize expr
-      @expr = expr.freeze
-      @key = [:check, @expr].freeze
+    def initialize cond:, command: nil, path: nil
+      @key = [:check, cond].freeze
 
-      super()
+      super(cond, command, path)
     end
 
     def setup
       @tp = TracePoint.new(:line){|tp|
-        next if tp.path.start_with? __dir__
-        next if tp.path.start_with? '<internal:'
+        next if SESSION.in_subsession? # TODO: Ractor support
         next if ThreadClient.current.management?
+        next if skip_path?(tp.path)
 
-        if safe_eval tp.binding, @expr
+        if need_suspend? safe_eval(tp.binding, @cond)
           suspend
         end
       }
     end
 
+    private def need_suspend? cond_result
+      map = ThreadClient.current.check_bp_fulfillment_map
+      if cond_result
+        if map[self]
+          false
+        else
+          map[self] = true
+        end
+      else
+        map[self] = false
+      end
+    end
+
     def to_s
-      "#{generate_label("Check")} #{@expr}"
+      s = "#{generate_label("Check")}"
+      s += super
+      s
     end
   end
 
   class WatchIVarBreakpoint < Breakpoint
-    def initialize ivar, object, current
+    def initialize ivar, object, current, cond: nil, command: nil, path: nil
       @ivar = ivar.to_sym
       @object = object
-      @key = [:watch, @ivar].freeze
+      @key = [:watch, object.object_id, @ivar].freeze
 
       @current = current
-      super()
+
+      super(cond, command, path)
     end
 
-    def watch_eval
+    def watch_eval(tp)
       result = @object.instance_variable_get(@ivar)
       if result != @current
         begin
           @prev = @current
           @current = result
-          suspend
+
+          if (@cond.nil? || @object.instance_eval(@cond)) && !skip_path?(tp.path)
+            suspend
+          end
         ensure
           remove_instance_variable(:@prev)
         end
@@ -328,10 +405,7 @@ module DEBUGGER__
 
     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
+        watch_eval(tp)
       }
     end
 
@@ -347,9 +421,9 @@ module DEBUGGER__
   end
 
   class MethodBreakpoint < Breakpoint
-    attr_reader :sig_method_name, :method
+    attr_reader :sig_method_name, :method, :klass
 
-    def initialize b, klass_name, op, method_name, cond: nil, command: nil
+    def initialize b, klass_name, op, method_name, cond: nil, command: nil, path: nil
       @sig_klass_name = klass_name
       @sig_op = op
       @sig_method_name = method_name
@@ -358,19 +432,19 @@ module DEBUGGER__
 
       @klass = nil
       @method = nil
-      @cond = cond
       @cond_class = nil
-      @command = command
       @key = "#{klass_name}#{op}#{method_name}".freeze
 
-      super(false)
+      super(cond, command, path, do_enable: false)
     end
 
     def setup
       @tp = TracePoint.new(:call){|tp|
         next if !safe_eval(tp.binding, @cond) if @cond
         next if @cond_class && !tp.self.kind_of?(@cond_class)
-        next if @override_method ? (caller_locations(2, 1).first.to_s.start_with?(__dir__)) : tp.path.start_with?(__dir__)
+
+        caller_location = caller_locations(2, 1).first.to_s
+        next if skip_path?(caller_location)
 
         suspend
       }

data/lib/debug/client.rb

@@ -18,29 +18,69 @@ module DEBUGGER__
         case name
         when 'gen-sockpath'
           puts DEBUGGER__.create_unix_domain_socket_name
+        when 'gen-portpath'
+          port_path = File.join(DEBUGGER__.unix_domain_socket_dir, 'tcp_port')
+          File.unlink port_path if File.exist?(port_path)
+          puts port_path
         when 'list-socks'
           cleanup_unix_domain_sockets
           puts list_connections
-        when 'init'
-          if ARGV.shift == '-'
-            puts <<~EOS
-            export RUBYOPT="-r #{__dir__}/prelude $(RUBYOPT)"
-            EOS
-          else
-            puts <<~EOS
-            # add the following lines in your .bash_profile
-
-            eval "$(rdbg init -)"
-            EOS
-          end
+        when 'setup-autoload'
+          setup_autoload
+        else
+          abort "Unknown utility: #{name}"
+        end
+      end
+
+      def working_shell_type
+        shell = `ps -p #{Process.ppid} -o 'args='`
+        case shell
+        when /bash/
+          :bash
+        when /fish/
+          :fish
+        when /csh/
+          :csh
+        when /zsh/
+          :szh
+        when /dash/
+          :dash
+        else
+          :unknown
+        end
+      end
+
+      def setup_autoload
+        prelude_path = File.join(__dir__, 'prelude.rb')
+
+        case shell = working_shell_type
+        when :bash, :zsh
+          puts <<~EOS
+          # add the following lines in your ~/.#{shell}_profile
+
+          if test -s #{prelude_path} ; then
+            export RUBYOPT='-r #{prelude_path}'
+          fi
+
+          # Add `Kernel#bb` method which is alias of `Kernel#debugger`
+          # export RUBY_DEBUG_BB=1
+          EOS
+
+        when :fish
+          puts <<~EOS
+          # add the following lines in your ~/.config/fish/config.fish
+          set -x RUBYOPT "-r #{__dir__}/prelude" $RUBYOPT
+          EOS
+
         else
-          raise "Unknown utility: #{name}"
+          puts "# Sorry that your shell is not supported yet.",
+               "# Please use the content in #{prelude_path} as a reference and modify your login script accordingly."
         end
       end
 
       def cleanup_unix_domain_sockets
         Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*') do |file|
-          if /(\d+)$/ =~ file
+          if File.socket?(file) && (/-(\d+)-\d+$/ =~ file || /-(\d+)$/ =~ file)
             begin
               Process.kill(0, $1.to_i)
             rescue Errno::EPERM
@@ -52,7 +92,9 @@ module DEBUGGER__
       end
 
       def list_connections
-        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*')
+        Dir.glob(DEBUGGER__.create_unix_domain_socket_name_prefix + '*').find_all do |path|
+          File.socket?(path)
+        end
       end
     end
 
@@ -79,7 +121,10 @@ module DEBUGGER__
       @width = IO.console_size[1]
       @width = 80 if @width == 0
 
-      send "version: #{VERSION} width: #{@width} cookie: #{CONFIG[:cookie]}"
+      send "version: #{VERSION} " +
+           "width: #{@width} " +
+           "cookie: #{CONFIG[:cookie] || '-'} " +
+           "nonstop: #{CONFIG[:nonstop] ? 'true' : 'false'}"
     end
 
     def deactivate
@@ -131,12 +176,19 @@ module DEBUGGER__
     end
 
     def connect
+      pre_commands = (CONFIG[:commands] || '').split(';;')
+
       trap(:SIGINT){
         send "pause"
       }
-      trap(:SIGWINCH){
-        @width = IO.console_size[1]
-      }
+
+      begin
+        trap(:SIGWINCH){
+          @width = IO.console_size[1]
+        }
+      rescue ArgumentError
+        @width = 80
+      end
 
       while line = @s.gets
         p recv: line if $VERBOSE
@@ -152,7 +204,12 @@ module DEBUGGER__
           prev_trap = trap(:SIGINT, 'DEFAULT')
 
           begin
-            line = readline
+            if pre_commands.empty?
+              line = readline
+            else
+              line = pre_commands.shift
+              puts "(rdbg:remote:command) #{line}"
+            end
           rescue Interrupt
             retry
           ensure