gdbruby 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d8f60d770afee00f6dcff8f144788e63210a5714
+  data.tar.gz: 08a8449dc823f8d43403bf09ceca37499e37619f
+SHA512:
+  metadata.gz: 57c4b47fd4b823cbfcf7461eb5561f9f36b68da821c0c0cad394123514a4cf2ccdf2c18863eea8a3d02e8f1d336646acb78561678bd3d8b7c8762028c32e34bc
+  data.tar.gz: 6b62783d5847fa6f787bba87739599ec33456d4bce35f1e8eb8eba617f0d47ddcd7e561ebb2dff374fb9ad4851b3a782e005e7719667c1a4e89f0ff7f9f3c058

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+
+rvm:
+  - "2.0.0"
+
+before_install:
+  - sudo apt-get -qq update
+  - sudo apt-get -qq install gdb
+
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,68 @@
+# gdbruby.rb
+
+## Overview
+
+gdbruby.rb can output these information with live process or core.
+
+- environment variables
+- C stacktrace
+- Ruby backtrace
+
+This is Ruby port of gdbperl.pl made by Akira Higuchi.
+
+## Precondition
+
+Your Ruby executable must have debug symbol.
+
+## Usage
+
+With live process(process id: 24113)
+
+```sh
+$ gdbruby.rb 24113
+```
+
+With core file. You have to specify path of ruby executable.
+
+```sh
+$ gdbruby.rb core.24113 `rbenv which ruby`
+```
+
+You can get core file with gcore script or execute gcore command on gdb like below.
+
+```
+$ gdb
+(gdb) attach 24113
+(gdb) gcore core.24113
+(gdb) detach
+```
+
+## Options
+
+You can specify options. 0 is interprited as false.
+
+```sh
+$ gdbruby.rb 24113 verbose_gdb=1 c_trace=1
+```
+
+- verbose_gdb: Show request and response to/from gdb(default: false)
+- env: Show environment variables(default: true)
+- c_trace: Show C stacktrace(default:true)
+
+## ToDo
+
+- Print all Ruby threads
+- Print arguments on Ruby backtrace
+- Speeding up Ruby's type check
+- List Ruby objects
+- Check memory usage
+
+## FAQ
+
+### Why don't you call functions such like rb_vm_get_sourceline()
+
+If you use gdbruby.rb with live process, gdb can call these functions. But if you use gdbruby.rb with core file, gdb cannot call c functions. So I re-implement these functions.
+
+### Which version does it support?
+
+Ruby 2.0.0 only.

data/Rakefile

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require "bundler/gem_tasks"
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+end
+task :default => :spec
+
+desc 'Open an irb session preloaded with the gem library'
+task :console do
+    sh 'irb -rubygems -I lib'
+end
+task :c => :console

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/gdbruby.rb

