rbx-trepanning 0.0.5-universal-rubinius-1.2.1

data/processor/command/break.rb

@@ -0,0 +1,100 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::SetBreakpointCommand < Trepan::Command
+
+  ALIASES      = %w(b brk)
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  HELP         = <<-HELP
+#{NAME} 
+#{NAME} [line number|offset]
+#{NAME} Class[.#]method[:line-or-offset]
+
+Sets a breakpoint. In the first form, a breakpoint is set at the
+current line you are stopped at. In the second form, you give a line
+number or an offset.  An offset is a number that is prefaced with 'O'
+or 'o' and represents a Rubinius VM PC offset. 
+
+The current method name is used for the start of the search. If a line
+number is given and the line number is not found in that method,
+enclosing scopes are searched for the line.
+
+The last form is the most explicit. Use '#' to specify an instance
+method and '.' to specify a class method. If a line number or offset
+is omitted, we use the first line of the method.
+
+Examples:
+
+  #{NAME}     # set breakpoint at the current line
+  #{NAME} 5   # set breakpoint on line 5
+  #{NAME} O5  # set breakpoint at offset 5
+  #{NAME} o5  # same as above
+  #{NAME} Array#pop::3 # Set break at instance method 'pop' in Array, line 3
+  #{NAME} Trepan.start:3  # Set break in class method 'start' of Trepan, line 3
+  #{NAME} Trepan.start:o3 # Same as above but at offset 3, not line 3.
+  #{NAME} Trepan.start    # Set break in class method 'start' of Trepan
+
+See also 'tbreak', 'info breakpoint', and 'delete'. 
+      HELP
+  SHORT_HELP   = 'Set a breakpoint at a point in a method'
+
+  def run(args, temp=false)
+    arg_str = args[1..-1].join(' ')
+
+    describe, klass_name, which, name, line, ip = 
+      @proc.breakpoint_position(args[1..-1])
+    event = temp ? 'tbrkpt' : 'brkpt'
+    opts={:event => event, :temp => temp}      
+    if name.kind_of?(Rubinius::CompiledMethod)
+      bp = @proc.set_breakpoint_method(describe, name, line, ip, opts)
+    else
+      return unless klass_name
+    
+      begin
+        klass = @proc.debug_eval(klass_name, settings[:maxstring])
+      rescue NameError
+        errmsg "Unable to find class/module: #{klass_name}"
+        ask_deferred klass_name, which, name, line
+        return
+      end
+      
+      begin
+        if which == "#"
+          method = klass.instance_method(name)
+        else
+          method = klass.method(name)
+        end
+      rescue NameError
+        errmsg "Unable to find method '#{name}' in #{klass}"
+        ask_deferred klass_name, which, name, line
+        return
+      end
+
+      bp = @proc.set_breakpoint_method(arg_str.strip, method, line, ip, opts)
+    end
+      
+    bp.set_temp! if temp
+    return bp
+  end
+  
+  def ask_deferred(klass_name, which, name, line)
+    if confirm('Would you like to defer this breakpoint to later?', false)
+      @proc.dbgr.add_deferred_breakpoint(klass_name, which, name, line)
+      msg 'Deferred breakpoint created.'
+    else
+      msg 'Not confirmed.'
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  # require 'trepanning'
+  # Trepan.start(:set_restart => true)
+  cmd.run([cmd.name, __LINE__.to_s])
+  cmd.run([cmd.name, 'foo'])
+end

data/processor/command/complete.rb

