trepanning 0.0.4

data/processor/command/info_subcmd/registers.rb

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../base/subsubcmd'
+require_relative '../base/subsubmgr'
+
+class Trepan::SubSubcommand::InfoRegisters < Trepan::SubSubcommandMgr
+  unless defined?(HELP)
+    HELP         = 
+'List of contents for the registers of the current stack frame.
+If a register name given, only only that register is show.
+
+Examples:
+  info registers     # show all registers
+  info register pc   # show only the pc register
+  info reg sp        # show all stack pointer registers
+  info reg sp 1 3    # show sp(1) and sp(3)
+  info reg sp size   # show sp size
+  info reg lfp       # show lfp(0)
+'
+
+    MIN_ABBREV   = 'reg'.size  # Note we have "info return"
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info registers)
+  end
+
+  def run(args)
+
+    args = @parent.last_args
+    unavailable_regs = 
+      if 'CFUNC' == @proc.frame.type
+        %w(inforegisterslfp inforegisterspc) 
+      else
+        []
+      end
+    all_regs = @subcmds.subcmds.keys.sort - unavailable_regs
+      
+    if args.size == 2
+      # Form is: "info registers"
+      all_regs.sort.each do |subcmd_name|
+        @subcmds.subcmds[subcmd_name].run([])
+      end
+    else
+      subcmd_name = args[2]
+      key_name    = PREFIX.join('') + subcmd_name
+      remain_args = args[3..-1]
+      if all_regs.member?(key_name)
+        @subcmds.subcmds[key_name].run(remain_args) 
+      elsif unavailable_regs.member?(key_name)
+        msg("info registers: %s can not be displayed for frame type %s." % 
+            [subcmd_name, @proc.frame.type])
+      else
+        errmsg("info registers: %s is not a valid register name" % subcmd_name)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  dbgr = MockDebugger::MockDebugger.new
+  cmds = dbgr.core.processor.commands
+  info_cmd = cmds['info']
+  command = Trepan::SubSubcommand::InfoRegisters.new(dbgr.core.processor,
+                                                     info_cmd)
+  name = File.basename(__FILE__, '.rb')
+  cmd_args = ['info', name]
+  info_cmd.instance_variable_set('@last_args', cmd_args)
+  command.proc.frame_setup(RubyVM::ThreadFrame::current)
+  command.run(cmd_args)
+end

data/processor/command/info_subcmd/registers_subcmd/dfp.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../../base/subsubcmd'
+require_relative 'helper'
+
+class Trepan::Subcommand::InfoRegistersDfp < Trepan::SubSubcommand
+  unless defined?(HELP)
+    HELP         = 'Show the value of the VM dynamic frame pointer (DFP)'
+    MIN_ABBREV   = 'lf'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info registers dfp)
+  end
+
+  include Registers
+  def run(args)
+    register_array_index(PREFIX[-1], args)
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = Trepan::SubSubcommand::InfoRegistersDfp::PREFIX.join('')
+  infox_cmd  = Trepan::SubSubcommand::InfoRegistersDfp.new(info_cmd.proc,
+                                                           info_cmd,
+                                                           cmd_name)
+  infox_cmd.run([])
+
+  # name = File.basename(__FILE__, '.rb')
+  # subcommand.summary_help(name)
+end

data/processor/command/info_subcmd/registers_subcmd/helper.rb

@@ -0,0 +1,40 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+module Registers
+  def register_array_index(name, args, max_value=nil)
+    if args.size == 0
+      # Form is: "info xx" which means "info xx 0"
+      lookup_pos = position = 0
+    else
+      position_str = args[0]
+      opts = {
+        :msg_on_error => 
+        "The 'info registers %s' command argument must eval to an integer. Got: %s" % [name, position_str],
+        # :min_value => 0,
+        :max_value => max_value
+      }
+      position = @proc.get_an_int(position_str, opts)
+      return nil unless position
+    end
+    lookup_pos = 
+      if 'lfp' == name
+        max_value + 1 - position 
+      elsif 'sp' == name && 'CFUNC' == @proc.frame.type 
+        # && @proc.frame.next.type == 'IFUNC" # ? 
+
+        # FIXME: In C frames there seems to be some vm_push_frame's
+        # via perhaps vm_yield_with_cfunc along with sp adjustments.
+        # I am not sure if this is under what conditions this
+        # *doesn't* happen so until I can figure out the better thing
+        # to do, possibly in the Ruby 1.9 interpeter, we'll handle
+        # this here.  It is also conceivable to handle this in
+        # thread_frame's sp handling.
+        position + 2
+      else
+        position
+      end
+    msg("VM %s(%d) = %s" % [name, position, 
+                            @proc.frame.send(name, lookup_pos).inspect])
+    return position
+  end
+
+end

data/processor/command/info_subcmd/registers_subcmd/lfp.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../../base/subsubcmd'
+require_relative 'helper'
+
+class Trepan::Subcommand::InfoRegistersLfp < Trepan::SubSubcommand
+  unless defined?(HELP)
+    HELP         = 'Show the value of the VM local frame pointer (LFP).
+
+When a local variable is defined for the first time, this stack
+is pushed and the value for local variable is assigned to this stack entry.
+
+See also "info register sp".'
+
+    MIN_ABBREV   = 'lf'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info registers lfp)
+  end
+
+  include Registers
+  def run(args)
+    frame = @proc.frame
+    if 'CFUNC' == frame.type
+      msg "local_name not available for C function"
+    else
+      iseq = frame.iseq
+      index = register_array_index(PREFIX[-1], args, iseq.local_size-1)
+      msg("local_name(%d)=%s" % [index, iseq.local_name(index)]) if index
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = Trepan::SubSubcommand::InfoRegistersSp::PREFIX.join('')
+  infox_cmd  = Trepan::SubSubcommand::InfoRegistersSp.new(info_cmd.proc,
+                                                          info_cmd,
+                                                          cmd_name)
+  # require_relative '../../../../lib/trepanning'
+  # dbgr = Trepan.new(:set_restart => true)
+  # dbgr.debugger
+  infox_cmd.run([])
+
+  # name = File.basename(__FILE__, '.rb')
+  # subcommand.summary_help(name)
+end

data/processor/command/info_subcmd/registers_subcmd/pc.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../../base/subsubcmd'
+
+class Trepan::SubSubcommand::InfoRegistersPc < Trepan::SubSubcommand
+  unless defined?(HELP)
+    HELP         = 'Show the value of the VM program counter (PC).
+
+The VM program is an offset into the instruction sequence for the next
+VM instruction in the sequence to be executed. 
+
+See also "info disassemble" and "info registers".'
+    MIN_ABBREV   = 'pc'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info registers pc)
+  end
+
+  def run(args)
+    msg("VM pc = %d" % @proc.frame.pc_offset)
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = Trepan::SubSubcommand::InfoRegistersPc::PREFIX.join('')
+  infox_cmd  = Trepan::SubSubcommand::InfoRegistersPc.new(info_cmd.proc, 
+                                                          info_cmd,
+                                                          cmd_name)
+  # require_relative '../../../../trepanning'
+  # dbgr = Trepan.new(:set_restart => true)
+  # dbgr.debugger
+  infox_cmd.run([])
+
+  # name = File.basename(__FILE__, '.rb')
+  # subcommand.summary_help(name)
+end

