rbx-trepanning 0.2.0-universal-rubinius-2.0

data/app/irb.rb

@@ -0,0 +1,113 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+# This code comes more or less from ruby-debug.
+require 'irb'
+module IRB # :nodoc:
+  module ExtendCommand # :nodoc:
+    # FIXME: should we read these out of a directory to 
+    #        make this more user-customizable? 
+
+    unless defined? Continue
+      # A base command class that resume execution
+      class DebuggerResumeCommand
+        def self.execute(conf, *opts)
+          name = 
+            if self.name =~ /IRB::ExtendCommand::(\S+)/
+              $1.downcase
+            else
+              'unknown'
+            end
+          $trepan_args = opts
+          $trepan_command = 
+            if $trepan_irb_statements 
+              $trepan_irb_statements
+            else
+              ([name] + opts).join(' ')
+            end
+          
+          throw :IRB_EXIT, name.to_sym
+        end
+      end
+      
+      class Continue < DebuggerResumeCommand ; end
+      class Finish   < DebuggerResumeCommand ; end
+      class Next     < DebuggerResumeCommand ; end
+      class Quit     < DebuggerResumeCommand ; end
+      class Step     < DebuggerResumeCommand ; end
+      
+      # Issues a comamnd to the debugger without continuing
+      # execution. 
+      class Dbgr
+        def self.execute(conf, *opts)
+          $trepan_command = 
+            if opts.size == 1 && opts[0].is_a?(String)
+              $trepan_args = opts[0]
+            else
+              opts.join(' ')
+            end
+          dbg_cmdproc = conf.workspace.instance_variable_get('@dbg_cmdproc')
+          dbg_cmdproc.run_command($trepan_command)
+        end
+      end
+    end
+  end
+
+  if defined?(ExtendCommandBundle)
+    # New irb Commands which are the same name as their debugger
+    # counterpart
+    %w(Dbgr Finish Step).each do |name|
+      command = name.downcase
+      sym     = name.to_sym
+      ExtendCommandBundle.def_extend_command command, sym
+    end
+    # New irb Commands which are the slightly different from their
+    # debugger counterpart
+    [['cont',   :Continue],
+     ['ne',     :Next],
+     ['q',      :Quit]].each do |command, sym|
+      ExtendCommandBundle.def_extend_command command, sym
+    end
+  end
+  
+  def self.start_session(binding, dbg_cmdproc, conf={})
+    unless @__initialized
+
+      # Set to run the standard trepanx IRB profile
+      irbrc = File.expand_path(File.join(File.dirname(__FILE__), 
+                                         %w(.. data irbrc)))
+      ENV['IRBRC'] = irbrc
+
+      args = ARGV.dup
+      ARGV.replace([])
+      IRB.setup(nil)
+      ARGV.replace(args)
+      
+      # If the user has a IRB profile, run that now.
+      if ENV['TREPANX_IRB']
+        ENV['IRBRC'] = ENV['TREPANX_IRB']
+        @CONF[:RC_NAME_GENERATOR]=nil
+        IRB.run_config
+      end
+
+      @__initialized = true
+    end
+    
+    workspace = WorkSpace.new(binding)
+
+    irb = Irb.new(workspace)
+
+    @CONF[:IRB_RC].call(irb.context) if @CONF[:IRB_RC]
+    @CONF[:MAIN_CONTEXT] = irb.context
+    conf.each {|k, v| @CONF[k] = v}
+    # A copy of this back_trace_limit is already active. How? 
+    IRB.CurrentContext.back_trace_limit = @CONF[:BACK_TRACE_LIMIT]
+
+    catch(:IRB_EXIT) do
+      irb.eval_input
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  IRB.start_session(binding, nil) if ARGV.size > 0
+end

data/app/iseq.rb

@@ -0,0 +1,188 @@
+# Module for working with instruction sequences.
+class Trepan
+  module ISeq
+    OP_GOTO = Rubinius::InstructionSet.opcodes_map[:goto]
+    OP_GOTO_IF_TRUE  = Rubinius::InstructionSet.opcodes_map[:goto_if_true]
+    OP_GOTO_IF_FALSE = Rubinius::InstructionSet.opcodes_map[:goto_if_false]
+    OP_RET           = Rubinius::InstructionSet.opcodes_map[:ret]
+    OP_YIELD_STACK   = Rubinius::InstructionSet.opcodes_map[:yield_stack]
+
+    module_function
+
+    # Returns prefix string to indicate whether a breakpoint has been
+    # set at this ip and or whether we are currently stopped at this ip.
+    def disasm_prefix(ip, frame_ip, cm)
+      prefix = cm.breakpoint?(ip) ? 'B' : ' ' 
+      prefix += 
+        if ip == frame_ip
+          '-->'
+        else
+          '   '
+        end
+    end
+
+    def goto_op?(cm, ip)
+      [OP_GOTO, OP_GOTO_IF_TRUE, OP_GOTO_IF_FALSE].member?(cm.iseq[ip])
+    end
+
+    def goto_between(cm, start, fin)
+      
+      iseq = cm.iseq
+      
+      i = start
+      while i < fin
+        op = iseq[i]
+        case op
+        when OP_GOTO
+          return next_interesting(cm, iseq[i + 1]) # goto target
+        when OP_RET
+          return -2
+        when OP_GOTO_IF_TRUE, OP_GOTO_IF_FALSE
+          return [next_interesting(cm, iseq[i + 1]),
+                  next_interesting(cm, i + 2)] # target and next ip
+        when nil
+          return -1
+        else
+          # Rubinius is getting an error here sometimes. Need to figure
+          # out what's wrong.
+          begin
+            op = Rubinius::InstructionSet[op]
+          rescue TypeError
+            return -1
+          end
+          i += (op.arg_count + 1)
+        end
+      end
+
+      if fin == cm.lines.last
+        return -1
+      else
+        return next_interesting(cm, fin)
+      end
+    end
+
+    def ip_ranges_for_line(lines, line)
+      result = []
+      in_range = false
+      start_ip = nil
+      total = lines.size
+      i = 1
+      while i < total
+        cur_line = lines.at(i)
+        if cur_line == line
+          start_ip = lines.at(i-1)
+          in_range = true
+        elsif cur_line > line && in_range
+          result << [start_ip, lines.at(i-1)]
+          start_ip = nil
+          in_range = false
+        end
+        i += 2
+      end
+      if in_range && start_ip
+        result << [start_ip, lines.at(total-1)]
+      end
+      result
+    end
+    
+    # Return range of ips covering ip. There will be only one of these.
+    # We surround this in another list to match the format of 
+    # ip_ranges_for_line.
+    def ip_ranges_for_ip(lines, ip)
+      total = lines.size
+      i = 0
+      while i < total and lines.at(i) <= ip
+        i += 2
+      end
+      [[lines.at(i-2), lines.at(i)]]
+    end
+  
+    def next_interesting(cm, ip)
+      pop = Rubinius::InstructionSet.opcodes_map[:pop]
+      
+      if cm.iseq[ip] == pop
+        return ip + 1
+      end
+      
+      return ip
+    end
+
+    # start is assumed to be on a tail code "synthesized" line, which
+    # has line number 0. Follow opcodes until we get to a line that is
+    # not 0. 
+    def tail_code_line(cm, start)
+      
+      iseq = cm.iseq
+      
+      i = start
+      fin = cm.lines.last
+      while i < fin
+        line_no = cm.line_from_ip(i)
+        return line_no if line_no > 0
+        op = iseq[i]
+        case op
+        when OP_GOTO_IF_TRUE, OP_GOTO_IF_FALSE, OP_GOTO
+        when OP_GOTO
+          i = iseq[i+1]
+        when OP_RET
+          return -2
+        when nil
+          return -1
+        else
+          # Rubinius is getting an error here sometimes. Need to figure
+          # out what's wrong.
+          begin
+            op = Rubinius::InstructionSet[op]
+          rescue TypeError
+            return -1
+          end
+          i += (op.arg_count + 1)
+        end
+      end
+      return 0
+    end
+    
+    def yield_or_return_between(cm, start, fin)
+      iseq = cm.iseq
+      ips = []
+      i = start
+      while i < fin
+        op = iseq[i]
+        if [OP_RET, OP_YIELD_STACK].member?(op)
+          ips << i 
+        end
+        op = Rubinius::InstructionSet[op]
+        i += (op.arg_count + 1)
+      end
+      return ips
+    end
+
+  end
+end
+if __FILE__ == $0
+  vm_locations = Rubinius::VM.backtrace(0, true)
+  call_loc = vm_locations[1]
+  cm = call_loc.method
+  puts cm.decode
+  ips = nil
+  puts '-' * 20
+  0.upto((cm.lines.last+1)/2) do |i|
+    ip = cm.lines[i*2]
+    unless -1 == ip
+      ips = Trepan::ISeq.yield_or_return_between(cm, ip, cm.lines.last) 
+      puts "return: #{ips.inspect}"
+      break 
+    end
+  end
+  puts '-' * 20
+  0.upto((cm.lines.last+1)/2) do |i|
+    ip = cm.lines[i*2]
+    unless -1 == ip
+      ips = Trepan::ISeq.goto_between(cm, ip, cm.lines.last)
+      puts "goto: #{ips.inspect}"
+      break 
+    end
+  end
+  puts Trepan::ISeq.disasm_prefix(ips[0], ips[0], cm)
+  p Trepan::ISeq.disasm_prefix(10, ips[0], cm)
+end

