gdbdump 0.1.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea50c60dac2189b7cea3222ddcf45ef8a351d203
-  data.tar.gz: df893c9a3c07006e1864358def10125388660f4d
+  metadata.gz: 806c8f4485ae5cfad83522a88e00ea3a625d7ed5
+  data.tar.gz: a125ef9b802bb4cece94f042a11340a3ca862296
 SHA512:
-  metadata.gz: 209d5cd21074e35b9b02a14a29b6ba396b8dfb03f66aaf76f34bc1e556f3f31fb7ffce4df202cbfd5321c2e4ac0b913356a89a6b7d140ea23d47a56217758c89
-  data.tar.gz: 4999fe00d9d43b77b4a330eeb57a7185a1dcb4b870d712ea8799ac9737da3dbf5cbff91addbcc5fdf6f7c2604a8e2d3a649705a545484d8646db408234476ea4
+  metadata.gz: 2e9373b1893dac6dad697b3eb95dca41e0f43d64b2400e136e9387850755152474e472e0c5038a1ee181e180dfb4e3e8d0bbb7d365bf263a8c2b973cc4e405e0
+  data.tar.gz: f2eb578d9859bbccd7149156bba3e1a35dcedb70dab66915597c6bbea807492c426e3da7b076d7588b8776f0c4c79c7bc9a51b01a3d77a6542ee5246c6031615

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+.ruby-version

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# 0.9.0
+
+Enhancements:
+
+* Use rb_ps defined in ruby trunk .gdbinit to
+  * get backtrace of all treads
+  * print backtrace to STDOUT of gdbdump process, rather than STDERR of the attached process
+* Use `sudo` to execute gdb command inside so that
+  * we can run as `$ gdbdump PID` rather than `$ sudo /path/to/ruby gdbdump PID`
+  * (previously, it was burdensome to use rbenv rubys and bundler via sudo)
+
+# 0.1.0
+
+First version
+
+* Use rb_backtrace (for ruby level backtrace) and rb_print_backtrace (for C level backtrace)

data/Gemfile

@@ -1,4 +1,4 @@
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in gdbdump.gemspec
 gemspec
+gem 'pry-nav'

data/README.md

@@ -1,64 +1,85 @@
-# Gdbdump
+# gdbdump
 
-Print C level and Ruby level backtrace of living process using gdb
+Print C level and Ruby level backtrace of living ruby process using gdb
 
 ## Installation
 
-    $ gem install gdbdump
+```
+$ gem install gdbdump
+```
 
 ## Requirements
 