@@ -0,0 +1,533 @@
+#!/usr/bin/env ruby
+# vim: set expandtab ts=2 sw=2 nowrap ft=ruby ff=unix : */
+
+# gdbruby.rb - shows the call trace of a running ruby process
+#
+# Ruby porting of gdbperl.pl.
+# gdbperl.pl is made by ahiguchi.
+# https://github.com/ahiguti/gdbperl
+#
+# Copyright (c) Tasuku SUENAGA a.k.a. gunyarakun
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#   Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#   Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the
+#     documentation and/or other materials provided with the distribution.
+#   Neither the name of the author nor the names of its contributors
+#      may be used to endorse or promote products derived from this software
+#      without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# Usage: gdbruby.rb PROCESS_ID [ruby_EXECUTABLE] [OPTION=VALUE [...]]
+#        gdbruby.rb CORE_FILE ruby_EXECUTABLE [OPTION=VALUE [...]]
+
+require 'open3'
+
+class GDBRubyConfig
+  attr_reader :core_or_pid, :exe, :is_pid
+
+  def initialize(argvs)
+    @config_map = {}
+    @argv = []
+
+    argvs.each do |argv|
+      if argv =~ /^(\w+)=(.+)$/
+        @config_map[$1] = $2
+      else
+        @argv << argv
+      end
+    end
+
+    parse_argv
+  end
+
+  def parse_argv
+    @core_or_pid = @argv[0]
+
+    unless @core_or_pid
+      message =
+        "Usage: #{$0} PROCESS_ID [ruby_EXECUTABLE] [OPTION=VALUE [...]]\n" +
+        "Usage: #{$0} CORE_FILE ruby_EXECUTABLE [OPTION=VALUE [...]]\n"
+      puts message
+      exit 1
+    end
+
+    exe = @argv[1]
+
+    @is_pid = (@core_or_pid =~ /^\d+$/)
+    if @is_pid
+      if exe.nil?
+        begin
+          if RUBY_PLATFORM =~ /linux/
+            exe = File.readlink("/proc/#{@core_or_pid}/exe")
+          end
+        rescue
+        end
+      end
+
+      if exe.nil?
+        exe = `rbenv which ruby`
+        exe = `which ruby` unless FileTest.exist?(exe)
+        exe.chomp!
+      end
+    end
+
+    raise "failed to detect ruby executable" unless exe
+    @exe = exe
+  end
+
+  def [](key, default_value = nil)
+    if @config_map.has_key?(key)
+      return case default_value
+      when TrueClass, FalseClass
+        not (@config_map[key].empty? || @config_map[key] == '0')
+      when Numeric
+        @config_map[key].to_i
+      else
+        @config_map[key]
+      end
+    end
+    default_value
+  end
+end
+
+class GDB
+  COMMAND_READ_BUFFER_SIZE = 1024
+  attr_reader :exec_options
+
+  def initialize(config)
+    @config = config
+    @exec_options = ['gdb', '-silent', '-nw', @config.exe, @config.core_or_pid]
+  end
+
+  def run
+    @gdb_stdin, @gdb_stdout, @gdb_stderr = *Open3.popen3(*@exec_options)
+    prepare
+    begin
+      yield
+      detach
+    ensure
+      if @config.is_pid
+        Process.kill('CONT', @config.core_or_pid.to_i)
+      end
+      @gdb_stdin.close
+      @gdb_stdout.close
+      @gdb_stderr.close
+    end
+  end
+
+  def prepare
+    cmd_exec('')
+    cmd_exec('set pagination off')
+  end
+
+  def detach
+    cmd_get_value("detach")
+    cmd_get_value("quit")
+  end
+
+  def log_gdb(pre, message)
+    return unless @config['verbose_gdb', false]
+    message.each_line do |line|
+      puts "#{pre}: #{line}"
+    end
+  end
+
+  def cmd_get_pointer(cmd, type)
+    response = cmd_exec(cmd)
+    raise "Invalid pointer #{response}" unless response =~ /\(#{type} \*\) (0x[0-9a-f]+)/
+    $1
+  end
+
+  def cmd_exec(cmd)
+    log_gdb('C', cmd)
+    if cmd
+      send_cmd = cmd.empty? ? cmd : "#{cmd}\n"
+      r = @gdb_stdin.syswrite(send_cmd)
+      if r < send_cmd.length
+        raise "failed to send: [#{cmd}]"
+      end
+    end
+
+    responses = []
+    while true
+      # TODO: specify buffer size
+      begin
+        buf = @gdb_stdout.sysread(COMMAND_READ_BUFFER_SIZE)
+      rescue
+        break
+      end
+      responses << buf
+      break if buf =~ /\(gdb\) $/
+    end
+
+    response = responses.join('')
+    log_gdb('R', response)
+    response
+  end
+
+  def cmd_get_value(cmd)
+    response = cmd_exec(cmd)
+    return '' unless response =~ /\A\$\d+ =\s+(.+)/
+
+    value = $1
+    if value =~ /0x\w+\s+\"(.+)\"/
+      $1
+    else
+      value
+    end
+  end
+end
+
+class RubyInternal
+  FL_USHIFT = 12
+  FL_USER1 = 1 << (FL_USHIFT + 1)
+  RSTRING_NOEMBED = FL_USER1
+
+  VM_FRAME_MAGIC_CFUNC = 0x61
+  VM_FRAME_MAGIC_MASK_BITS = 8
+  VM_FRAME_MAGIC_MASK = ~(~0 << VM_FRAME_MAGIC_MASK_BITS)
+
+  def initialize(gdb)
+    @gdb = gdb
+  end
+
+  def ruby_vm_ifunc_p(pointer)
+    # pointer is string like 0xaabbccdd
+    @gdb.cmd_get_value("p (enum ruby_value_type)(((struct RBasic *)(#{pointer}))->flags & RUBY_T_MASK) == RUBY_T_NODE") != '0'
+  end
+
+  def ruby_vm_normal_iseq_p(pointer)
+    @gdb.cmd_get_value("p #{pointer} && #{pointer} != 0") != '0' and not ruby_vm_ifunc_p(pointer)
+  end
+
+  def rb_vm_get_sourceline(cfp, iseq)
+    if ruby_vm_normal_iseq_p(iseq)
+      # calc_lineno()@vm_backtrace.c
+      current_position = @gdb.cmd_get_value("p #{cfp}->pc - #{iseq}->iseq_encoded").to_i
+      # rb_iseq_line_no()@iseq.c
+      current_position -= 1 unless current_position == 0
+      # find_line_no@iseq.c and get_line_info@iseq.c
+      line_info_size = @gdb.cmd_get_value("p #{iseq}->line_info_size").to_i
+      line_info_table = "#{iseq}->line_info_table"
+      case line_info_size
+      when 0
+        return 0
+      when 1
+        return @gdb.cmd_get_value("p #{line_info_table}[0].line_no").to_i
+      else
+        (1..line_info_size).each do |i|
+          position = @gdb.cmd_get_value("p #{line_info_table}[#{i}].position").to_i
+          if position == current_position
+            return @gdb.cmd_get_value("p #{line_info_table}[#{i}].line_no").to_i
+          elsif position > current_position
+            return @gdb.cmd_get_value("p #{line_info_table}[#{i - 1}].line_no").to_i
+          end
+        end
+      end
+    end
+    0
+  end
+
+  # NOTE: This logic is slow because many commands are sent to gdb.
+  #       Fetch consts with 'ptype enum ruby_value_type' first and
+  #       check types in Ruby.
+  def rb_type(value)
+    type_str = nil
+    # IMMEDIATE_P
+    if @gdb.cmd_get_value("p (int)(#{value}) & RUBY_IMMEDIATE_MASK") != '0'
+      # FIXNUM_P
+      if @gdb.cmd_get_value("p (int)(#{value}) & RUBY_FIXNUM_FLAG") != '0'
+        type_str = 'RUBY_T_FIXNUM'
+      # FLONUM_P
+      elsif @gdb.cmd_get_value("p ((int)(#{value}) & RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG") != '0'
+        type_str = 'RUBY_T_FLONUM'
+      elsif @gdb.cmd_get_value("p (#{value}) == RUBY_Qtrue") != '0'
+        type_str = 'RUBY_T_TRUE'
+      # SYMBOL_P
+      elsif @gdb.cmd_get_value("p (VALUE)(#{value}) & ~(~(VALUE)0 << RUBY_SPECIAL_SHIFT) == RUBY_SYMBOL_FLAG") != '0'
+        type_str = 'RUBY_T_SYMBOL'
+      elsif @gdb.cmd_get_value("p (#{value}) == RUBY_Qundef") != '0'
+        type_str = 'RUBY_T_UNDEF'
+      end
+    elsif @gdb.cmd_get_value("p (int)(#{value}) & RUBY_FIXNUM_FLAG") != '0'
+      # special consts
+      const = @gdb.cmd_get_value("p (enum ruby_special_consts)(#{value})")
+      # TODO: change to map
+      case const
+      when 'RUBY_Qnil'
+        type_str = 'RUBY_T_NIL'
+      when 'RUBY_Qfalse'
+        type_str = 'RUBY_T_FALSE'
+      end
+    else
+      # builtin type
+      type_str = @gdb.cmd_get_value("p (enum ruby_value_type)(((struct RBasic*)(#{value}))->flags & RUBY_T_MASK)")
+    end
+  end
+
+  def rstring_ptr(value_pointer)
+    no_embed = @gdb.cmd_get_value("p ((struct RBasic *)(#{value_pointer}))->flags & #{RSTRING_NOEMBED}")
+    if no_embed == '0'
+      # embedded in struct
+      @gdb.cmd_get_value("p (char *)((struct RString *)(#{value_pointer}))->as.ary")
+    else
+      # heap pointer
+      @gdb.cmd_get_value("p (char *)((struct RString *)(#{value_pointer}))->as.heap.ptr")
+    end
+  end
+
+  def rubyvm_cfunc_frame_p(cfp)
+    @gdb.cmd_get_value("p (#{cfp}->flag & #{VM_FRAME_MAGIC_MASK}) == #{VM_FRAME_MAGIC_CFUNC}") != '0'
+  end
+
+  def do_hash(key, table)
+    # NOTE: table->type->hash is always st_numhash
+    key
+  end
+
+  def st_lookup(table, key)
+    hash_val = do_hash(key, table)
+
+    raise if @gdb.cmd_get_value("p (#{table})->entries_packed") != '0'
+    raise if @gdb.cmd_get_value("p (#{table})->type->hash == st_numhash") == '0'
+    raise if @gdb.cmd_get_value("p (#{table})->type->compare == st_numcmp") == '0'
+
+    # TODO: check table->entries_packed
+    bin_pos = @gdb.cmd_get_value("p (#{hash_val}) % (#{table})->num_bins")
+
+    ptr = find_entry(table, key, hash_val, bin_pos)
+
+    if ptr.hex == 0
+      nil
+    else
+      value = @gdb.cmd_get_value("p ((struct st_table_entry *)(#{ptr}))->record")
+      value
+    end
+  end
+
+  def ptr_not_equal(table, ptr, hash_val, key)
+    ptr =~ /(0x[0-9a-f]+)\z/
+    ptr_num = $1.hex
+    t_hash = @gdb.cmd_get_value("p (#{ptr})->hash")
+    t_key = @gdb.cmd_get_value("p (#{ptr})->key")
+    # NOTE: table->type->compare is always st_numcmp
+    ptr_num != 0 and (t_hash != hash_val or t_key != key)
+  end
+
+  def find_entry(table, key, hash_val, bin_pos)
+    ptr = @gdb.cmd_get_value("p (#{table})->as.big.bins[#{bin_pos}]")
+    if ptr_not_equal(table, ptr, hash_val, key)
+      next_ptr = @gdb.cmd_get_value("p (#{ptr})->next")
+      while ptr_not_equal(table, next_ptr, hash_val, key)
+        ptr = next_ptr
+        next_ptr = @gdb.cmd_get_value("p (#{ptr})->next")
+      end
+      ptr = next_ptr
+    end
+    ptr =~ /(0x[0-9a-f]+)\z/
+    $1
+  end
+
+  def rb_id2str(id)
+    rstring_ptr(st_lookup('global_symbols.id_str', id))
+  end
+end
+
+class GDBRuby
+  MAX_FRAMES = 30
+
+  def initialize(config)
+    @config = config
+  end
+
+  def trace
+    @gdb = GDB.new(@config)
+    @ri = RubyInternal.new(@gdb)
+    puts "command:\n#{@gdb.exec_options.join(' ')}"
+    puts ''
+    @gdb.run do
+      show_environ if @config['env', true]
+      show_ruby_version
+      show_backtrace
+    end
+  end
+
+  def show_environ
+    i = 0
+    puts "environ:"
+    while true
+      response = @gdb.cmd_get_value("p ((char **)environ)[#{i}]")
+      break if response.empty? or response == '0x0'
+      puts response
+      i += 1
+    end
+    puts ''
+  end
+
+  def get_map_of_ruby_thread_pointer_to_gdb_thread_id
+    # After 'set pagination off' is executed,
+    # thread info is one line per thread.
+    map = {}
+    @gdb.cmd_exec('info threads').each_line do |line|
+      if line =~ /\A[\s\*]+(\d+)/
+        gdb_thread_id = $1
+        @gdb.cmd_exec("thread #{gdb_thread_id}")
+        @gdb.cmd_exec("backtrace").each_line do |bt_line|
+          if bt_line =~ /\(th=(0x[0-9a-f]+)/
+            ruby_thread_pointer = $1
+            map[ruby_thread_pointer] = gdb_thread_id
+            break
+          end
+        end
+      end
+    end
+    map
+  end
+
+  def get_ruby_frame(frame_count)
+    # Accessor
+    cfp = "(ruby_current_thread->cfp + #{frame_count})"
+    iseq = "#{cfp}->iseq"
+
+    # Check iseq
+    iseq_ptr = @gdb.cmd_get_pointer("p #{iseq}", 'rb_iseq_t')
+    if iseq_ptr.hex != 0
+      # TODO: check cfp->pc is null or not
+
+      iseq_type = @gdb.cmd_get_value("p #{iseq}->type").intern
+
+      case iseq_type
+      when :ISEQ_TYPE_TOP
+        return
+      end
+
+      # Ruby function
+      @prev_location = {
+        :cfp => cfp,
+        :iseq => iseq,
+      }
+      file_path = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.absolute_path"))
+      if file_path.empty?
+        file_path = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.path"))
+      end
+      label = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.label"))
+      base_label = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.base_label"))
+      line_no = @ri.rb_vm_get_sourceline(cfp, iseq)
+
+      self_value = @gdb.cmd_get_value("p #{cfp}->self")
+      self_type = @ri.rb_type(self_value)
+      self_name = self_type == 'RUBY_T_CLASS' ? @gdb.cmd_get_value("p rb_class2name(#{cfp}->self)") : ''
+
+      func_prefix = "#{self_name}#" unless self_name.empty?
+
+      {
+        :callee => label.empty? ? '(unknown)' : "#{func_prefix}#{label}",
+        :args => '', # TODO: implement
+        :source_path_line => "#{file_path}:#{line_no}",
+      }
+    elsif @ri.rubyvm_cfunc_frame_p(cfp)
+      # C function
+
+      mid = @gdb.cmd_get_value("p #{cfp}->me->def ? #{cfp}->me->def->original_id : #{cfp}->me->called_id")
+      label = @ri.rb_id2str(mid)
+      if @prev_location
+        cfp = @prev_location[:cfp]
+        iseq = @prev_location[:iseq]
+
+        file_path = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.absolute_path"))
+        if file_path.empty?
+          file_path = @ri.rstring_ptr(@gdb.cmd_get_value("p #{iseq}->location.path"))
+        end
+        line_no = @ri.rb_vm_get_sourceline(cfp, iseq)
+      end
+
+      {
+        :callee => label,
+        :args => '', # TODO: implement
+        :source_path_line => "#{file_path}:#{line_no}",
+      }
+    end
+  end
+
+  def check_ruby_version
+    @ruby_version = @gdb.cmd_get_value('p ruby_version')
+    case @ruby_version.intern
+    when :'2.0.0'
+    end
+    raise "unknown ruby version" unless @ruby_version
+  end
+
+  def show_ruby_version
+    check_ruby_version
+    puts 'ruby_version:'
+    puts @ruby_version
+    puts ''
+  end
+
+  def show_backtrace
+    # TODO: List threads with ruby_current_vm->living_threads and dump all threads.
+    #       Now, we dump only ruby_current_thread which is equivalent to ruby_current_vm->running_thread.
+
+    thread_map = get_map_of_ruby_thread_pointer_to_gdb_thread_id
+
+    # Detect ruby running thread and change gdb thread to it
+    current_thread_pointer = @gdb.cmd_get_pointer('p ruby_current_thread', 'rb_thread_t')
+    gdb_thread_id = thread_map[current_thread_pointer]
+    raise 'Cannot find current thread id in gdb' if gdb_thread_id.nil?
+    @gdb.cmd_exec("thread #{gdb_thread_id}")
+
+    # Show C backtrace
+    if @config['c_trace', true]
+      response = @gdb.cmd_exec('bt')
+      puts 'c_backtrace:'
+      response.each_line do |line|
+        break if line == '(gdb) '
+        puts line
+      end
+      puts ''
+    end
+
+    # Show Ruby backtrace
+    puts 'ruby_backtrace:'
+    cfp_count = @gdb.cmd_get_value('p (rb_control_frame_t *)(ruby_current_thread->stack + ruby_current_thread->stack_size) - ruby_current_thread->cfp').to_i
+
+    frame_infos = []
+    @prev_location = nil
+    # NOTE: @prev_location may not be set properly when limited by MAX_FRAMES
+    ([MAX_FRAMES, cfp_count].min - 1).downto(0).each do |count|
+      frame_info = get_ruby_frame(count)
+      frame_infos << frame_info if frame_info
+    end
+    frame_infos.reverse.each_with_index do |fi, i|
+      puts "[#{frame_infos.length - i}] #{fi[:callee]}(#{fi[:args]}) <- #{fi[:source_path_line]}"
+    end
+  end
+
+end
+
+def main
+  config = GDBRubyConfig.new(ARGV)
+  gdbruby = GDBRuby.new(config)
+  gdbruby.trace
+end
+
+main
+
+# vim: set expandtab ts=2 sw=2 nowrap ft=ruby ff=unix :

data/gdbruby.gemspec

@@ -0,0 +1,21 @@
+#! /usr/bin/env gem build
+# encoding: utf-8
+
+Gem::Specification.new do |gem|
+  gem.name          = 'gdbruby'
+  gem.version       = File.read(File.expand_path('VERSION', File.dirname(__FILE__))).chomp
+  gem.authors       = ["Tasuku SUENAGA"]
+  gem.email         = ["tasuku-s-github@titech.ac"]
+  gem.homepage      = "https://github.com/gunyarakun/gdbruby"
+  gem.summary       = "gdbperl for Ruby"
+  gem.description   = gem.summary
+  gem.licenses      = ["New BSD"]
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "rspec"
+end

data/spec/gdbruby_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'tempfile'
+
+EXECUTABLE = File.join(File.dirname(__FILE__), '..', 'bin', 'gdbruby.rb')
+TARGET = File.expand_path(File.join(File.dirname(__FILE__), 'target', 'call.rb'))
+
+describe 'gdbruby' do
+  describe 'execute' do
+    RESULT = <<EOF
+[13] sleep() <- #{TARGET}:42
+[12] Module1::Class1#block in method6() <- #{TARGET}:42
+[11] Module1::Class1#method7() <- #{TARGET}:47
+[10] Module1::Class1#method6() <- #{TARGET}:40
+[9] Module1::Class1#method5() <- #{TARGET}:35
+[8] Module1::Class1#rescue in method4() <- #{TARGET}:26
+[7] Module1::Class1#method4() <- #{TARGET}:23
+[6] Module1::Class1#method3() <- (eval):1
+[5] eval() <- #{TARGET}:17
+[4] Module1::Class1#method3() <- #{TARGET}:17
+[3] method2() <- #{TARGET}:12
+[2] method1() <- #{TARGET}:7
+[1] <main>() <- #{TARGET}:51
+EOF
+
+    before(:all) do
+      @target_pid = Kernel.spawn(TARGET, :pgroup => true, :out => '/dev/null', :err => '/dev/null')
+    end
+
+    context 'With live process' do
+      before(:all) do
+        @output = `#{EXECUTABLE} #{@target_pid}`
+      end
+
+      it 'should work' do
+        @output =~ /ruby_backtrace:\n(.+)\z/m
+        ruby_backtrace = $1
+        expect(ruby_backtrace).to eq(RESULT)
+      end
+    end
+
+    gcore_path = `which gcore`.chomp!
+    if File.executable?(gcore_path)
+      context 'With core file' do
+        before(:all) do
+          @core_path = Tempfile.new('core')
+          puts "target_pid: #{@target_pid}"
+          system('gcore', '-o', @core_path.path, @target_pid.to_s)
+          @output = `#{EXECUTABLE} #{@target_pid}`
+        end
+
+        it 'should work' do
+          @output =~ /ruby_backtrace:\n(.+)\z/m
+          ruby_backtrace = $1
+          expect(ruby_backtrace).to eq(RESULT)
+        end
+
+        after(:all) do
+          @core_path.close!
+        end
+      end
+    end
+
+    after(:all) do
+      Process.kill('KILL', @target_pid)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/target/call.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+# vim: set expandtab ts=2 sw=2 nowrap ft=ruby ff=unix : */
+
+puts Process.pid
+
+def method1(*args)
+  Module1::method2(*args)
+end
+
+module Module1
+  def self.method2(*args)
+    Class1::method3(*args)
+  end
+
+  class Class1
+    def self.method3(*args)
+      eval('method4(*args)')
+    end
+  end
+end
+
+def method4(*args)
+  begin
+    raise
+  rescue
+    method5(*args)
+  end
+end
+
+def method5(*args)
+  begin
+    raise
+  rescue
+  ensure
+    method6(*args)
+  end
+end
+
+def method6(*args)
+  method7(*args) do |*args|
+    p args
+    sleep(100)
+  end
+end
+
+def method7(*args)
+  yield *args
+end
+
+# TODO: test Struct, Bignum, File, Data, Match, Complex, Rational
+method1(
+  nil,
+  true,
+  false,
+  :symbol,
+  1,
+  Module1::Class1.new,
+  Module1::Class1,
+  Module1,
+  1.0,
+  'string',
+  /regex/,
+  ['array'],
+  { :hash => :value },
+)

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: gdbruby
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Tasuku SUENAGA
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: gdbperl for Ruby
+email:
+- tasuku-s-github@titech.ac
+executables:
+- gdbruby.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- bin/gdbruby.rb
+- gdbruby.gemspec
+- spec/gdbruby_spec.rb
+- spec/spec_helper.rb
+- spec/target/call.rb
+homepage: https://github.com/gunyarakun/gdbruby
+licenses:
+- New BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: gdbperl for Ruby
+test_files:
+- spec/gdbruby_spec.rb
+- spec/spec_helper.rb
+- spec/target/call.rb