heap_dump 0.0.29 → 0.0.30

data/README.md

@@ -4,7 +4,7 @@ Low-level ruby heap memory dump - including data and code references, useful for
 Has no performance overhead while not active, so can be used in production environment.
 
 Originally written across ruby 1.9.2-p290 data structures.
-Does work on other 1.9.2s and 1.9.3, but not well-tested yet(output is not proven to be as full etc.).
+Does work on other 1.9.2s, 1.9.3 and 2.0.0-preview1, but not well-tested yet(output is not proven to be as full etc.).
 
 Currently is under development and output format may differ.
 

data/ext/heap_dump/extconf.rb

@@ -1,6 +1,20 @@
 #!/usr/bin/env ruby
 #encoding: utf-8
 
+# autodetect ruby headers
+unless ARGV.any? {|arg| arg.include?('--with-ruby-include') }
+  require 'rbconfig'
+  bindir = RbConfig::CONFIG['bindir']
+  if bindir =~ %r{(^.*/\.rbenv/versions)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-1.9.1/ruby-#{$2}"
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  elsif bindir =~ %r{(^.*/\.rvm/rubies)/([^/]+)/bin$}
+    ruby_include = "#{$1}/#{$2}/include/ruby-1.9.1/#{$2}"
+    ruby_include = "#{ENV['rvm_path']}/src/#{$2}" unless File.exist?(ruby_include)
+    ARGV << "--with-ruby-include=#{ruby_include}"
+  end
+end
+
 require 'mkmf'
 require 'debugger/ruby_core_source'
 
@@ -50,13 +64,32 @@ hdrs = proc {
   %w{
     constant.h
     internal.h
+    gc.h
     }.each{|h| have_header(h)}
 
+  have_struct_member("rb_iseq_t", "filename", "vm_core.h")
+  have_struct_member("rb_binding_t", "filename", "vm_core.h")
+  have_struct_member("rb_control_frame_t", "bp", "vm_core.h")
+  have_struct_member("rb_thread_t", "thrown_errinfo", "vm_core.h")
+  have_struct_member("rb_event_hook_t", "data", "vm_core.h")
+  
+
+
+  have_struct_member("rb_iseq_t", "location", "vm_core.h")
+  #have_struct_member("rb_iseq_location_t", "filename", "vm_core.h")
+  have_struct_member("rb_block_t", "klass", "vm_core.h")
+  have_struct_member("rb_block_t", "lfp", "vm_core.h")
+
   res
 }
 
 dir_config("ruby") # allow user to pass in non-standard core include directory
 
 if !Debugger::RubyCoreSource::create_makefile_with_core(hdrs, "heap_dump")
+  STDERR.print("Makefile creation failed\n")
+  STDERR.print("*************************************************************\n\n")
+  STDERR.print("  NOTE: If your headers were not found, try passing\n")
+  STDERR.print("        --with-ruby-include=PATH_TO_HEADERS      \n\n")
+  STDERR.print("*************************************************************\n\n")
   exit(1)
 end

data/ext/heap_dump/heap_dump.c

@@ -16,6 +16,10 @@
 // #include "atomic.h"
 #include "iseq.h"
 
+#ifdef HAVE_GC_H
+#include "gc.h"
+#endif
+
 #ifdef HAVE_INTERNAL_H
 #include "internal.h"
 #else
@@ -66,9 +70,9 @@ static ID classid;
 
 //shortcuts to yajl
 #define YAJL ctx->yajl
-#define yg_string(str,len) yajl_gen_string(YAJL, str, len)
-#define yg_cstring(str) yg_string(str, (unsigned int)strlen(str))
-#define yg_rstring(str) yg_string(RSTRING_PTR(str), (unsigned int)RSTRING_LEN(str))
+#define yg_string(str,len) yajl_gen_string(YAJL, (const unsigned char *)(str), (unsigned int)(len))
+#define yg_cstring(str) yg_string(str, strlen(str))
+#define yg_rstring(str) yg_string(RSTRING_PTR(str), RSTRING_LEN(str))
 #define yg_int(i) yajl_gen_integer(YAJL, i)
 #define yg_double(d) (yajl_gen_double(YAJL, d)==yajl_gen_invalid_number? yg_cstring("inf|NaN") : true)
 #define yg_null() yajl_gen_null(YAJL)
@@ -135,11 +139,6 @@ static inline const char* rb_type_str(int type){
   }
 }
 
-static inline const char* rb_builtin_type(VALUE obj){
-  //NOTE: only for heap objects, on embedded use (TYPE(...))
-  return rb_type_str(BUILTIN_TYPE(obj));
-}
-
 #define true 1
 #define false 0
 