data/processor/command/info_subcmd/registers_subcmd/sp.rb

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../../base/subsubcmd'
+require_relative 'helper'
+
+class Trepan::Subcommand::InfoRegistersSp < Trepan::SubSubcommand
+  unless defined?(HELP)
+    HELP         = 'Show information about the VM stack pointer (SP).
+
+usage: 
+   info register sp [NUMBER NUMBER ...|size]
+
+With no arguments, all SP values for the current frame of the debugged
+program are shown.  If a number is given, then the entry at that
+location is shown. If "size" is given, then we show the number items
+in the stack of the current frame.
+
+The VM uses a stack to store temporary values in computations. For
+example to compute "a + b", the values of "a" and "b" are pushed onto
+a stack pointed to by SP. Just before the addition is perofrmed, sp(1)
+will have the value "a" contians and sp(2) will contain the value of
+"b"
+
+See also "info register LFP"'
+
+    MIN_ABBREV   = 'sp'.size
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info registers sp)
+  end
+
+  include Registers
+  def run(args)
+    if args.size == 0
+      1.upto(@proc.frame.sp_size-1) do |i|
+        msg "%s%d: %s" % [' ' * 2, i, @proc.frame.sp(i).inspect]
+      end if @proc.frame.sp_size
+    elsif args.size == 1 and 'size' == args[0] 
+      msg "Number of stack items in frame is #{@proc.frame.sp_size}."
+    else
+      args.each do |arg|
+        register_array_index(PREFIX[-1], arg, @proc.frame.sp_size)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../../mock'
+  require_relative '../../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, info_cmd = MockDebugger::setup('info')
+  testcmdMgr = Trepan::Subcmd.new(info_cmd)
+  cmd_name   = Trepan::SubSubcommand::InfoRegistersSp::PREFIX.join('')
+  infox_cmd  = Trepan::SubSubcommand::InfoRegistersSp.new(info_cmd.proc, 
+                                                          info_cmd,
+                                                          cmd_name)
+  infox_cmd.summary_help(name)
+  puts
+  # require_relative '../../../../lib/trepanning'
+  # dbgr = Trepan.new(:set_restart => true)
+  # dbgr.debugger
+  infox_cmd.run([])
+  puts
+  %w(0 1 10).each do |val|
+    infox_cmd.run([val])
+    puts '-' * 40
+  end
+  infox_cmd.run(['size'])
+
+  name = File.basename(__FILE__, '.rb')
+end

data/processor/command/info_subcmd/return.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../base/subcmd'
+
+class Trepan::Subcommand::InfoReturn < Trepan::Subcommand
+  unless defined?(HELP)
+    HELP         = 'Show the value about to be returned'
+    MIN_ABBREV   = 'ret'.size # Note we have "info registers"
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info return)
+  end
+
+  def run(args)
+    event = @proc.event
+    if %w(return c-return).member?(event)
+      ret_val = Trepan::Frame.value_returned(@proc.frame, event)
+      msg('Return value: %s' % ret_val.inspect)
+    else
+      errmsg('You need to be in a return event to do this. Event is %s' % 
+             event)
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  require_relative '../../subcmd'
+  name = File.basename(__FILE__, '.rb')
+
+  # FIXME: DRY the below code
+  dbgr, cmd = MockDebugger::setup('info')
+  subcommand = Trepan::Subcommand::InfoReturn.new(cmd)
+  testcmdMgr = Trepan::Subcmd.new(subcommand)
+
+  name = File.basename(__FILE__, '.rb')
+  subcommand.summary_help(name)
+end