@@ -0,0 +1,37 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../load_cmds'
+class Trepan::Command::CompleteCommand < Trepan::Command
+
+  unless defined?(HELP)
+    NAME          = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} COMMAND-PREFIX
+
+List the completions for the rest of the line as a command.
+    HELP
+    CATEGORY      = 'support'
+    NEED_STACK    = false
+    SHORT_HELP    = 'List the completions for the rest of the line as a command'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    @proc.complete(args[1..-1]).each do |match|
+      msg match
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  %w(d b bt).each do |prefix|
+    cmd.run [cmd.name, prefix]
+    puts '=' * 40
+  end
+  cmd.run %w(#{cmd.name} fdafsasfda)
+  puts '=' * 40
+end

data/processor/command/continue.rb

@@ -0,0 +1,91 @@
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+require_relative '../stepping'
+
+class Trepan::Command::ContinueCommand < Trepan::Command
+  unless defined?(HELP)
+    NAME = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [breakpoint-position]
+
+Leave the debugger loop and continue execution. Subsequent entry to
+the debugger however may occur via breakpoints or explicit calls, or
+exceptions.
+
+If a parameter is given, a temporary breakpoint is set at that position
+before continuing. Offset are numbers prefixed with an "O" otherwise
+the parameter is taken as a line number.
+
+Examples:
+   #{NAME}
+   #{NAME} 10    # continue to line 10
+   #{NAME} o20   # continue to VM Instruction Sequence offset 20
+   #{NAME} gcd   # continue to first instruction of method gcd
+   #{NAME} IRB.start o7 # continue to IRB.start offset 7
+
+See also 'step', 'next', 'finish', and 'nexti' commands.
+    HELP
+
+    ALIASES      = %w(c cont)
+    CATEGORY     = 'running'
+    MAX_ARGS     = 2  # Need at most this many
+    NEED_RUNNING = true
+    SHORT_HELP   = 'Continue execution of the debugged program'
+  end
+
+  # This is the method that runs the command
+  def run(args)
+
+    ## FIXME: DRY this code, tbreak and break.
+    unless args.size == 1
+      describe, klass_name, which, name, line, ip = 
+        @proc.breakpoint_position(args[1..-1])
+      unless describe
+        errmsg "Can't parse temporary breakpoint location"
+        return 
+      end
+      if name.kind_of?(Rubinius::CompiledMethod)
+        bp = @proc.set_breakpoint_method(describe, name, line, ip,
+                                         {:temp=>true, :event =>'tbrkpt'})
+        unless bp
+          errmsg "Trouble setting temporary breakpoint"
+          return 
+        end
+      else
+        return unless klass_name
+        begin
+          klass = @proc.debug_eval(klass_name, settings[:maxstring])
+        rescue NameError
+          errmsg "Unable to find class/module: #{klass_name}"
+          return
+        end
+        
+        begin
+          if which == "#"
+            method = klass.instance_method(name)
+          else
+            method = klass.method(name)
+          end
+        rescue NameError
+          errmsg "Unable to find method '#{name}' in #{klass}"
+          return
+        end
+        arg_str = args[1..-1].join(' ')
+        bp = @proc.set_breakpoint_method(arg_str.strip, method, line, nil,
+                                         {:temp=>true, :event =>'tbrkpt'})
+        unless bp
+          errmsg "Trouble setting temporary breakpoint"
+          return 
+        end
+      end
+    end
+    @proc.continue('continue')
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  p cmd.run([cmd.name])
+end

data/processor/command/delete.rb

@@ -0,0 +1,30 @@
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+
+class Trepan::Command::DeleteBreakpontCommand < Trepan::Command
+  CATEGORY     = 'breakpoints'
+  NAME         = File.basename(__FILE__, '.rb')
+  SHORT_HELP   = 'Delete a breakpoint'
+  HELP         = <<-HELP
+Specify the breakpoint by number, use 'info break' to see the numbers
+      HELP
+
+  def run(args)
+    if args.size != 2
+      errmsg 'Please specify which breakpoint by number'
+      return
+    end
+    
+    begin
+      i = Integer(args[1])
+    rescue ArgumentError
+      errmsg "'#{args}' is not a number"
+      return
+    end
+    
+    if @proc.delete_breakpoint_by_number(i)
+      msg('Deleted breakpoint %d.' % i)
+    end
+  end
+end
+

data/processor/command/directory.rb

@@ -0,0 +1,51 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative 'base/cmd'
+class Trepan::Command::DirectoryCommand < Trepan::Command
+
+  unless defined?(HELP)
+    ALIASES      = %w(dir)
+    CATEGORY     = 'files'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    HELP = <<-HELP
+#{NAME} [DIR]
+
+Add directory DIR to beginning of search path for source files.
+DIR can also be $cwd for the current working directory, or $cdir for the
+directory in which the debugged file start.
+With no argument, reset the search path to $cdir:$cwd, the default.
+
+This command may be useful for debugging into Rubinius methods such as
+kernel/common/module.rb if have the source code somewhere.
+
+Examples:
+   #{NAME} ~/.rvm/src/rbx-head  # Adds an rvm-like directory to path
+   #{NAME} # reset to $cdir:$cwd
+      HELP
+
+    SHORT_HELP  = 
+      'Add directory DIR to beginning of search path for source files'
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size > 1
+      path = File.expand_path(args[1])
+      settings[:directory] = "#{path}:#{settings[:directory]}"
+      msg "Source directories searched: #{settings[:directory]}"
+    else
+      if confirm('Reintialize source path to empty?', false)
+        settings[:directory] = '$cdir:$cwd'
+        msg 'Source directories searched: $cdir:$cwd'
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  cmd.run([cmd.name])
+  cmd.run([cmd.name, '/tmp'])
+end

data/processor/command/disassemble.rb

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2011 Rocky Bernstein <rockyb@rubyforge.net>
+require 'rubygems'; require 'require_relative'
+require_relative './base/cmd'
+require_relative '../../app/method'
+require_relative '../../app/iseq'
+
+class Trepan::Command::DisassembleCommand < Trepan::Command
+
+  include Trepanning::Method
+
+  NAME         = File.basename(__FILE__, '.rb')
+  ALIASES       = %w(disas disassem) # Note we (will) have disable
+  CATEGORY     = 'data'
+  HELP         = <<-HELP
+#{NAME} [all]
+#{NAME} [method|LINE-NUM]...
+
+Disassembles Rubinius VM instructions. By default, the bytecode for the
+current line is disassembled only.
+
+If a method name is given, disassemble just that method. 
+
+If a line number given, then disassemble just that line number if it
+has bytecode assocated with that line. Note that if a line has
+discontinuous regions we will show just the first region associated
+with that line.
+
+If the argument is 'all', the entire method is shown as bytecode.
+
+Examples:
+   #{NAME}              # dissasemble VM for current line
+   #{NAME} all          # disassemble entire current method
+   #{NAME} [1,2].max    # disassemble max method of Array
+   #{NAME} Object.is_a? # disassemble Object.is_a?
+   #{NAME} is_a?        # same as above (probably)
+   #{NAME} 6            # Disassemble line 6 if there is bytecode for it
+   #{NAME} 6 is_a?      # The above two commands combined into one
+    HELP
+
+  NEED_STACK   = true
+  SHORT_HELP   = 'Show the bytecode for the current method'
+
+  def disassemble_method(cm)
+    frame_ip = (@proc.frame.method == cm) ? @proc.frame.next_ip : nil
+    lines = cm.lines
+    next_line_ip = 0
+    next_i = 1
+    prefixes = []
+    disasm = ''
+    cm.decode.each do |insn|
+      show_line = 
+        if insn.ip >= next_line_ip
+          next_line_ip = lines.at(next_i+1)
+          line_no = lines.at(next_i)
+          next_i += 2
+          true
+        else
+          false
+        end
+          
+      prefixes << Trepan::ISeq::disasm_prefix(insn.ip, frame_ip, cm)
+      str = insn.to_s
+      if show_line
+        str += 
+          if insn.instance_variable_get('@comment')
+            ' '
+          elsif str[-1..-1] !~/\s/
+            '    '
+          else
+            ''
+          end
+        str += "# line: #{line_no}"  
+      end
+      disasm += "#{str}\n"
+    end
+
+    # FIXME DRY with ../disassemble.rb
+    if settings[:highlight]
+      require_relative '../../app/rbx-llvm'
+      @llvm_highlighter ||= CodeRay::Duo[:llvm, :term]
+      # llvm_scanner = CodeRay.scanner :llvm
+      # p llvm_scanner.tokenize(disasm)
+      disasm = @llvm_highlighter.encode(disasm)
+    end
+      
+    disasm.split("\n").each_with_index do |inst, i|
+      msg ("#{prefixes[i]} #{inst}", :unlimited => true)
+    end
+  end
+
+  # Run command. 
+  def run(args)
+    if 1 == args.size
+      @proc.show_bytecode
+    elsif 'all' == args[1]
+      section "Bytecode for #{@proc.frame.vm_location.describe}"
+      disassemble_method(current_method)
+    else
+      args[1..-1].each do |arg|
+        cm = @proc.parse_method(arg)
+        if cm
+          section "Bytecode for method #{arg}"
+          disassemble_method(cm.executable)
+        else
+          opts = {:msg_on_error => false }
+          line_num = @proc.get_an_int(arg, opts) 
+          if line_num
+            cm = find_method_with_line(current_method, line_num)
+            if cm
+              @proc.show_bytecode(line_num)
+            else
+              errmsg "Can't find that bytecode for line #{line_num}"
+            end
+          else
+            errmsg "Method #{arg} not found"
+          end
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../mock'
+  dbgr, cmd = MockDebugger::setup
+  def foo(cmd)
+    puts "#{cmd.name}"
+    cmd.run([cmd.name])
+    puts '=' * 40
+    puts "#{cmd.name} all"
+    cmd.run([cmd.name, 'all'])
+    puts '=' * 40
+    p cmd.proc.frame.vm_location.describe
+    cmd.run([cmd.name, 'foo'])
+    puts '=' * 40
+    # require_relative '../../lib/trepanning'
+    # debugger
+    cmd.run([cmd.name, 'self.setup'])
+    puts '=' * 40
+    cmd.run([cmd.name, __LINE__.to_s])
+  end
+  foo(cmd)
+end