data/app/method.rb

@@ -0,0 +1,178 @@
+# Copyright (C) 2010, 2013 Rocky Bernstein <rockyb@rubyforge.net>
+module Trepanning
+  module Method
+
+    module_function
+    ## FIXME: until the next two routines find their way back into
+    ## Rubinius::CompiledMethod...
+    ##
+    # Locates the instruction address (IP) of the first instruction on
+    # the specified line if is in CompiledMethod cm only, or nil if no
+    # match for the specified line is found.
+    #
+    # @return [Fixnum, NilClass] returns
+    #   nil if nothing is found, else the first IP for the line
+    def locate_line_in_cm(line, cm=self)
+      cm.lines.each_with_index do |l, i|
+        next unless (i&1 == 1)
+        if (l ==  line)
+          # Found target line - return first IP
+          return cm.lines[i-1]
+        elsif l > line
+          return nil
+        end
+      end
+      return nil
+    end
+
+    ## FIXME: Try using Routine in Rubinius now.
+    ##
+    # Locates the CompiledMethod and instruction address (IP) of the
+    # first instruction on the specified line. This method recursively
+    # examines child compiled methods until an exact match for the
+    # searched line is found.  It returns both the matching
+    # CompiledMethod and the IP of the first instruction on the
+    # requested line, or nil if no match for the specified line is
+    # found.
+    #
+    # @return [(Rubinius::CompiledMethod, Fixnum), NilClass] returns
+    #   nil if nothing is found, else an array of size 2 containing the method
+    #   the line was found in and the IP pointing there.
+    def locate_line(line, cm=self)
+      ## p [cm, lines_of_method(cm)]
+      ip = locate_line_in_cm(line, cm)
+      return cm, ip if ip
+
+      # Didn't find line in this CM, so check if a contained
+      # CM encompasses the line searched for
+      cm.child_methods.each do |child|
+        if res = locate_line(line, child)
+          return res
+        end
+      end
+
+      # No child method is a match - fail
+      return nil
+    end
+
+    def lines_of_method(cm)
+      lines = []
+      cm.lines.each_with_index do |l, i|
+        lines << l if (i&1 == 1)
+      end
+      return lines
+    end
+
+    # Return true if ip is the start of some instruction in meth.
+    # FIXME: be more stringent.
+    def valid_ip?(cm, ip)
+      size = cm.lines.size
+      ip >= 0 && ip < cm.lines[size-1]
+    end
+
+    # Returns a CompiledMethod for the specified line. We search the
+    # current method +meth+ and then up the parent scope.  If we hit
+    # the top and we can't find +line+ that way, then we
+    # reverse the search from the top and search down. This will add
+    # all siblings of ancestors of +meth+.
+    def find_method_with_line(cm, line)
+      unless cm.kind_of?(Rubinius::CompiledMethod)
+        return nil
+      end
+
+      lines = lines_of_method(cm)
+      return cm if lines.member?(line)
+      scope = cm.scope
+      return nil unless scope and scope.current_script
+      cm  = scope.current_script.compiled_code
+      lines = lines_of_method(cm)
+      until lines.member?(line) do
+        child = scope
+        scope = scope.parent
+        unless scope
+          # child is the top-most scope. Search down from here.
+          cm = child.current_script.compiled_code
+          pair = locate_line(line, cm)
+          ## pair = cm.locate_line(line)
+          return pair ? pair[0] : nil
+        end
+        cm = scope.current_script.compiled_code
+        lines = lines_of_method(cm)
+      end
+      return cm
+    end
+
+    def top_scope(cm)
+      scope = cm.scope
+      return unless scope
+      while true do
+        scope = scope.parent
+        break unless scope && scope.current_script
+        cm = scope.current_script.compiled_code
+      end
+      cm
+    end
+  end
+
+end
+
+module Rubinius
+
+  class Location
+    def next_ip
+      ip_on_current? ? ip : ip + 1
+    end
+  end
+
+  class CompiledMethod < Executable
+    ##
+    # Returns the address (IP) of the first instruction in this
+    # CompiledMethod that is on the specified line but not before the
+    # given, or the address of the first instruction on the next code
+    # line after the specified line if there are no instructions on
+    # the requested line.  This method only looks at instructions
+    # within the current CompiledMethod; see #locate_line for an
+    # alternate method that also searches inside the child
+    # CompiledMethods.
+
+    #
+    # @return [Fixnum] the address of the first instruction
+    def first_ip_on_line_after(line, start_ip)
+      i = 0
+      last_i = @lines.size - 1
+      while i < last_i
+        ip = @lines.at(i)
+        cur_line = @lines.at(i+1)
+        if cur_line >= line and ip >= start_ip
+          return ip
+        end
+        i += 2
+      end
+      nil
+    end
+  end
+end
+
+
+if __FILE__ == $0
+  include Trepanning::Method
+  require "#{File.dirname(__FILE__)}/../lib/trepanning"
+
+  line = __LINE__
+  def find_line(line) # :nodoc
+    cm = Rubinius::VM.backtrace(0)[0].method
+    p lines_of_method(cm)
+    p find_method_with_line(cm, line)
+  end
+
+  cm = Rubinius::VM.backtrace(0)[0].method
+  p lines_of_method(cm)
+  find_line(line)
+  p find_method_with_line(cm, line+2)
+  puts "top scope: #{top_scope(cm)}"
+  ip = locate_line( __LINE__, cm)[1]
+  puts "Line #{__LINE__} has ip #{ip}"
+  [-1, 0, 10, ip, 10000].each do |i|
+    puts "IP #{i} is %svalid" % (valid_ip?(cm, i) ? '' : 'not ')
+  end
+end