data/processor/command/info_subcmd/thread.rb

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative '../base/subcmd'
+require_relative '../../../app/thread'
+require_relative '../../../app/frame'
+
+class Trepan::Subcommand::InfoThread < Trepan::Subcommand
+  unless defined?(HELP)
+    HELP         = 
+'info thread [THREAD-ARG1 THREAD-ARG2.. ]
+
+Show frame information for thread(s). If no thread arguments are
+given, then the top frame information is shown for all threads.
+
+If arguments are given, each number should be either the object id of
+the thread, a position number in the list of threads, "M", or ".".  The
+object id and list position are given when "info thread" is run.  The
+name "M" in upper- or lower- case refers to the "main thread" and "."
+refers to the current thread.
+
+Examples:
+   info thread             # Show summary frame information
+   info thread M           # information for main thread
+   info thread .           # information for current thread
+   info thread 1 2 m       # information for thread in list 1, 2, and main
+   info thread 92562770    # ifnormation for thread with object id 92562770
+'
+    MIN_ABBREV   = 'thr'.size 
+    NAME         = File.basename(__FILE__, '.rb')
+    NEED_STACK   = true
+    PREFIX       = %w(info thread)
+    SHORT_HELP   = 'Show frame(s) for threads'
+  end
+
+  include Trepan::ThreadHelper
+  include Trepan::Frame # To show stack
+
+  def list_threads(verbose=false)
+    Thread.list.each_with_index do |th, i|
+      main_str = 
+        if th == Thread.main
+          '(main thread) '
+          else
+          ''
+        end
+      frame, line_no, mark = 
+        if th == Thread.current
+          [@proc.frame, @proc.frame_line, '+']
+        else
+          [th.threadframe, 
+           (@proc.frame.source_location && @proc.frame.source_location[0]),
+           ' ']
+        end
+      frame_info = format_stack_call(frame, {})
+
+      source_container = @proc.frame_container(frame, false)
+      loc = @proc.source_location_info(source_container, line_no, frame)
+
+      msg("%s %2d %s%d %s\n\t%s\n\t%s" % 
+          [mark, i, main_str, th.object_id, th.inspect, frame_info, loc])
+    end
+  end
+
+  def run(args)
+    if args.size == 2
+      list_threads
+    elsif args.size > 2
+      args[2..-1].each do |id_or_num_str|
+        th = @proc.get_thread_from_string(id_or_num_str)
+        if th
+          frame = @proc.get_frame_from_thread(th)
+          print_stack_trace(frame, {:maxstack => settings[:maxstack]})
+        end
+      end
+    else
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  # Demo it.
+  require_relative '../../mock'
+  name = File.basename(__FILE__, '.rb')
+
+  dbgr, cmd  = MockDebugger::setup('info')
+  # FIXME: shouldn't have to do this:
+  cmd.proc.settings[:maxstring] = 150
+
+  name = File.basename(__FILE__, '.rb')
+  cmd_args = ['info', name]
+
+  cmd.proc.instance_variable_set('@last_args', cmd_args)
+  cmd_args = ['info', name]
+  cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+  cmd.run(cmd_args)
+  puts '-' * 20
+  Thread.new do 
+    cmd.proc.frame_setup(RubyVM::ThreadFrame::current)
+    cmd.run(cmd_args)
+    puts '-' * 10
+    cmd.run(cmd_args + [0])
+    puts '-' * 10
+    cmd.run(cmd_args + [1])
+  end.join
+end

data/processor/command/irb.rb