-* run with sudo.
-* on Linux.
-
-I verified that this gem works with ruby executables built by [rbenv/ruby-build](https://github.com/rbenv/ruby-build).
+* gdb
+* linux
+* `sudo gdb` must be allowed
 
-## Example
+It was verfied that gdbdump works with ruby executables built by [rbenv/ruby-build](https://github.com/rbenv/ruby-build).
 
-With living ruby process of pid 1897,
+## Usage
 
 ```
-$ sudo gdbdump 1897
+Usage: gdbdump [options] [pid|prog pid]
+    -d, --[no-]debug   print debug log (default: false)
+    -x, --gdbinit FILE path to ruby trunk's .gdbinit (default: some of ruby trunk's .gdbinit is bundle in this gem, and used})
+        --gdb PATH     path to gdb command (default: gdb)
 ```
 
-You will see C and Ruby level backtrace on STDERR of **the target process** of pid 1897 as:
+### .gdbinit
 
-```
-== c backtrace ==
-/home/ubuntu/.rbenv/versions/2.4.1/bin/ruby(rb_print_backtrace+0x15) [0x7fd23062c115] vm_dump.c:684
-[0x7ffc98c378af]
-== ruby backtrace ==
-        from loop.rb:3:in `<main>'
-        from loop.rb:3:in `loop'
-        from loop.rb:5:in `block in <main>'
-        from loop.rb:5:in `sleep'
-```
+Default supported ruby versions: 2.3.0 - 2.4.1
 
-## Usage
+Ruby trunk's [.gdbinit](https://github.com/ruby/ruby/blob/trunk/.gdbinit) file defines useful helper functions and it is maintained by ruby core team. `gdbdump` uses it.
+Some versions of .gdbinit are bundled in this gem, but if you want to use `gdbdump` for older or newer ruby versions:
+
+1. Download .gdbinit from ruby repo like https://github.com/ruby/ruby/blob/v2_4_1/.gdbinit, and specify with `-x` option
+2. Or, send PR to bundle the .gdbinit in `gdbdump` gem.
+
+## Example
+
+With living ruby 2.4.1 process of pid 1897,
 
 ```
-Usage: gdbdump [options] [pid|prog pid]
-    -d, --[no-]debug                 print debug log (default: false)
+$ gdbdump 1897
 ```
 
-## How this work
+You will see C and Ruby level backtrace on STDERR of **the target process** of pid 1897 as:
 
-Attach to the ruby process with gdb, and call `rb_print_backtrace()` (C level backtrace) and `rb_backtrace()` (Ruby level backtrace). That's it.
+```
+$1 = (rb_vm_t *) 0x7f46bb071f20
+* #<Thread:0x7f46bb0a5ee8 rb_thread_t:0x7f46bb0725d0 native_thread:0x7f46ba514740>
+0x7f46ba16d700 <thread_join_m at thread.c:980>:in `join'
+loop.rb:17:in `<main>'
+* #<Thread:0x7f46bb202750 rb_thread_t:0x7f46bb3e03d0 native_thread:0x7f46b89c0700>
+0x7f46ba0e4f30 <rb_f_sleep at process.c:4388>:in `sleep'
+loop.rb:6:in `block (2 levels) in <main>'
+0x7f46ba1a72b0 <rb_f_loop at vm_eval.c:1137>:in `loop'
+loop.rb:4:in `block in <main>'
+* #<Thread:0x7f46bb202660 rb_thread_t:0x7f46bb3e47e0 native_thread:0x7f46b87be700>
+0x7f46ba0e4f30 <rb_f_sleep at process.c:4388>:in `sleep'
+loop.rb:13:in `block (2 levels) in <main>'
+0x7f46ba1a72b0 <rb_f_loop at vm_eval.c:1137>:in `loop'
+loop.rb:11:in `block in <main>'
+```
 
-The path of ruby executable is found by `/proc/[PID]/exe` as default.
+## FAQ
 
-## ToDo
+Q. How this work?
+A. Attach to the ruby process with gdb, and call `rb_ps` defined in gdbinit. That's it.
 
-* Want to print backtrace on STDOUT of gdbdump process.
-  * To do it, we need another version of `rb_print_backtrace` and `rb_backtrace` to print results into a file in CRuby itself.
-  * If they are available, gdbdump can dump to a file and, then read and print into STDOUT of gdbdump process.
+Q. Is this available for production process?
+A. GDB stops the process during printing backtrace, would cause some issues
 
 ## Comparisons
 
 * gdb
-  * You can get C level backtrace with raw gdb, of course.
+  * You can print C level backtrace with raw gdb, of course
 * [sigdump](https://github.com/frsyuki/sigdump)
-  * You can get ruby level backtrace with sigdump gem, but your ruby application must pre-install sigdump and `require 'sigdump/setup'`. `gdbdump` does not require it.
+  * sigdump enables to print ruby level backtrace with sending CONT signal to living ruby process.
+  * The ruby process must pre-install `sigdump` gem and `require 'sigdump/setup'` unlike gdbdump.
+* [gdbruby](https://github.com/gunyarakun/gdbruby)
+  * gdbruby enables to print C level and ruby level backtrace of living ruby process and core file.
+  * gdbruby must follow changes of C level interfaces of CRuby to get backtrace of the core file, it rises fragility that it will be broken on newer ruby versions.
 
 ## Development
 

data/example/loop.rb

@@ -0,0 +1,18 @@
+puts Process.pid
+
+th1 = Thread.new do
+  loop do
+    puts 'thread 1'
+    sleep 1
+  end
+end
+
+th2 = Thread.new do
+  loop do
+    puts 'thread 2'
+    sleep 1
+  end
+end
+
+th1.join
+th2.join

data/lib/gdbdump.rb

@@ -1,3 +1,8 @@
 require_relative "gdbdump/version"
+
+class Gdbdump
+  ROOT = File.dirname(File.dirname(__FILE__))
+end
+
 require_relative "gdbdump/gdb"
 require_relative "gdbdump/procfs"

data/lib/gdbdump/cli.rb

@@ -16,11 +16,19 @@ class Gdbdump
 
       opts = {
         debug: false,
+        gdbinit: nil,
+        gdb: nil,
       }
 
       op.on('-d', '--[no-]debug', "print debug log (default: #{opts[:debug]})") {|v|
         opts[:debug] = v
       }
+      op.on('-x', '--gdbinit FILE', "path to ruby trunk's .gdbinit (default: some of ruby trunk's .gdbinit is bundle in this gem, and used})") {|v|
+        opts[:gdbinit] = v
+      }
+      op.on('--gdb PATH', "path to gdb command (default: gdb)") {|v|
+        opts[:gdb] = v
+      }
 
       op.banner += ' [pid|prog pid]'
       begin
@@ -43,7 +51,7 @@ class Gdbdump
 
     def run
       parse_options
-      GDB.new(pid: @pid, prog: @prog, debug: @opts[:debug]).print_backtrace
+      GDB.new(pid: @pid, prog: @prog, **(@opts)).print_backtrace
     end
   end
 end

data/lib/gdbdump/gdb.rb

@@ -1,3 +1,4 @@
+# frozen-string-literal: true
 require 'open3'
 
 class Gdbdump
@@ -6,27 +7,36 @@ class Gdbdump
   # end
   class GDB
     COMMAND_READ_BUFFER_SIZE = 1024
+    STRINGS_CMD = 'strings'
+    SUDO_CMD = 'sudo'
 
-    def initialize(pid:, prog:, debug: false)
-      @prog = prog
+    def initialize(pid:, prog: nil, debug: false, gdbinit: nil, gdb: nil)
       @pid = pid.to_s
+      @prog = prog
       @debug = debug
-      @exec_options = ['gdb', '-silent', '-nw', @prog, @pid]
+      @gdbinit = gdbinit || File.join(ROOT, 'vendor', 'ruby', ruby_version, 'gdbinit')
+      @gdb = gdb || 'gdb'
+      @exec_options = [SUDO_CMD, @gdb, '-silent', '-nw', '-x', @gdbinit, @prog, @pid]
     end
 
     def print_backtrace
       run do |gdb|
-        gdb.cmd_exec('call write(2, "== c backtrace ==\n", 18)')
-        gdb.cmd_exec('call rb_print_backtrace()')
-        gdb.cmd_exec('call write(2, "== ruby backtrace ==\n", 21)')
-        gdb.cmd_exec('call rb_backtrace()')
+        out, err = gdb.cmd_exec('rb_ps')
+        $stdout.puts out
+        $stderr.puts err unless err.empty?
       end
+      # run do |gdb|
+      #   gdb.cmd_exec('call write(2, "== c backtrace ==\n", 18)')
+      #   gdb.cmd_exec('call rb_print_backtrace()')
+      #   gdb.cmd_exec('call write(2, "== ruby backtrace ==\n", 21)')
+      #   gdb.cmd_exec('call rb_backtrace()')
+      # end
     end
 
     def run
       @stdin, @stdout, @stderr = Open3.popen3(*@exec_options)
-      if get_response =~ /ptrace: Operation not permitted./
-        raise 'Must run gdbdump with sudo'
+      if get_response =~ /ptrace: Operation not permitted/
+        raise 'root privilege is required'
       end
       prepare
       begin
@@ -40,6 +50,15 @@ class Gdbdump
       end
     end
 
+    # ToDo: Any faster way to get ruby_version from pid?
+    # NOTE: I want ruby_version before starting gdb
+    def ruby_version
+      return @ruby_version if @ruby_version
+      ret = `#{STRINGS_CMD} #{@prog}`
+      line = ret.lines.find {|_| _.start_with?('RUBY_VERSION "') }
+      @ruby_version = line[14..-3] if line
+    end
+
     def cmd_exec(cmd)
       log('C', cmd)
       if cmd
@@ -52,18 +71,19 @@ class Gdbdump
     end
 
     def get_response
-      response = +''
-
+      out = +''
       loop do
         begin
           buf = @stdout.sysread(COMMAND_READ_BUFFER_SIZE)
         rescue EOFError
           break
         end
-        response << buf
         break if buf =~ /\(gdb\) $/
+        out << buf
       end
+      log('O', out)
 
+      err = +''
       loop do
         begin
           buf = @stderr.read_nonblock(COMMAND_READ_BUFFER_SIZE)
@@ -72,17 +92,16 @@ class Gdbdump
         rescue EOFError
           break
         end
-        response << buf if buf
+        err << buf if buf
       end
+      log('E', err)
 
-      log('R', response)
-      response
+      [out, err]
     end
 
     private
 
     def prepare
-      cmd_exec('')
       cmd_exec('set pagination off')
     end
 
@@ -93,6 +112,7 @@ class Gdbdump
 
     def log(pre, message)
       return unless @debug
+      return if message.nil? or message.empty?
       message.each_line do |line|
         puts "#{pre}: #{line}"
       end

data/lib/gdbdump/procfs.rb

@@ -8,9 +8,9 @@ class Gdbdump
 
     def exe
       begin
-        File.readlink("/proc/#{@pid}/exe")
+        @exe ||= File.readlink("/proc/#{@pid}/exe")
       rescue Errno::ENOENT
-        raise "/proc/#{@pid}/exe does not exist, it seems pid #{@pid} does not exit"
+        raise "/proc/#{@pid}/exe does not exist, it seems no process of pid #{@pid} exists"
       end
     end
   end

data/lib/gdbdump/version.rb

@@ -1,3 +1,3 @@
 class Gdbdump
-  VERSION = "0.1.0"
+  VERSION = "0.9.0"
 end

data/vendor/ruby/2.3.0/gdbinit

@@ -0,0 +1,966 @@
+define hook-run
+  set $color_type = 0
+  set $color_highlite = 0
+  set $color_end = 0
+end
+
+define ruby_gdb_init
+  if !$color_type
+    set $color_type = "\033[31m"
+  end
+  if !$color_highlite
+    set $color_highlite = "\033[36m"
+  end
+  if !$color_end
+    set $color_end = "\033[m"
+  end
+  if ruby_dummy_gdb_enums.special_consts
+  end
+end
+
+# set prompt \033[36m(gdb)\033[m\040
+
+define rp
+  ruby_gdb_init
+  if (VALUE)($arg0) & RUBY_FIXNUM_FLAG
+    printf "FIXNUM: %ld\n", (long)($arg0) >> 1
+  else
+  if ((VALUE)($arg0) & ~(~(VALUE)0<<RUBY_SPECIAL_SHIFT)) == RUBY_SYMBOL_FLAG
+    set $id = (($arg0) >> RUBY_SPECIAL_SHIFT)
+    printf "%sSYMBOL%s: ", $color_type, $color_end
+    rp_id $id
+  else
+  if ($arg0) == RUBY_Qfalse
+    echo false\n
+  else
+  if ($arg0) == RUBY_Qtrue
+    echo true\n
+  else
+  if ($arg0) == RUBY_Qnil
+    echo nil\n
+  else
+  if ($arg0) == RUBY_Qundef
+    echo undef\n
+  else
+  if (VALUE)($arg0) & RUBY_IMMEDIATE_MASK
+    if ((VALUE)($arg0) & RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG
+      printf "%sFLONUM%s: %g\n", $color_type, $color_end, (double)rb_float_value($arg0)
+    else
+      echo immediate\n
+    end
+  else
+  set $flags = ((struct RBasic*)($arg0))->flags
+  if ($flags & RUBY_FL_PROMOTED) == RUBY_FL_PROMOTED
+    printf "[PROMOTED] "
+  end
+  if ($flags & RUBY_T_MASK) == RUBY_T_NONE
+    printf "%sT_NONE%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_NIL
+    printf "%sT_NIL%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_OBJECT
+    printf "%sT_OBJECT%s: ", $color_type, $color_end
+    print (struct RObject *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_CLASS
+    printf "%sT_CLASS%s%s: ", $color_type, ($flags & RUBY_FL_SINGLETON) ? "*" : "", $color_end
+    rp_class $arg0
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_ICLASS
+    printf "%sT_ICLASS%s: ", $color_type, $color_end
+    rp_class $arg0
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_MODULE
+    printf "%sT_MODULE%s: ", $color_type, $color_end
+    rp_class $arg0
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_FLOAT
+    printf "%sT_FLOAT%s: %.16g ", $color_type, $color_end, (((struct RFloat*)($arg0))->float_value)
+    print (struct RFloat *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_STRING
+    printf "%sT_STRING%s: ", $color_type, $color_end
+    rp_string $arg0 $flags
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_REGEXP
+    set $regsrc = ((struct RRegexp*)($arg0))->src
+    set $rsflags = ((struct RBasic*)$regsrc)->flags
+    printf "%sT_REGEXP%s: ", $color_type, $color_end
+    set print address off
+    output (char *)(($rsflags & RUBY_FL_USER1) ? \
+      ((struct RString*)$regsrc)->as.heap.ptr : \
+      ((struct RString*)$regsrc)->as.ary)
+    set print address on
+    printf " len:%ld ", ($rsflags & RUBY_FL_USER1) ? \
+            ((struct RString*)$regsrc)->as.heap.len : \
+            (($rsflags & (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4|RUBY_FL_USER5|RUBY_FL_USER6)) >> RUBY_FL_USHIFT+2)
+    if $flags & RUBY_FL_USER6
+      printf "(none) "
+    end
+    if $flags & RUBY_FL_USER5
+      printf "(literal) "
+    end
+    if $flags & RUBY_FL_USER4
+      printf "(fixed) "
+    end
+    printf "encoding:%d ", ($flags & RUBY_ENCODING_MASK) >> RUBY_ENCODING_SHIFT
+    print (struct RRegexp *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_ARRAY
+    if ($flags & RUBY_FL_USER1)
+      set $len = (($flags & (RUBY_FL_USER3|RUBY_FL_USER4)) >> (RUBY_FL_USHIFT+3))
+      printf "%sT_ARRAY%s: len=%ld ", $color_type, $color_end, $len
+      printf "(embed) "
+      if ($len == 0)
+  printf "{(empty)} "
+      else
+  output/x *((VALUE*)((struct RArray*)($arg0))->as.ary) @ $len
+  printf " "
+      end
+    else
+      set $len = ((struct RArray*)($arg0))->as.heap.len
+      printf "%sT_ARRAY%s: len=%ld ", $color_type, $color_end, $len
+      if ($flags & RUBY_FL_USER2)
+  printf "(shared) shared="
+  output/x ((struct RArray*)($arg0))->as.heap.aux.shared
+  printf " "
+      else
+  printf "(ownership) capa=%ld ", ((struct RArray*)($arg0))->as.heap.aux.capa
+      end
+      if ($len == 0)
+  printf "{(empty)} "
+      else
+  output/x *((VALUE*)((struct RArray*)($arg0))->as.heap.ptr) @ $len
+  printf " "
+      end
+    end
+    print (struct RArray *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_FIXNUM
+    printf "%sT_FIXNUM%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_HASH
+    printf "%sT_HASH%s: ", $color_type, $color_end,
+    if ((struct RHash *)($arg0))->ntbl
+      printf "len=%ld ", ((struct RHash *)($arg0))->ntbl->num_entries
+    end
+    print (struct RHash *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_STRUCT
+    printf "%sT_STRUCT%s: len=%ld ", $color_type, $color_end, \
+      (($flags & (RUBY_FL_USER1|RUBY_FL_USER2)) ? \
+       ($flags & (RUBY_FL_USER1|RUBY_FL_USER2)) >> (RUBY_FL_USHIFT+1) : \
+       ((struct RStruct *)($arg0))->as.heap.len)
+    print (struct RStruct *)($arg0)
+    x/xw (($flags & (RUBY_FL_USER1|RUBY_FL_USER2)) ? \
+          ((struct RStruct *)($arg0))->as.ary : \
+          ((struct RStruct *)($arg0))->as.heap.ptr)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_BIGNUM
+    printf "%sT_BIGNUM%s: sign=%d len=%ld ", $color_type, $color_end, \
+      (($flags & RUBY_FL_USER1) != 0), \
+      (($flags & RUBY_FL_USER2) ? \
+       ($flags & (RUBY_FL_USER5|RUBY_FL_USER4|RUBY_FL_USER3)) >> (RUBY_FL_USHIFT+3) : \
+       ((struct RBignum*)($arg0))->as.heap.len)
+    if $flags & RUBY_FL_USER2
+      printf "(embed) "
+    end
+    print (struct RBignum *)($arg0)
+    x/xw (($flags & RUBY_FL_USER2) ? \
+          ((struct RBignum*)($arg0))->as.ary : \
+          ((struct RBignum*)($arg0))->as.heap.digits)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_RATIONAL
+    printf "%sT_RATIONAL%s: ", $color_type, $color_end
+    print (struct RRational *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_COMPLEX
+    printf "%sT_COMPLEX%s: ", $color_type, $color_end
+    print (struct RComplex *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_FILE
+    printf "%sT_FILE%s: ", $color_type, $color_end
+    print (struct RFile *)($arg0)
+    output *((struct RFile *)($arg0))->fptr
+    printf "\n"
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_TRUE
+    printf "%sT_TRUE%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_FALSE
+    printf "%sT_FALSE%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_DATA
+    if ((struct RTypedData *)($arg0))->typed_flag == 1
+      printf "%sT_DATA%s(%s): ", $color_type, $color_end, ((struct RTypedData *)($arg0))->type->wrap_struct_name
+      print (struct RTypedData *)($arg0)
+    else
+      printf "%sT_DATA%s: ", $color_type, $color_end
+      print (struct RData *)($arg0)
+    end
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_MATCH
+    printf "%sT_MATCH%s: ", $color_type, $color_end
+    print (struct RMatch *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_SYMBOL
+    printf "%sT_SYMBOL%s: ", $color_type, $color_end
+    print (struct RSymbol *)($arg0)
+    set $id_type = ((struct RSymbol *)($arg0))->id & RUBY_ID_SCOPE_MASK
+    if $id_type == RUBY_ID_LOCAL
+      printf "l"
+    else
+    if $id_type == RUBY_ID_INSTANCE
+      printf "i"
+    else
+    if $id_type == RUBY_ID_GLOBAL
+      printf "G"
+    else
+    if $id_type == RUBY_ID_ATTRSET
+      printf "a"
+    else
+    if $id_type == RUBY_ID_CONST
+      printf "C"
+    else
+    if $id_type == RUBY_ID_CLASS
+      printf "c"
+    else
+      printf "j"
+    end
+    end
+    end
+    end
+    end
+    end
+    set $id_fstr = ((struct RSymbol *)($arg0))->fstr
+    rp_string $id_fstr
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_UNDEF
+    printf "%sT_UNDEF%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_IMEMO
+    printf "%sT_IMEMO%s(", $color_type, $color_end
+    output (enum imemo_type)(($flags>>RUBY_FL_USHIFT)&imemo_mask)
+    printf "): "
+    rp_imemo $arg0
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_NODE
+    printf "%sT_NODE%s(", $color_type, $color_end
+    output (enum node_type)(($flags&RUBY_NODE_TYPEMASK)>>RUBY_NODE_TYPESHIFT)
+    printf "): "
+    print *(NODE *)($arg0)
+  else
+  if ($flags & RUBY_T_MASK) == RUBY_T_ZOMBIE
+    printf "%sT_ZOMBIE%s: ", $color_type, $color_end
+    print (struct RData *)($arg0)
+  else
+    printf "%sunknown%s: ", $color_type, $color_end
+    print (struct RBasic *)($arg0)
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+end
+document rp
+  Print a Ruby's VALUE.
+end
+
+define rp_id
+  set $id = (ID)$arg0
+  if $id == '!' || $id == '+' || $id == '-' || $id == '*' || $id == '/' || $id == '%' || $id == '<' || $id == '>' || $id == '`'
+    printf "(:%c)\n", $id
+  else
+  if $id == idDot2
+    printf "(:..)\n"
+  else
+  if $id == idDot3
+    printf "(:...)\n"
+  else
+  if $id == idUPlus
+    printf "(:+@)\n"
+  else
+  if $id == idUMinus
+    printf "(:-@)\n"
+  else
+  if $id == idPow
+    printf "(:**)\n"
+  else
+  if $id == idCmp
+    printf "(:<=>)\n"
+  else
+  if $id == idLTLT
+    printf "(:<<)\n"
+  else
+  if $id == idLE
+    printf "(:<=)\n"
+  else
+  if $id == idGE
+    printf "(:>=)\n"
+  else
+  if $id == idEq
+    printf "(:==)\n"
+  else
+  if $id == idEqq
+    printf "(:===)\n"
+  else
+  if $id == idNeq
+    printf "(:!=)\n"
+  else
+  if $id == idEqTilde
+    printf "(:=~)\n"
+  else
+  if $id == idNeqTilde
+    printf "(:!~)\n"
+  else
+  if $id == idAREF
+    printf "(:[])\n"
+  else
+  if $id == idASET
+    printf "(:[]=)\n"
+  else
+    if $id <= tLAST_OP_ID
+      printf "O"
+    else
+      set $id_type = $id & RUBY_ID_SCOPE_MASK
+      if $id_type == RUBY_ID_LOCAL
+        printf "l"
+      else
+      if $id_type == RUBY_ID_INSTANCE
+        printf "i"
+      else
+      if $id_type == RUBY_ID_GLOBAL
+        printf "G"
+      else
+      if $id_type == RUBY_ID_ATTRSET
+        printf "a"
+      else
+      if $id_type == RUBY_ID_CONST
+        printf "C"
+      else
+      if $id_type == RUBY_ID_CLASS
+        printf "c"
+      else
+        printf "j"
+      end
+      end
+      end
+      end
+      end
+      end
+    end
+    printf "(%ld): ", $id
+    set $str = lookup_id_str($id)
+    if $str
+      rp_string $str
+    else
+      echo undef\n
+    end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+  end
+end
+document rp_id
+  Print an ID.
+end
+
+define rp_string
+  set $flags = ((struct RBasic*)($arg0))->flags
+  set print address off
+  output (char *)(($flags & RUBY_FL_USER1) ? \
+      ((struct RString*)($arg0))->as.heap.ptr : \
+      ((struct RString*)($arg0))->as.ary)
+  set print address on
+  printf " bytesize:%ld ", ($flags & RUBY_FL_USER1) ? \
+          ((struct RString*)($arg0))->as.heap.len : \
+          (($flags & (RUBY_FL_USER2|RUBY_FL_USER3|RUBY_FL_USER4|RUBY_FL_USER5|RUBY_FL_USER6)) >> RUBY_FL_USHIFT+2)
+  if !($flags & RUBY_FL_USER1)
+    printf "(embed) "
+  else
+    if ($flags & RUBY_FL_USER2)
+      printf "(shared) "
+    end
+    if ($flags & RUBY_FL_USER3)
+      printf "(assoc) "
+    end
+  end
+  printf "encoding:%d ", ($flags & RUBY_ENCODING_MASK) >> RUBY_ENCODING_SHIFT
+  if ($flags & RUBY_ENC_CODERANGE_MASK) == 0
+    printf "coderange:unknown "
+  else
+  if ($flags & RUBY_ENC_CODERANGE_MASK) == RUBY_ENC_CODERANGE_7BIT
+    printf "coderange:7bit "
+  else
+  if ($flags & RUBY_ENC_CODERANGE_MASK) == RUBY_ENC_CODERANGE_VALID
+    printf "coderange:valid "
+  else
+    printf "coderange:broken "
+  end
+  end
+  end
+  print (struct RString *)($arg0)
+end
+document rp_string
+  Print the content of a String.
+end
+
+define rp_class
+  printf "(struct RClass *) %p", (void*)$arg0
+  if ((struct RClass *)($arg0))->ptr.origin_ != $arg0
+    printf " -> %p", ((struct RClass *)($arg0))->ptr.origin_
+  end
+  printf "\n"
+  rb_classname $arg0
+  print *(struct RClass *)($arg0)
+  print *((struct RClass *)($arg0))->ptr
+end
+document rp_class
+  Print the content of a Class/Module.
+end
+
+define rp_imemo
+  set $flags = (((struct RBasic *)($arg0))->flags >> RUBY_FL_USHIFT) & imemo_mask
+  if $flags == imemo_cref
+    printf "(rb_cref_t *) %p\n", (void*)$arg0
+    print *(rb_cref_t *)$arg0
+  else
+  if $flags == imemo_svar
+    printf "(struct vm_svar *) %p\n", (void*)$arg0
+    print *(struct vm_svar *)$arg0
+  else
+  if $flags == imemo_throw_data
+    printf "(struct vm_throw_data *) %p\n", (void*)$arg0
+    print *(struct vm_throw_data *)$arg0
+  else
+  if $flags == imemo_ifunc
+    printf "(struct vm_ifunc *) %p\n", (void*)$arg0
+    print *(struct vm_ifunc *)$arg0
+  else
+  if $flags == imemo_memo
+    printf "(struct MEMO *) %p\n", (void*)$arg0
+    print *(struct MEMO *)$arg0
+  else
+    printf "(struct RIMemo *) %p\n", (void*)$arg0
+    print *(struct RIMemo *)$arg0
+  end
+  end
+  end
+  end
+  end
+end
+document rp_imemo
+  Print the content of a memo
+end
+
+define nd_type
+  print (enum node_type)((((NODE*)($arg0))->flags&RUBY_NODE_TYPEMASK)>>RUBY_NODE_TYPESHIFT)
+end
+document nd_type
+  Print a Ruby' node type.
+end
+
+define nd_file
+  print ((NODE*)($arg0))->nd_file
+end
+document nd_file
+  Print the source file name of a node.
+end
+
+define nd_line
+  print ((unsigned int)((((NODE*)($arg0))->flags>>RUBY_NODE_LSHIFT)&RUBY_NODE_LMASK))
+end
+document nd_line
+  Print the source line number of a node.
+end
+
+# Print members of ruby node.
+
+define nd_head
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_alen
+  printf "%su2.argc%s: ", $color_highlite, $color_end
+  p ($arg0).u2.argc
+end
+
+define nd_next
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_cond
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_body
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+define nd_else
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_orig
+  printf "%su3.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.value
+end
+
+
+define nd_resq
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+define nd_ensr
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_1st
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_2nd
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+
+define nd_stts
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+
+define nd_entry
+  printf "%su3.entry%s: ", $color_highlite, $color_end
+  p ($arg0).u3.entry
+end
+
+define nd_vid
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_cflag
+  printf "%su2.id%s: ", $color_highlite, $color_end
+  p ($arg0).u2.id
+end
+
+define nd_cval
+  printf "%su3.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.value
+end
+
+
+define nd_cnt
+  printf "%su3.cnt%s: ", $color_highlite, $color_end
+  p ($arg0).u3.cnt
+end
+
+define nd_tbl
+  printf "%su1.tbl%s: ", $color_highlite, $color_end
+  p ($arg0).u1.tbl
+end
+
+
+define nd_var
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_ibdy
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+define nd_iter
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_value
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+define nd_aid
+  printf "%su3.id%s: ", $color_highlite, $color_end
+  p ($arg0).u3.id
+end
+
+
+define nd_lit
+  printf "%su1.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.value
+end
+
+
+define nd_frml
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_rest
+  printf "%su2.argc%s: ", $color_highlite, $color_end
+  p ($arg0).u2.argc
+end
+
+define nd_opt
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+
+define nd_recv
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_mid
+  printf "%su2.id%s: ", $color_highlite, $color_end
+  p ($arg0).u2.id
+end
+
+define nd_args
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_noex
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_defn
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_old
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_new
+  printf "%su2.id%s: ", $color_highlite, $color_end
+  p ($arg0).u2.id
+end
+
+
+define nd_cfnc
+  printf "%su1.cfunc%s: ", $color_highlite, $color_end
+  p ($arg0).u1.cfunc
+end
+
+define nd_argc
+  printf "%su2.argc%s: ", $color_highlite, $color_end
+  p ($arg0).u2.argc
+end
+
+
+define nd_cname
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_super
+  printf "%su3.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u3.node
+end
+
+
+define nd_modl
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_clss
+  printf "%su1.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.value
+end
+
+
+define nd_beg
+  printf "%su1.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u1.node
+end
+
+define nd_end
+  printf "%su2.node%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.node
+end
+
+define nd_state
+  printf "%su3.state%s: ", $color_highlite, $color_end
+  p ($arg0).u3.state
+end
+
+define nd_rval
+  printf "%su2.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.value
+end
+
+
+define nd_nth
+  printf "%su2.argc%s: ", $color_highlite, $color_end
+  p ($arg0).u2.argc
+end
+
+
+define nd_tag
+  printf "%su1.id%s: ", $color_highlite, $color_end
+  p ($arg0).u1.id
+end
+
+define nd_tval
+  printf "%su2.value%s: ", $color_highlite, $color_end
+  rp ($arg0).u2.value
+end
+
+define nd_tree
+  set $buf = (struct RString *)rb_str_buf_new(0)
+  call dump_node((VALUE)($buf), rb_str_new(0, 0), 0, ($arg0))
+  printf "%s\n", $buf->as.heap.ptr
+end
+
+define rb_p
+  call rb_p($arg0)
+end
+
+define rb_numtable_entry
+  set $rb_numtable_tbl = $arg0
+  set $rb_numtable_id = (st_data_t)$arg1
+  set $rb_numtable_key = 0
+  set $rb_numtable_rec = 0
+  if $rb_numtable_tbl->entries_packed
+    set $rb_numtable_p = $rb_numtable_tbl->as.packed.bins
+    while $rb_numtable_p && $rb_numtable_p < $rb_numtable_tbl->as.packed.bins+$rb_numtable_tbl->num_entries
+      if $rb_numtable_p.k == $rb_numtable_id
+  set $rb_numtable_key = $rb_numtable_p.k
+  set $rb_numtable_rec = $rb_numtable_p.v
+  set $rb_numtable_p = 0
+      else
+  set $rb_numtable_p = $rb_numtable_p + 1
+      end
+    end
+  else
+    set $rb_numtable_p = $rb_numtable_tbl->as.big.bins[st_numhash($rb_numtable_id) % $rb_numtable_tbl->num_bins]
+    while $rb_numtable_p
+      if $rb_numtable_p->key == $rb_numtable_id
+  set $rb_numtable_key = $rb_numtable_p->key
+  set $rb_numtable_rec = $rb_numtable_p->record
+  set $rb_numtable_p = 0
+      else
+  set $rb_numtable_p = $rb_numtable_p->next
+      end
+    end
+  end
+end
+
+define rb_id2name
+  ruby_gdb_init
+  printf "%sID%s: ", $color_type, $color_end
+  rp_id $arg0
+end
+document rb_id2name
+  Print the name of id
+end
+
+define rb_method_entry
+  set $rb_method_entry_klass = (struct RClass *)$arg0
+  set $rb_method_entry_id = (ID)$arg1
+  set $rb_method_entry_me = (rb_method_entry_t *)0
+  while !$rb_method_entry_me && $rb_method_entry_klass
+    rb_numtable_entry $rb_method_entry_klass->m_tbl_wrapper->tbl $rb_method_entry_id
+    set $rb_method_entry_me = (rb_method_entry_t *)$rb_numtable_rec
+    if !$rb_method_entry_me
+      set $rb_method_entry_klass = (struct RClass *)RCLASS_SUPER($rb_method_entry_klass)
+    end
+  end
+  if $rb_method_entry_me
+    print *$rb_method_entry_klass
+    print *$rb_method_entry_me
+  else
+    echo method not found\n
+  end
+end
+document rb_method_entry
+  Search method entry by class and id
+end
+
+define rb_classname
+  # up to 128bit int
+  set $rb_classname_permanent = "0123456789ABCDEF"
+  set $rb_classname = classname($arg0, $rb_classname_permanent)
+  if $rb_classname != RUBY_Qnil
+    rp $rb_classname
+  else
+    echo anonymous class/module\n
+  end
+end
+
+define rb_ancestors
+  set $rb_ancestors_module = $arg0
+  while $rb_ancestors_module
+    rp_class $rb_ancestors_module
+    set $rb_ancestors_module = RCLASS_SUPER($rb_ancestors_module)
+  end
+end
+document rb_ancestors
+  Print ancestors.
+end
+
+define rb_backtrace
+  call rb_backtrace()
+end
+
+define iseq
+  if ruby_dummy_gdb_enums.special_consts
+  end
+  if ($arg0)->type == ISEQ_ELEMENT_NONE
+    echo [none]\n
+  end
+  if ($arg0)->type == ISEQ_ELEMENT_LABEL
+    print *(LABEL*)($arg0)
+  end
+  if ($arg0)->type == ISEQ_ELEMENT_INSN
+    print *(INSN*)($arg0)
+    if ((INSN*)($arg0))->insn_id != YARVINSN_jump
+      set $i = 0
+      set $operand_size = ((INSN*)($arg0))->operand_size
+      set $operands = ((INSN*)($arg0))->operands
+      while $i < $operand_size
+  rp $operands[$i++]
+      end
+    end
+  end
+  if ($arg0)->type == ISEQ_ELEMENT_ADJUST
+    print *(ADJUST*)($arg0)
+  end
+end
+
+define rb_ps
+  rb_ps_vm ruby_current_vm
+end
+document rb_ps
+Dump all threads and their callstacks
+end
+
+define rb_ps_vm
+  print $ps_vm = (rb_vm_t*)$arg0
+  set $ps_thread_ln = $ps_vm->living_threads.n.next
+  set $ps_thread_ln_last = $ps_vm->living_threads.n.prev
+  while 1
+    set $ps_thread_th = (rb_thread_t *)$ps_thread_ln
+    set $ps_thread = (VALUE)($ps_thread_th->self)
+    rb_ps_thread $ps_thread
+    if $ps_thread_ln == $ps_thread_ln_last
+      loop_break
+    end
+    set $ps_thread_ln = $ps_thread_ln->next
+  end
+end
+document rb_ps_vm
+Dump all threads in a (rb_vm_t*) and their callstacks
+end
+
+define rb_ps_thread
+  set $ps_thread = (struct RTypedData*)$arg0
+  set $ps_thread_th = (rb_thread_t*)$ps_thread->data
+  printf "* #<Thread:%p rb_thread_t:%p native_thread:%p>\n", \
+    $ps_thread, $ps_thread_th, $ps_thread_th->thread_id
+end
+
+# Details: https://bugs.ruby-lang.org/projects/ruby-trunk/wiki/MachineInstructionsTraceWithGDB
+define trace_machine_instructions
+  set logging on
+  set height 0
+  set width 0
+  display/i $pc
+  while !$exit_code
+    info line *$pc
+    si
+  end
+end
+
+define SDR
+  call rb_vmdebug_stack_dump_raw_current()
+end
+
+define rbi
+  if ((LINK_ELEMENT*)$arg0)->type == ISEQ_ELEMENT_LABEL
+    p *(LABEL*)$arg0
+  else
+  if ((LINK_ELEMENT*)$arg0)->type == ISEQ_ELEMENT_INSN
+    p *(INSN*)$arg0
+  else
+  if ((LINK_ELEMENT*)$arg0)->type == ISEQ_ELEMENT_ADJUST
+    p *(ADJUST*)$arg0
+  else
+    print *$arg0
+  end
+  end
+  end
+end