data/app/mock.rb

@@ -0,0 +1,13 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+class Trepan
+  attr_accessor :trace_filter # Procs/Methods we ignore.
+  def initialize(opts={})
+    @trace_filter = []
+  end
+  class MockCore
+    attr_accessor :dbgr
+    attr_reader   :core
+    def event; 'line' end
+  end 
+end
+

data/app/options.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010-2011, 2013 Rocky Bernstein <rockyb@rubyforge.net>
+#=== Summary
+# Parses command-line options.
+
+require 'optparse'
+class Trepan
+  require 'rubygems'; require 'require_relative'
+  require_relative 'default'
+
+  VERSION = '0.2.0'
+  PROGRAM = 'trepanx' unless defined? Trepan::PROGRAM
+
+  def self.show_version
+    "#{PROGRAM}, version #{VERSION}"
+  end
+
+  def self.copy_default_options
+    options = {}
+    DEFAULT_CMDLINE_SETTINGS.each do |key, value|
+      begin
+        options[key] = value.clone
+      rescue TypeError
+        options[key] = value
+      end
+    end
+    options
+  end
+
+  def self.setup_options(options, stdout=$stdout, stderr=$stderr)
+    OptionParser.new do |opts|
+      opts.banner = <<EOB
+#{show_version}
+Usage: #{PROGRAM} [options] [[--] <script.rb> <script.rb parameters>]
+EOB
+      opts.separator ''
+      opts.separator 'Options:'
+      opts.on('--client',
+              'Connect to out-of-process program') do
+        if options[:server]
+          stderr.puts '--server option previously given. --client option ignored.'
+        else
+          options[:client] = true
+        end
+      end
+      opts.on('-c', '--command FILE', String,
+              'Execute debugger commands from FILE') do |cmdfile|
+        if File.readable?(cmdfile)
+          options[:cmdfiles] << cmdfile
+        elsif File.exists?(cmdfile)
+            stderr.puts "Command file '#{cmdfile}' is not readable. Option ignored."
+        else
+          stderr.puts "Command file '#{cmdfile}' does not exist."
+        end
+      end
+      opts.on('--cd DIR', String, 'Change current directory to DIR') do |dir|
+        if File.directory?(dir)
+          if File.executable?(dir)
+            options[:chdir] = dir
+          else
+            stderr.puts "Can't cd to #{dir}. Option --cd ignored."
+          end
+        else
+          stderr.puts "\"#{dir}\" is not a directory. Option --cd ignored."
+        end
+      end
+      opts.on('--basename',
+              'Show only file basename in file locations') do
+        options[:basename] = true
+      end
+      opts.on('-d', '--debug', 'Set $DEBUG=true') do
+        $DEBUG = true
+      end
+     opts.on('--[no-]highlight',
+              'Use [no] syntax highlight output') do |v|
+        options[:highlight] = ((v) ? :term : nil)
+      end
+      opts.on('-h', '--host NAME', String,
+              'Host or IP used in TCP connections for --server or --client. ' +
+              "Default is #{DEFAULT_SETTINGS[:host].inspect}.") do
+        |name_or_ip|
+        options[:host] = name_or_ip
+      end
+      opts.on('-I', '--include PATH', String, 'Add PATH to $LOAD_PATH') do
+        |path|
+        $LOAD_PATH.unshift(path)
+      end
+      opts.on('--nx',
+              "Do not run debugger initialization file #{CMD_INITFILE}") do
+        options[:nx] = true
+      end
+      opts.on('-p', '--port NUMBER', Integer,
+              'Port number used in TCP connections for --server or --client. ' +
+              "Default is #{DEFAULT_SETTINGS[:port]}.") do
+        |num|
+        options[:port] = num
+      end
+      opts.on('--[no-]readline',
+              'Try [not] GNU Readline') do |v|
+        options[:readline] = v
+      end
+      opts.on('-r', '--require SCRIPT', String,
+              'Require the library, before executing your script') do |name|
+        if name == 'debug'
+          stderr.puts "ruby-debug is not compatible with Ruby's 'debug' library. This option is ignored."
+        else
+          require name
+        end
+      end
+      opts.on('-s', '--server',
+              'Set up for out-of-process debugging') do
+        if options[:client]
+          stderr.puts '--client option previously given. --server option ignored.'
+        else
+          options[:server] = true
+        end
+      end
+      opts.on('-x', '--trace', 'Turn on line tracing') do
+        options[:traceprint] = true
+        options[:nx] = true
+      end
+      opts.separator ''
+      opts.on_tail('-?', '--help', 'Show this message') do
+        options[:help] = true
+        stdout.puts opts
+        exit
+      end
+      opts.on_tail('-v', '--version',
+                   'print the version') do
+        options[:version] = true
+        stdout.puts show_version
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  opts = {}
+  options ={}
+  [%w(--help), %w(--version)].each do |o|
+    options = Trepan::copy_default_options
+    opts    = Trepan::setup_options(options)
+    rest    = opts.parse o
+    p options
+    puts '=' * 10
+  end
+  rest = opts.parse! ARGV
+  puts opts
+  puts '=' * 10
+  p options
+  puts '=' * 10
+  p Trepan::DEFAULT_CMDLINE_SETTINGS
+end