@@ -0,0 +1,106 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require 'irb'
+require_relative 'base/cmd'
+require_relative '../../app/irb'
+class Trepan::Command::IRBCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"          irb [-d]\tstarts an Interactive Ruby (IRB) session.
+
+If -d is added you can get access to debugger frame the global variables
+$trepan_frame and $trepan_cmdproc. 
+
+irb is extended with methods 'cont', 'dbgr', 'n', and, 'q', 'step' which 
+run the corresponding debugger commands. 
+
+To issue a debugger command, inside irb nested inside a debugger use
+'dbgr'. For example:
+
+  dbgr %%w(info program)
+  dbgr('info', 'program') # Same as above
+  dbgr 'info program'     # Single quoted string also works
+
+But arguments have to be quoted because irb will evaluate them:
+
+  dbgr info program     # wrong!
+  dbgr info, program    # wrong!
+  dbgr(info, program)   # What I say 3 times is wrong!
+
+Here then is a loop to query VM stack values:
+  (-1..1).each {|i| dbgr(\"info reg sp \#{i}\")}
+"
+
+    CATEGORY     = 'support'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    SHORT_HELP  = 'Run interactive Ruby session irb as a command subshell'
+  end
+
+  # This method runs the command
+  def run(args) # :nodoc
+    add_debugging = 
+      if args.size > 1
+        '-d' == args[1]
+      else
+        false
+      end
+
+    # unless @state.interface.kind_of?(LocalInterface)
+    #   print "Command is available only in local mode.\n"
+    #   throw :debug_error
+    # end
+
+    save_trap = trap('SIGINT') do
+      throw :IRB_EXIT, :cont if $trepan_in_irb
+    end
+
+    $trepan = @proc.dbgr 
+    if add_debugging
+      $trepan_cmdproc  = @proc
+      $trepan_frame    = @proc.frame
+    end
+    $trepan_in_irb = true
+    $trepan_irb_statements = nil
+    $trepan_command = nil
+
+    conf = {:BACK_TRACE_LIMIT => settings[:maxstack]}
+    cont = IRB.start_session(@proc.frame.binding, @proc, conf)
+    trap('SIGINT', save_trap) # Restore old trap
+
+    back_trace_limit = IRB.CurrentContext.back_trace_limit
+    if settings[:maxstack] !=  back_trace_limit
+      msg("\nSetting debugger's BACK_TRACE_LIMIT (%d) to match irb's last setting (%d)" % 
+          [settings[:maxstack], back_trace_limit])
+      settings[:maxstack]= IRB.CurrentContext.back_trace_limit
+    end
+
+    case cont
+    when :continue
+      @proc.continue
+    when :finish
+      @proc.finish 
+    when :next
+      @proc.next # (1, {})
+    when :quit
+      @proc.quit
+    when :step
+      @proc.step # (1, {})
+    else
+      @proc.print_location
+    end
+  ensure
+    $trepan_in_irb = false
+    # restore old trap if any
+    trap('SIGINT', save_trap) if save_trap
+   end
+end
+
+if __FILE__ == $0
+  require 'thread_frame'
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  # Get an IRB session -- the hard way :-)
+  cmd.run([name]) if ARGV.size > 0
+end

data/processor/command/kill.rb

@@ -0,0 +1,58 @@
+# Copyright (C) 2010 Rocky Bernstein <rockyb@rubyforge.net>
+require_relative 'base/cmd'
+class Trepan::Command::KillCommand < Trepan::Command
+
+  unless defined?(HELP)
+    HELP = 
+"Kill execution of program being debugged.
+
+Equivalent of Process.kill('KILL', Process.pid). This is an unmaskable
+signal. When all else fails, e.g. in thread code, use this.
+
+If 'unconditionally' is given, no questions are asked. Otherwise, if
+we are in interactive mode, we'll prompt to make sure."
+
+    CATEGORY     = 'running'
+    MAX_ARGS     = 1  # Need at most this many
+    NAME         = File.basename(__FILE__, '.rb')
+    SHORT_HELP  = 'Send this process a POSIX signal (default "9" is "kill -9")'
+  end
+    
+  # This method runs the command
+  def run(args) # :nodoc
+    if args.size > 1
+      sig = Integer(args[1]) rescue args[1]
+      unless sig.is_a?(Integer) || Signal.list.member?(sig)
+        errmsg("Signal name '#{sig}' is not a signal I know about.\n")
+        return false
+        end
+#       FIXME: reinstate
+#       if 'KILL' == sig || Signal['KILL'] == sig
+#           @proc.intf.finalize
+#       end
+    else
+      if not confirm('Really kill?', false)
+        msg('Kill not confirmed.')
+        return
+      else 
+        sig = 'KILL'
+      end
+    end
+    begin
+      Process.kill(sig, Process.pid)
+    rescue Errno::ESRCH
+      errmsg "Unable to send kill #{sig} to process #{Process.pid}"
+    end
+  end
+end
+
+if __FILE__ == $0
+  require_relative '../mock'
+  name = File.basename(__FILE__, '.rb')
+  dbgr, cmd = MockDebugger::setup(name)
+  %w(fooo 1 -1 HUP -9).each do |arg| 
+    puts "#{name} #{arg}"
+    cmd.run([name, arg])
+    puts '=' * 40
+  end
+end