@@ -565,9 +564,20 @@ static const char* iseq_type(VALUE type){
 }
 
 static void dump_iseq(const rb_iseq_t* iseq, walk_ctx_t *ctx){
+  int i;
+#ifdef HAVE_RB_ISEQ_T_FILENAME
   if(iseq->name) ygh_rstring("name", iseq->name);
   if(iseq->filename) ygh_rstring("filename", iseq->filename);
   ygh_int("line", FIX2LONG(iseq->line_no));
+#else
+  #ifdef HAVE_RB_ISEQ_T_LOCATION
+    if(iseq->location.label) ygh_rstring("name", iseq->location.label);
+    if(iseq->location.path) ygh_rstring("filename", iseq->location.path);
+    //base_label usually(always?)==label
+    // if(iseq->location.base_label) ygh_rstring("base_label", iseq->location.base_label);
+    ygh_int("line", FIX2LONG(iseq->location.first_lineno));
+  #endif
+#endif
 
   //if(iseq->type != 25116) //also 28 in mark_ary
   ygh_cstring("type", iseq_type(iseq->type));
@@ -581,12 +591,11 @@ static void dump_iseq(const rb_iseq_t* iseq, walk_ctx_t *ctx){
   ygh_id("klass", iseq->klass);
   ygh_id("cref_stack", (VALUE)iseq->cref_stack); //NODE*
 
-  ID id = iseq->defined_method_id;
   yg_cstring("defined_method_id");
-  if(id && id != ID_ALLOCATOR){
-    yg_cstring(rb_id2name(id)); // symbol=ID2SYM(id);
+  if(iseq->defined_method_id && iseq->defined_method_id != ID_ALLOCATOR){
+    yg_cstring(rb_id2name(iseq->defined_method_id));
   } else {
-    yg_int(id);
+    yg_int(iseq->defined_method_id);
   }
 
   if (iseq->compile_data != 0) {
@@ -599,9 +608,8 @@ static void dump_iseq(const rb_iseq_t* iseq, walk_ctx_t *ctx){
   if(iseq->local_table_size > 0){
     yg_cstring("local_table");
     yg_array();
-    int i;
     for(i = 0; i < iseq->local_table_size; i++){
-      char* name = rb_id2name(iseq->local_table[i]);
+      const char* name = rb_id2name(iseq->local_table[i]);
       if(name){
         yg_cstring(name);
       } else {
@@ -632,11 +640,17 @@ static void dump_block(const rb_block_t* block, walk_ctx_t *ctx){
 
   ygh_id("self", block->self);
 
+#ifdef HAVE_RB_BLOCK_T_LFP
   //FIXME: these are pointers to some memory, may be dumped more clever
   ygh_id("lfp", (VALUE)block->lfp);
   ygh_id("dfp", (VALUE)block->dfp);
   //lfp = local frame pointer? local_num elems?
   // dfp = ?
+#endif
+#ifdef HAVE_RB_BLOCK_T_KLASS
+  ygh_id("class", (VALUE)block->klass);
+  //TODO: VALUE*ep = ?
+#endif
 }
 
 
@@ -672,7 +686,7 @@ static void dump_locations(VALUE* p, long int n, walk_ctx_t *ctx){
 static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx);
 
 
-vm_dump_each_thread_func(st_data_t key, VALUE obj, walk_ctx_t *ctx){
+static int vm_dump_each_thread_func(st_data_t key, VALUE obj, walk_ctx_t *ctx){
   //here stored 'self' from thread
   // yg_map();
   ygh_id("id", obj);
@@ -758,16 +772,20 @@ static void dump_data_if_known(VALUE obj, walk_ctx_t *ctx){
     rb_binding_t *bind = RTYPEDDATA_DATA(obj);
     if(!bind) return;
     ygh_id("env", bind->env);
+    #ifdef HAVE_RB_BINDING_T_FILENAME
     ygh_id("filename", bind->filename);
+    ygh_int("line", bind->line_no);
+    #else
+    ygh_id("filename", bind->path);
+    ygh_int("line", bind->first_lineno);
+    #endif
     return;
   }
 
   if(!strcmp("VM/env", typename)){
     const rb_env_t* env = RTYPEDDATA_DATA(obj);
-    int i = 0;
     yg_cstring("env");
     yajl_gen_array_open(ctx->yajl);
-    //for(; i < env->env_size; i++) yg_id(env->env[i]);
     dump_locations(env->env, env->env_size, ctx);
     yajl_gen_array_close(ctx->yajl);
 
@@ -891,7 +909,7 @@ static void dump_data_if_known(VALUE obj, walk_ctx_t *ctx){
     // rb_gc_mark(tobj->vtm.subsecx);
     // rb_gc_mark(tobj->vtm.utc_offset);
     VALUE flt = rb_funcall(obj, rb_intern("to_f"), 0);
-    if(BUILTIN_TYPE(flt) == T_FLOAT){ ygh_double("val", RFLOAT_VALUE(flt)); }
+    if(TYPE(flt) == T_FLOAT){ ygh_double("val", NUM2DBL(flt)); }
     return;
   }
 
@@ -920,11 +938,13 @@ static VALUE rb_class_real_checked(VALUE cl)
 }
 
 static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
+  //note: BUILTIN_TYPE is only for heap, for embedded use TYPE
+  const int bt_type = BUILTIN_TYPE(obj);
   ctx->live_objects++;
   yajl_gen_map_open(ctx->yajl);
 
   ygh_int("id", NUM2LONG(rb_obj_id(obj)));
-  ygh_cstring("bt", rb_builtin_type(obj));
+  ygh_cstring("bt", rb_type_str(bt_type));
 
   //TODO:
   #ifdef GC_DEBUG
@@ -938,8 +958,6 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
   // if (FL_TEST(obj, FL_EXIVAR) || rb_special_const_p(obj))
   // return generic_ivar_get(obj, id, warn);
 
-  const int bt_type = BUILTIN_TYPE(obj);
-
   // for generic types ivars are held separately in a table
   if(bt_type != T_OBJECT && bt_type != T_CLASS && bt_type != T_MODULE && bt_type != T_ICLASS){
     st_table* generic_tbl = rb_generic_ivar_table(obj);
@@ -1151,10 +1169,11 @@ static inline void walk_live_object(VALUE obj, walk_ctx_t *ctx){
  *   vend: a pointer to next to the valid heap_slot area.
  *   stride: a distance to next VALUE.
 */
-static int objspace_walker(void *vstart, void *vend, int stride, walk_ctx_t *ctx) {
+static int objspace_walker(void *vstart, void *vend, size_t stride, void* data) {
+  VALUE v = (VALUE)vstart;
+  walk_ctx_t *ctx = data;
   ctx->walker_called++;
 
-  VALUE v = (VALUE)vstart;
   for (; v != (VALUE)vend; v += stride) {
     if (RBASIC(v)->flags) { // is live object
       walk_live_object(v, ctx);
@@ -1165,18 +1184,8 @@ static int objspace_walker(void *vstart, void *vend, int stride, walk_ctx_t *ctx
 }
 
 
-//TODO: move to separate header.
-/*
-  Bits of code taken directly from ruby gc
-  Copyright (C) 1993-2007 Yukihiro Matsumoto
-  Copyright (C) 2000  Network Applied Communication Laboratory, Inc.
-  Copyright (C) 2000  Information-technology Promotion Agency, Japan
-*/
-// #if defined(__x86_64__) && defined(__GNUC__) && !defined(__native_client__)
-// #define SET_MACHINE_STACK_END(p) __asm__("movq\t%%rsp, %0" : "=r" (*(p)))
-// #elif defined(__i386) && defined(__GNUC__) && !defined(__native_client__)
-// #define SET_MACHINE_STACK_END(p) __asm__("movl\t%%esp, %0" : "=r" (*(p)))
-// #else
+//TODO: move to separate header?
+#ifndef SET_MACHINE_STACK_END
 NOINLINE(static void rb_gc_set_stack_end(VALUE **stack_end_p));
 #define SET_MACHINE_STACK_END(p) rb_gc_set_stack_end(p)
 #define USE_CONSERVATIVE_STACK_END
@@ -1187,6 +1196,7 @@ rb_gc_set_stack_end(VALUE **stack_end_p)
     VALUE stack_end;
     *stack_end_p = &stack_end;
 }
+#endif
 
 #ifdef __ia64
 #define SET_STACK_END (SET_MACHINE_STACK_END(&th->machine_stack_end), th->machine_register_stack_end = rb_ia64_bsp())
@@ -1234,7 +1244,6 @@ ruby_get_stack_grow_direction(volatile VALUE *addr)
 
 #define numberof(array) (int)(sizeof(array) / sizeof((array)[0]))
 
-
 /////////////
 
 
@@ -1251,8 +1260,10 @@ static int
 dump_backtrace(void* data, VALUE file, int line, VALUE method, int argc, VALUE* argv)
 {
     walk_ctx_t *ctx = data;
-    yg_map();
     const char *filename = NIL_P(file) ? "<ruby>" : RSTRING_PTR(file);
+    int i;
+
+    yg_map();
 
     ygh_cstring("file", filename);
     ygh_int("line", line);
@@ -1268,7 +1279,6 @@ dump_backtrace(void* data, VALUE file, int line, VALUE method, int argc, VALUE*
     if(argc > 0){
       yg_cstring("argv");
       yg_array();
-      int i;
       for(i = 0; i < argc; i++)
         yg_id(argv[i]);
       yg_array_end();
@@ -1281,11 +1291,12 @@ typedef int (rb_backtrace_iter_ext_func)(void *arg, VALUE file, int line, VALUE
 
 // copied from ruby_ext_backtrace
 static int
-vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtrace_iter_ext_func *iter, void *arg)
+vm_backtrace_each_ext(const rb_thread_t *th, int lev, void (*init)(void *), rb_backtrace_iter_ext_func *iter, void *arg)
 {
   const rb_control_frame_t *limit_cfp = th->cfp;
   const rb_control_frame_t *cfp = (void *)(th->stack + th->stack_size);
   VALUE file = Qnil;
+  VALUE* argv;
   int line_no = 0;
 
   cfp -= 2;
@@ -1301,18 +1312,32 @@ vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtra
   if (th->vm->progname) file = th->vm->progname;
 
   while (cfp > limit_cfp) {
+    #ifdef HAVE_RB_CONTROL_FRAME_T_BP
+    VALUE* bp = cfp->bp;
+    #else
+    VALUE* bp = cfp->sp; //??
+    #endif
     if (cfp->iseq != 0) {
         if (cfp->pc != 0) {
           rb_iseq_t *iseq = cfp->iseq;
 
           line_no = rb_vm_get_sourceline(cfp);
+          #ifdef HAVE_RB_ISEQ_T_FILENAME
           file = iseq->filename;
-
+          #else
+          file = iseq->location.path;
+          #endif
           //arguments pushed this way: *reg_cfp->sp++ = recv; for (i = 0; i < argc; i++) *reg_cfp->sp++ = argv[i];
           //local vars = cfp->iseq->local_size - cfp->iseq->arg_size;
           //in memory: receiver params locals (bp(incremented))
-          VALUE* argv = &cfp->bp[- cfp->iseq->local_size - 1];
-          if ((*iter)(arg, file, line_no, iseq->name, cfp->iseq->arg_size, argv)) break;
+          argv = &bp[- cfp->iseq->local_size - 1];
+          if ((*iter)(arg, file, line_no,
+            #ifdef HAVE_RB_ISEQ_T_LOCATION
+            iseq->location.label
+            #else
+            iseq->name
+            #endif
+            , cfp->iseq->arg_size, argv)) break;
         }
     } else
       if (RUBYVM_CFUNC_FRAME_P(cfp)) {
@@ -1321,11 +1346,11 @@ vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtra
         if (NIL_P(file)) file = ruby_engine_name;
 
         if (id != ID_ALLOCATOR){
-          VALUE* argv = NULL;
+          argv = NULL;
           // when argc==-1/-2(variable length params without/with splat) - the cfp has no info on params count :(
           //TODO: infere from somewhere ex. find self in stack? (not guaranted btw, for example: obj.method(obj, 123, obj) - will find last param instead of self)
           if(cfp->me->def->body.cfunc.argc >= 0){ //only fixed args
-            argv = &cfp->bp[- cfp->me->def->body.cfunc.argc - 2]; // args+self, bp was incremented thus minus 2
+            argv = &bp[- cfp->me->def->body.cfunc.argc - 2]; // args+self, bp was incremented thus minus 2
           }
           //file+line no from previous iseq frame
           if((*iter)(arg, file, line_no, rb_id2str(id), cfp->me->def->body.cfunc.argc, argv)) break;
@@ -1337,6 +1362,15 @@ vm_backtrace_each_ext(rb_thread_t *th, int lev, void (*init)(void *), rb_backtra
 }
 
 static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
+  rb_iseq_t *iseq;
+  int line_no;
+  ID id;
+  #ifdef HAVE_RB_EVENT_HOOK_T_DATA
+  rb_event_hook_t *hook = th->event_hooks;
+  #else
+  struct rb_event_hook_struct *hook = th->event_hooks.hooks;
+  #endif
+
    if(th->stack){
     VALUE *p = th->stack;
     VALUE *sp = th->cfp->sp;
@@ -1357,13 +1391,18 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
     //TODO: this is kind of backtrace, but other direction plus some other info, merge it in backtrace.
     while (cfp != limit_cfp) {
       yajl_gen_map_open(ctx->yajl);
-      rb_iseq_t *iseq = cfp->iseq;
+      iseq = cfp->iseq;
       ygh_id("proc", cfp->proc);
       ygh_id("self", cfp->self);
       if (iseq) {
           ygh_id("iseq", RUBY_VM_NORMAL_ISEQ_P(iseq) ? iseq->self : (VALUE)iseq);
-          int line_no = rb_vm_get_sourceline(cfp);
+          line_no = rb_vm_get_sourceline(cfp);
+          //TODO: dry?
+          #ifdef HAVE_RB_ISEQ_T_FILENAME
           ygh_rstring("file", iseq->filename);
+          #else
+          ygh_rstring("file", iseq->location.path);
+          #endif
           ygh_int("line_no",line_no);
       }
       if (cfp->me){
@@ -1376,7 +1415,7 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
      //   char mark;
         //rb_method_definition_t *def;
         ygh_id("klass", me->klass);
-        ID id = me->called_id;
+        id = me->called_id;
 
         if(me->def){
           id = me->def->original_id;
@@ -1405,8 +1444,12 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
   ygh_id("thgroup", th->thgroup);
   ygh_id("value", th->value);
   ygh_id("errinfo", th->errinfo);
+
+#ifdef HAVE_RB_THREAD_T_THROWN_ERRINFO
   ygh_id("thrown_errinfo", th->thrown_errinfo);
   ygh_id("local_svar", th->local_svar);
+#endif
+
   ygh_id("top_self", th->top_self);
   ygh_id("top_wrapper", th->top_wrapper);
   ygh_id("fiber", th->fiber);
@@ -1438,8 +1481,6 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
   }
   yajl_gen_map_close(ctx->yajl);
 
-    // mark_event_hooks(th->event_hooks);
-  rb_event_hook_t *hook = th->event_hooks;
   yg_cstring("event_hooks");
   yajl_gen_array_open(ctx->yajl);
   while(hook){
@@ -1451,6 +1492,9 @@ static void dump_thread(const rb_thread_t* th, walk_ctx_t *ctx){
 
 
 static void dump_machine_context(walk_ctx_t *ctx){
+  VALUE* x;
+  unsigned long n;
+
   //TODO: other threads?
   rb_thread_t* th = GET_THREAD()->vm->main_thread; //GET_THREAD();
   union {
@@ -1470,8 +1514,8 @@ static void dump_machine_context(walk_ctx_t *ctx){
   yg_cstring("registers");
   yajl_gen_array_open(ctx->yajl);
   //mark_locations_array(objspace, save_regs_gc_mark.v, numberof(save_regs_gc_mark.v));
-  VALUE* x = save_regs_gc_mark.v;
-  unsigned long n = numberof(save_regs_gc_mark.v);
+  x = save_regs_gc_mark.v;
+  n = numberof(save_regs_gc_mark.v);
   while (n--) {
     VALUE v = *(x++);
     if(is_in_heap((void*)v, NULL))
@@ -1501,22 +1545,21 @@ static void dump_machine_context(walk_ctx_t *ctx){
 // 1.9.2, rb_class_tbl fails to be linked in 1.9.3 :(
 
 static int dump_class_tbl_entry(ID key, rb_const_entry_t* ce/*st_data_t val*/, walk_ctx_t *ctx){
+  const char* id;
   if (!rb_is_const_id(key)) return ST_CONTINUE; //?
-  VALUE value = ce->value;
 
-  char* id = rb_id2name(key);
-  if(id)
+  if((id = rb_id2name(key)))
     yg_cstring(id);
   else
     yg_cstring("(unknown)");
-  yg_id(value);
+  yg_id(ce->value);
   return ST_CONTINUE;
 }
 #endif
 
 #ifdef HAVE_RB_GLOBAL_TBL
 static int dump_global_tbl_entry(ID key, struct rb_global_entry* ge/*st_data_t val*/, walk_ctx_t *ctx){
-  char* id = rb_id2name(key);
+  const char* id = rb_id2name(key);
   if(id)
     yg_cstring(id);
   else
@@ -1530,8 +1573,8 @@ static int dump_global_tbl_entry(ID key, struct rb_global_entry* ge/*st_data_t v
     yg_cstring(info.dli_sname);
 
     if(!strcmp("rb_gvar_val_getter", info.dli_sname)){
-    yg_cstring("data");
-    yg_id(ge->var->data);
+      yg_cstring("data");
+      yg_id((VALUE)ge->var->data);
     }
   }
 
@@ -1547,11 +1590,13 @@ static int dump_global_tbl_entry(ID key, struct rb_global_entry* ge/*st_data_t v
 #include <stdarg.h>
 static bool g_verbose = false;
 static int log_printf(const char* format, ...){
+  int res = 0;
   va_list list;
   va_start(list, format);
   if(g_verbose)
-    vprintf(format, list);
+    res = vprintf(format, list);
   va_end(list);
+  return res;
 }
 
 #define log log_printf
@@ -1569,6 +1614,14 @@ static VALUE heapdump_verbose_setter(VALUE self, VALUE verbose){
 //public symbol, can be used from GDB
 void heapdump_dump(const char* filename){
   struct walk_ctx ctx_o, *ctx = &ctx_o;
+  struct gc_list *list;
+  #ifdef HAVE_RB_CLASS_TBL
+  st_table *rb_class_tbl;
+  #endif
+  #ifdef HAVE_RB_GLOBAL_TBL
+  st_table *rb_global_tbl;
+  #endif
+
   memset(ctx, 0, sizeof(*ctx));
 
   if(!filename){
@@ -1589,7 +1642,6 @@ void heapdump_dump(const char* filename){
   flush_yajl(ctx);
   // fprintf(ctx->file, "\n");
 
-  struct gc_list *list;
   /* mark protected global variables */
   log("global_list\n");
   yg_cstring("globals");
@@ -1602,7 +1654,7 @@ void heapdump_dump(const char* filename){
 
   //TODO: rb_global_tbl
 #ifdef HAVE_RB_GLOBAL_TBL
-  st_table *rb_global_tbl = rb_get_global_tbl();
+  rb_global_tbl = rb_get_global_tbl();
   if (rb_global_tbl && rb_global_tbl->num_entries > 0){
     log("globals\n");
     yg_cstring("global_tbl");
@@ -1614,7 +1666,7 @@ void heapdump_dump(const char* filename){
 #endif
 
 #ifdef HAVE_RB_CLASS_TBL
-  st_table *rb_class_tbl = rb_get_class_tbl();
+  rb_class_tbl = rb_get_class_tbl();
   if (rb_class_tbl && rb_class_tbl->num_entries > 0){
     log("classes\n");
     yg_cstring("classes");
@@ -1666,13 +1718,25 @@ iterate_user_type_counts(VALUE key, VALUE value, yajl_gen yajl){
 
 static VALUE
 rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
-  rb_check_array_type(string_prefixes);
   yajl_gen_config cfg;
+  yajl_gen yajl;
+  VALUE cls, class_name, prefix;
+  size_t counts[T_MASK+1];
+  size_t freed = 0;
+  size_t total = 0;
+  size_t i;
+  long int n;
+  const unsigned char* buf;
+  unsigned int len;
+  VALUE hash = rb_hash_new();
+  rb_objspace_t *objspace = GET_THREAD()->vm->objspace;
+
+  rb_check_array_type(string_prefixes);
   memset(&cfg, 0, sizeof(cfg));
   cfg.beautify = true;
   cfg.htmlSafe = true;
   cfg.indentString = "    ";
-  yajl_gen yajl = yajl_gen_alloc(&cfg,NULL);
+  yajl = yajl_gen_alloc(&cfg,NULL);
   yg_map();
   if(do_gc){
     yg_cstring("gc_ran");
@@ -1680,13 +1744,6 @@ rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
     rb_gc_start();
   }
 
-  rb_objspace_t *objspace = GET_THREAD()->vm->objspace;
-  size_t counts[T_MASK+1];
-  size_t freed = 0;
-  size_t total = 0;
-  size_t i;
-  VALUE hash = rb_hash_new();
-
   for (i = 0; i <= T_MASK; i++) counts[i] = 0;
 
   FOR_EACH_HEAP_SLOT(p)
@@ -1696,12 +1753,11 @@ rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
       counts[type]++;
       if(type == T_OBJECT){
         //take class etc.
-        VALUE cls = rb_class_real_checked(CLASS_OF(p));
+        cls = rb_class_real_checked(CLASS_OF(p));
         if(!cls) continue;
-        VALUE class_name = rb_class_path(cls);
-        long int n = RARRAY_LEN(string_prefixes)-1;
-        for(; n >= 0; n--){
-          VALUE prefix = rb_check_string_type(RARRAY_PTR(string_prefixes)[n]);
+        class_name = rb_class_path(cls);
+        for(n = RARRAY_LEN(string_prefixes)-1; n >= 0; n--){
+          prefix = rb_check_string_type(RARRAY_PTR(string_prefixes)[n]);
           if(NIL_P(prefix)) continue;
           rb_enc_check(class_name, prefix);
           if (RSTRING_LEN(class_name) < RSTRING_LEN(prefix)) continue;
@@ -1744,11 +1800,9 @@ rb_heapdump_count_objects(VALUE self, VALUE string_prefixes, VALUE do_gc){
   yg_map_end(); //all document
 
   //flush yajl:
-  const unsigned char* buf;
-  unsigned int len;
   if(yajl_gen_get_buf(yajl, &buf, &len) == yajl_gen_status_ok){
     //fwrite(buf, len, 1, ctx->file);
-    VALUE res = rb_str_new(buf, len);
+    VALUE res = rb_str_new((char*)buf, len);
     yajl_gen_clear(yajl);
     yajl_gen_free(yajl);
     return res;

data/ext/heap_dump/specific/ruby-2.0.0/fiber.h

@@ -0,0 +1,67 @@
+#define CAPTURE_JUST_VALID_VM_STACK 1
+
+enum context_type {
+    CONTINUATION_CONTEXT = 0,
+    FIBER_CONTEXT = 1,
+    ROOT_FIBER_CONTEXT = 2
+};
+
+typedef struct rb_context_struct {
+    enum context_type type;
+    VALUE self;
+    int argc;
+    VALUE value;
+    VALUE *vm_stack;
+#ifdef CAPTURE_JUST_VALID_VM_STACK
+    size_t vm_stack_slen;  /* length of stack (head of th->stack) */
+    size_t vm_stack_clen;  /* length of control frames (tail of th->stack) */
+#endif
+    VALUE *machine_stack;
+    VALUE *machine_stack_src;
+#ifdef __ia64
+    VALUE *machine_register_stack;
+    VALUE *machine_register_stack_src;
+    int machine_register_stack_size;
+#endif
+    rb_thread_t saved_thread;
+    rb_jmpbuf_t jmpbuf;
+    size_t machine_stack_size;
+} rb_context_t;
+
+enum fiber_status {
+    CREATED,
+    RUNNING,
+    TERMINATED
+};
+
+#if FIBER_USE_NATIVE && !defined(_WIN32)
+#define MAX_MAHINE_STACK_CACHE  10
+static int machine_stack_cache_index = 0;
+typedef struct machine_stack_cache_struct {
+    void *ptr;
+    size_t size;
+} machine_stack_cache_t;
+static machine_stack_cache_t machine_stack_cache[MAX_MAHINE_STACK_CACHE];
+static machine_stack_cache_t terminated_machine_stack;
+#endif
+
+typedef struct rb_fiber_struct {
+    rb_context_t cont;
+    VALUE prev;
+    enum fiber_status status;
+    struct rb_fiber_struct *prev_fiber;
+    struct rb_fiber_struct *next_fiber;
+    /* If a fiber invokes "transfer",
+     * then this fiber can't "resume" any more after that.
+     * You shouldn't mix "transfer" and "resume".
+     */
+    int transfered;
+
+#if FIBER_USE_NATIVE
+#ifdef _WIN32
+    void *fib_handle;
+#else
+    ucontext_t context;
+#endif
+#endif
+} rb_fiber_t;

data/ext/heap_dump/specific/ruby-2.0.0/gc_internal.h

@@ -0,0 +1,251 @@
+#include "ruby/re.h"
+
+#ifndef GC_PROFILE_MORE_DETAIL
+#define GC_PROFILE_MORE_DETAIL 0
+#endif
+
+typedef struct gc_profile_record {
+    double gc_time;
+    double gc_invoke_time;
+
+    size_t heap_total_objects;
+    size_t heap_use_size;
+    size_t heap_total_size;
+
+    int is_marked;
+
+#if GC_PROFILE_MORE_DETAIL
+    double gc_mark_time;
+    double gc_sweep_time;
+
+    size_t heap_use_slots;
+    size_t heap_live_objects;
+    size_t heap_free_objects;
+
+    int have_finalize;
+
+    size_t allocate_increase;
+    size_t allocate_limit;
+#endif
+} gc_profile_record;
+
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+#pragma pack(push, 1) /* magic for reducing sizeof(RVALUE): 24 -> 20 */
+#endif
+
+typedef struct RVALUE {
+    union {
+  struct {
+      VALUE flags;    /* always 0 for freed obj */
+      struct RVALUE *next;
+  } free;
+  struct RBasic  basic;
+  struct RObject object;
+  struct RClass  klass;
+  struct RFloat  flonum;
+  struct RString string;
+  struct RArray  array;
+  struct RRegexp regexp;
+  struct RHash   hash;
+  struct RData   data;
+  struct RTypedData   typeddata;
+  struct RStruct rstruct;
+  struct RBignum bignum;
+  struct RFile   file;
+  struct RNode   node;
+  struct RMatch  match;
+  struct RRational rational;
+  struct RComplex complex;
+    } as;
+#ifdef GC_DEBUG
+    const char *file;
+    int   line;
+#endif
+} RVALUE;
+
+#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__CYGWIN__)
+#pragma pack(pop)
+#endif
+
+struct heaps_slot {
+    void *membase;
+    RVALUE *slot;
+    size_t limit;
+    uintptr_t *bits;
+    RVALUE *freelist;
+    struct heaps_slot *next;
+    struct heaps_slot *prev;
+    struct heaps_slot *free_next;
+};
+
+struct heaps_header {
+    struct heaps_slot *base;
+    uintptr_t *bits;
+};
+
+struct sorted_heaps_slot {
+    RVALUE *start;
+    RVALUE *end;
+    struct heaps_slot *slot;
+};
+
+struct heaps_free_bitmap {
+    struct heaps_free_bitmap *next;
+};
+
+struct gc_list {
+    VALUE *varptr;
+    struct gc_list *next;
+};
+
+#define STACK_CHUNK_SIZE 500
+
+typedef struct stack_chunk {
+    VALUE data[STACK_CHUNK_SIZE];
+    struct stack_chunk *next;
+} stack_chunk_t;
+
+typedef struct mark_stack {
+    stack_chunk_t *chunk;
+    stack_chunk_t *cache;
+    size_t index;
+    size_t limit;
+    size_t cache_size;
+    size_t unused_cache_size;
+} mark_stack_t;
+
+#ifndef CALC_EXACT_MALLOC_SIZE
+#define CALC_EXACT_MALLOC_SIZE 0
+#endif
+
+typedef struct rb_objspace {
+    struct {
+  size_t limit;
+  size_t increase;
+#if CALC_EXACT_MALLOC_SIZE
+  size_t allocated_size;
+  size_t allocations;
+#endif
+    } malloc_params;
+    struct {
+  size_t increment;
+  struct heaps_slot *ptr;
+  struct heaps_slot *sweep_slots;
+  struct heaps_slot *free_slots;
+  struct sorted_heaps_slot *sorted;
+  size_t length;
+  size_t used;
+        struct heaps_free_bitmap *free_bitmap;
+  RVALUE *range[2];
+  RVALUE *freed;
+  size_t live_num;
+  size_t free_num;
+  size_t free_min;
+  size_t final_num;
+  size_t do_heap_free;
+    } heap;
+    struct {
+  int dont_gc;
+  int dont_lazy_sweep;
+  int during_gc;
+  rb_atomic_t finalizing;
+    } flags;
+    struct {
+  st_table *table;
+  RVALUE *deferred;
+    } final;
+    mark_stack_t mark_stack;
+    struct {
+  int run;
+  gc_profile_record *record;
+  size_t count;
+  size_t size;
+  double invoke_time;
+    } profile;
+    struct gc_list *global_list;
+    size_t count;
+    int gc_stress;
+
+    struct mark_func_data_struct {
+  void *data;
+  void (*mark_func)(VALUE v, void *data);
+    } *mark_func_data;
+} rb_objspace_t;
+
+#define malloc_limit    objspace->malloc_params.limit
+#define malloc_increase   objspace->malloc_params.increase
+#define heaps     objspace->heap.ptr
+#define heaps_length    objspace->heap.length
+#define heaps_used    objspace->heap.used
+#define lomem     objspace->heap.range[0]
+#define himem     objspace->heap.range[1]
+#define heaps_inc   objspace->heap.increment
+#define heaps_freed   objspace->heap.freed
+#define dont_gc     objspace->flags.dont_gc
+#define during_gc   objspace->flags.during_gc
+#define finalizing    objspace->flags.finalizing
+#define finalizer_table   objspace->final.table
+#define deferred_final_list objspace->final.deferred
+#define global_List   objspace->global_list
+#define ruby_gc_stress    objspace->gc_stress
+#define initial_malloc_limit  initial_params.initial_malloc_limit
+#define initial_heap_min_slots  initial_params.initial_heap_min_slots
+#define initial_free_min  initial_params.initial_free_min
+
+#define is_lazy_sweeping(objspace) ((objspace)->heap.sweep_slots != 0)
+
+#define nonspecial_obj_id(obj) (VALUE)((SIGNED_VALUE)(obj)|FIXNUM_FLAG)
+
+#define RANY(o) ((RVALUE*)(o))
+#define has_free_object (objspace->heap.free_slots && objspace->heap.free_slots->freelist)
+
+#define HEAP_HEADER(p) ((struct heaps_header *)(p))
+#define GET_HEAP_HEADER(x) (HEAP_HEADER((uintptr_t)(x) & ~(HEAP_ALIGN_MASK)))
+#define GET_HEAP_SLOT(x) (GET_HEAP_HEADER(x)->base)
+#define GET_HEAP_BITMAP(x) (GET_HEAP_HEADER(x)->bits)
+#define NUM_IN_SLOT(p) (((uintptr_t)(p) & HEAP_ALIGN_MASK)/sizeof(RVALUE))
+#define BITMAP_INDEX(p) (NUM_IN_SLOT(p) / (sizeof(uintptr_t) * CHAR_BIT))
+#define BITMAP_OFFSET(p) (NUM_IN_SLOT(p) & ((sizeof(uintptr_t) * CHAR_BIT)-1))
+#define MARKED_IN_BITMAP(bits, p) (bits[BITMAP_INDEX(p)] & ((uintptr_t)1 << BITMAP_OFFSET(p)))
+
+//
+#define RANY(o) ((RVALUE*)(o))
+//
+
+static inline int
+is_pointer_to_heap(rb_objspace_t *objspace, void *ptr)
+{
+    register RVALUE *p = RANY(ptr);
+    register struct sorted_heaps_slot *heap;
+    register size_t hi, lo, mid;
+
+    if (p < lomem || p > himem) return FALSE;
+    if ((VALUE)p % sizeof(RVALUE) != 0) return FALSE;
+
+    /* check if p looks like a pointer using bsearch*/
+    lo = 0;
+    hi = heaps_used;
+    while (lo < hi) {
+  mid = (lo + hi) / 2;
+  heap = &objspace->heap.sorted[mid];
+  if (heap->start <= p) {
+      if (p < heap->end)
+    return TRUE;
+      lo = mid + 1;
+  }
+  else {
+      hi = mid;
+  }
+    }
+    return FALSE;
+}
+
+//from count_objects:
+#define FOR_EACH_HEAP_SLOT(p) for (i = 0; i < heaps_used; i++) {\
+      RVALUE *p = objspace->heap.sorted[i].start, *pend = objspace->heap.sorted[i].end;\
+      if(!p) continue;\
+      for (; p < pend; p++) {
+#define FOR_EACH_HEAP_SLOT_END(total) } total += objspace->heap.sorted[i].slot->limit; }
+
+#define NODE_OPTBLOCK 1000000 //FIXME

data/ext/heap_dump/specific/ruby-2.0.0/internal_typed_data.h

@@ -0,0 +1,109 @@
+ //FIXME: autogen this from ruby (this copied from 1.9.3p194)
+
+// thread.c:
+struct thgroup {
+  int enclosed;
+  VALUE group;
+};
+
+// enumerator.c:
+struct enumerator {
+    VALUE obj;
+    ID    meth;
+    VALUE args;
+    VALUE fib;
+    VALUE dst;
+    VALUE lookahead;
+    VALUE feedvalue;
+    VALUE stop_exc;
+};
+
+//
+struct generator {
+    VALUE proc;
+};
+
+struct yielder {
+    VALUE proc;
+};
+
+
+// proc.c:
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    VALUE defined_class; //FIXME: dump this
+    ID id;
+    rb_method_entry_t *me;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+//
+#define METHOD_DEFINITIONP(m) (m->me ? m->me->def : NULL)
+
+//class.c:
+#define HAVE_RB_CLASS_TBL 1
+//For som reason this fails to link directly on 1.9.3 :(
+
+//HACK:
+#include <dlfcn.h>
+
+inline st_table * rb_get_class_tbl(){
+  Dl_info info;
+  void* image;
+  if(!dladdr(rb_intern, &info) || !info.dli_fname){
+    return NULL;
+  }
+  image = dlopen(info.dli_fname, RTLD_NOLOAD | RTLD_GLOBAL);
+  // printf("Image is %p, addr is %p (%p rel)\n", image, rb_intern, ((void*)rb_intern - image));
+  if(image)
+  {
+    void* tbl = dlsym(image, "_rb_class_tbl");
+    dlclose(image);
+    if(tbl)
+      return tbl;
+  }
+
+  //TODO: parse sym table and calculate address?
+
+  return NULL;
+}
+
+#define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
+#define GET_THREAD() ruby_current_thread
+
+//FIXME: get global const for it:  rb_define_global_const("RUBY_ENGINE", ruby_engine_name = MKSTR(engine));
+#define ruby_engine_name Qnil
+
+#define ID_ALLOCATOR 0
+
+//vm_trace.c
+typedef enum {
+    RUBY_HOOK_FLAG_SAFE    = 0x01,
+    RUBY_HOOK_FLAG_DELETED = 0x02,
+    RUBY_HOOK_FLAG_RAW_ARG = 0x04
+} rb_hook_flag_t;
+typedef struct rb_event_hook_struct {
+    rb_hook_flag_t hook_flags;
+    rb_event_flag_t events;
+    rb_event_hook_func_t func;
+    VALUE data;
+    struct rb_event_hook_struct *next;
+} rb_event_hook_t;
+
+//vm_backtrace.c
+inline static int
+calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
+{
+    return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
+}
+
+int rb_vm_get_sourceline(const rb_control_frame_t * cfp){
+  int lineno = 0;
+  const rb_iseq_t *iseq = cfp->iseq;
+
+  if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
+  lineno = calc_lineno(cfp->iseq, cfp->pc);
+  }
+  return lineno;
+}

data/lib/heap_dump/version.rb

@@ -1,3 +1,3 @@
 module HeapDump
-  VERSION = "0.0.29"
+  VERSION = "0.0.30"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: heap_dump
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-19 00:00:00.000000000 Z
+date: 2012-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: debugger-ruby_core_source
@@ -82,6 +82,9 @@ files:
 - ext/heap_dump/specific/ruby-1.9.3/fiber.h
 - ext/heap_dump/specific/ruby-1.9.3/gc_internal.h
 - ext/heap_dump/specific/ruby-1.9.3/internal_typed_data.h
+- ext/heap_dump/specific/ruby-2.0.0/fiber.h
+- ext/heap_dump/specific/ruby-2.0.0/gc_internal.h
+- ext/heap_dump/specific/ruby-2.0.0/internal_typed_data.h
 - heap_dump.gemspec
 - lib/heap_dump.rb
 - lib/heap_dump/version.rb
@@ -103,9 +106,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3423213544880593547
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -114,3 +114,4 @@ specification_version: 3
 summary: Allows to dump heap to track reference leaks, including leaks in proc contexts
   and fibers
 test_files: []
+has_rdoc: