memprof 0.2.7 → 0.2.9

data/ext/extconf.rb

@@ -189,6 +189,8 @@ when 'i486'
 end
 add_define "_ARCH_#{arch}_"
 
+add_define "_MEMPROF_DEBUG" if ENV['MEMPROF_DEBUG'] == '1'
+
 if is_elf or is_macho
   create_makefile('memprof')
 else

data/ext/mach.c

@@ -2,15 +2,18 @@
 
 #include "bin_api.h"
 #include "arch.h"
+#include "util.h"
 
+#include <assert.h>
+#include <dlfcn.h>
+#include <err.h>
 #include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 #include <sysexits.h>
 #include <sys/mman.h>
-#include <stdio.h>
 #include <sys/stat.h>
-#include <dlfcn.h>
-#include <stdlib.h>
 
 #include <mach-o/dyld.h>
 #include <mach-o/getsect.h>
@@ -18,6 +21,17 @@
 #include <mach-o/ldsyms.h>
 #include <mach-o/nlist.h>
 
+struct mach_config {
+  const struct nlist_64 **symbol_table;
+  const char *string_table;
+  uint32_t symbol_count;
+  uint32_t string_table_size;
+  intptr_t image_offset;
+};
+
+static struct mach_config mach_config;
+extern struct memprof_config memprof_config;
+
 /*
  * The jmp instructions in the dyld stub table are 6 bytes,
  * 2 bytes for the instruction and 4 bytes for the offset operand
@@ -193,14 +207,20 @@ update_bin_for_mach_header(const struct mach_header *header, intptr_t slide, voi
 
 static int
 find_dyld_image_index(const struct mach_header_64 *hdr) {
-  int i;
+  uint32_t i;
 
   for (i = 0; i < _dyld_image_count(); i++) {
     const struct mach_header_64 *tmphdr = (const struct mach_header_64*) _dyld_get_image_header(i);
     if (hdr == tmphdr)
       return i;
   }
+
   errx(EX_SOFTWARE, "Could not find image index");
+
+  /* this is to quiet a GCC warning. might be a bug because errx is marked
+   * __dead2/noreturn
+   */
+  return -1;
 }
 
 /*
@@ -251,7 +271,7 @@ get_ruby_file_and_header_index(int *index) {
 
 /*
  * This function compares two nlist_64 structures by their n_value field (address, usually).
- * It is used by qsort in build_sorted_nlist_table.
+ * It is used by qsort in extract_symbol_table.
  */
 
 static int
@@ -268,16 +288,19 @@ nlist_cmp(const void *obj1, const void *obj2) {
 }
 
 /*
- * This function returns an array of pointers to nlist_64 entries in the symbol table
- * of the file buffer pointed to by the passed mach header, sorted by address, and sets the
- * passed uint32_t pointers nsyms and stroff to those fields found in the symtab_command structure.
+ * This function sets the passed pointers to a buffer containing the nlist_64 entries,
+ * a buffer containing the string data, the number of entries, and the size of the string buffer.
  *
- * !!! The pointer returned by this function must be freed !!!
+ * The string names of symbols are stored separately from the symbol table.
+ * The symbol table entries contain a string 'index', which is an offset into this region.
+ *
+ * !!! This function allocates memory. symbol_table and string_table should be freed when no longer used !!!
  */
 
-static const struct nlist_64 **
-build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint32_t *stroff) {
-  const struct nlist_64 **base;
+static void
+extract_symbol_table(const struct mach_header_64 *hdr, const struct nlist_64 ***symbol_table, const char **string_table, uint32_t *symbol_count, uint32_t *strsize) {
+  const struct nlist_64 **new_symtbl;
+  char *new_strtbl;
   uint32_t i, j;
 
   const char *lc = (const char*) hdr + sizeof(struct mach_header_64);
@@ -285,19 +308,23 @@ build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint
   for (i = 0; i < hdr->ncmds; i++) {
     if (((const struct load_command*)lc)->cmd == LC_SYMTAB) {
       const struct symtab_command *sc = (const struct symtab_command*) lc;
-      const struct nlist_64 *symbol_table = (const struct nlist_64*)((const char*)hdr + sc->symoff);
+      const struct nlist_64 *file_symtbl = (const struct nlist_64*)((const char*)hdr + sc->symoff);
+
+      new_symtbl = malloc(sc->nsyms * sizeof(struct nlist_64*));
+      new_strtbl = malloc(sc->strsize);
 
-      /* TODO: qsort this table *IN PLACE* instead of making a copy of it. */
-      base = malloc(sc->nsyms * sizeof(struct nlist_64*));
+      memcpy(new_strtbl, (char*)hdr + sc->stroff, sc->strsize);
 
       for (j = 0; j < sc->nsyms; j++)
-        base[j] = symbol_table + j;
+        new_symtbl[j] = file_symtbl + j;
 
-      qsort(base, sc->nsyms, sizeof(struct nlist_64*), &nlist_cmp);
+      qsort(new_symtbl, sc->nsyms, sizeof(struct nlist_64*), &nlist_cmp);
 
-      *nsyms = sc->nsyms;
-      *stroff = sc->stroff;
-      return base;
+      *symbol_table = new_symtbl;
+      *string_table = new_strtbl;
+      *symbol_count = sc->nsyms;
+      *strsize = sc->strsize;
+      return;
     }
 
     lc += ((const struct load_command*)lc)->cmdsize;
@@ -306,51 +333,36 @@ build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint
 }
 
 /*
- * The workflow for bin_find_symbol is as follows:
- *
- * 1. Prefix the symbol with a "_", since Apple is weird
- * 2. Figure out what file we think contains the symbol table (either the executable, or libruby),
- *    and read it into memory. We have to do this because the symbol table is not loaded
- *    into the process as part of the normal image loading. While we're doing this,
- *    figure out the dyld image index of the corresponding *in-process* image.
- * 3. Work up a copy of the symbol table, sorted by address.
- * 4. Iterate over the sorted table and find the symbol that matches our search name
- * 5. Obtain the rough (padded to 16 byte alignment) size of the symbol by subtracting it's
- *    address from the address of the symbol *after* it.
- * 6. Calculate the *real* address of the symbol by adding the image's "slide"
- *    (offset at which the image was loaded into the process) to the table entry's address.
+ * Return the string at the given offset into the symbol table's string buffer
+ */
+
+static inline const char*
+get_symtab_string(uint32_t stroff) {
+  assert(mach_config.string_table != NULL);
+  assert(stroff < mach_config.string_table_size);
+  return mach_config.string_table + stroff;
+}
+
+/*
+ * Return the address and size of a symbol given it's name
  */
 
 void *
 bin_find_symbol(const char *symbol, size_t *size) {
   void *ptr = NULL;
-  void *file = NULL;
-
-  uint32_t i, j, k;
-  uint32_t stroff, nsyms = 0;
-  int index = 0;
+  uint32_t i, j;
 
-  file = get_ruby_file_and_header_index(&index);
+  assert(mach_config.symbol_table != NULL);
+  assert(mach_config.symbol_count > 0);
 
-  const struct mach_header_64 *hdr = (const struct mach_header_64*) file;
-  if (hdr->magic != MH_MAGIC_64)
-    errx(EX_SOFTWARE, "Magic for Ruby Mach-O file doesn't match");
-
-  const struct nlist_64 **nlist_table = build_sorted_nlist_table(hdr, &nsyms, &stroff);
-  /*
-   * The string names of symbols are stored separately from the symbol table.
-   * The symbol table entries contain a string 'index', which is an offset into this region.
-   */
-  const char *string_table = (const char*)hdr + stroff;
-
-  for (i=0; i < nsyms; i++) {
-    const struct nlist_64 *nlist_entry = nlist_table[i];
-    const char *string = string_table + nlist_entry->n_un.n_strx;
+  for (i=0; i < mach_config.symbol_count; i++) {
+    const struct nlist_64 *nlist_entry = mach_config.symbol_table[i];
+    const char *string = get_symtab_string(nlist_entry->n_un.n_strx);
 
     if (string && strcmp(symbol, string+1) == 0) {
       const uint64_t addr = nlist_entry->n_value;
       /* Add the slide to get the *real* address in the process. */
-      ptr = (void*)(addr + _dyld_get_image_vmaddr_slide(index));
+      ptr = (void*)(addr + mach_config.image_offset);
 
       if (size) {
         const struct nlist_64 *next_entry = NULL;
@@ -362,7 +374,7 @@ bin_find_symbol(const char *symbol, size_t *size) {
          */
         j = 1;
         while (next_entry == NULL) {
-          const struct nlist_64 *tmp_entry = nlist_table[i + j];
+          const struct nlist_64 *tmp_entry = mach_config.symbol_table[i + j];
           if (nlist_entry->n_value != tmp_entry->n_value)
             next_entry = tmp_entry;
           j++;
@@ -378,9 +390,6 @@ bin_find_symbol(const char *symbol, size_t *size) {
       break;
     }
   }
-
-  free(nlist_table);
-  free(file);
   return ptr;
 }
 
@@ -390,33 +399,18 @@ bin_find_symbol(const char *symbol, size_t *size) {
 const char *
 bin_find_symbol_name(void *symbol) {
   const char *name = NULL;
-  void *ptr = NULL;
-  void *file = NULL;
-
-  uint32_t i, j, k;
-  uint32_t stroff, nsyms = 0;
-  int index = 0;
+  uint32_t i;
 
-  file = get_ruby_file_and_header_index(&index);
-
-  const struct mach_header_64 *hdr = (const struct mach_header_64*) file;
-  if (hdr->magic != MH_MAGIC_64)
-    errx(EX_SOFTWARE, "Magic for Ruby Mach-O file doesn't match");
-
-  const struct nlist_64 **nlist_table = build_sorted_nlist_table(hdr, &nsyms, &stroff);
-  /*
-   * The string names of symbols are stored separately from the symbol table.
-   * The symbol table entries contain a string 'index', which is an offset into this region.
-   */
-  const char *string_table = (const char*)hdr + stroff;
+  assert(mach_config.symbol_table != NULL);
+  assert(mach_config.symbol_count > 0);
 
-  for (i=0; i < nsyms; i++) {
-    const struct nlist_64 *nlist_entry = nlist_table[i];
-    const char *string = string_table + nlist_entry->n_un.n_strx;
+  for (i=0; i < mach_config.symbol_count; i++) {
+    const struct nlist_64 *nlist_entry = mach_config.symbol_table[i];
+    const char *string = get_symtab_string(nlist_entry->n_un.n_strx);
 
     const uint64_t addr = nlist_entry->n_value;
     /* Add the slide to get the *real* address in the process. */
-    void *ptr = (void*)(addr + _dyld_get_image_vmaddr_slide(index));
+    void *ptr = (void*)(addr + mach_config.image_offset);
 
     if (ptr == symbol) {
       name = string+1;
@@ -424,8 +418,6 @@ bin_find_symbol_name(void *symbol) {
     }
   }
 
-  free(nlist_table);
-  free(file);
   return name;
 }
 
@@ -471,12 +463,12 @@ bin_allocate_page()
   void *ret = NULL;
   size_t i = 0;
 
-  for (i = pagesize; i < INT_MAX - pagesize; i += pagesize) {
-    ret = mmap((void*)(NULL + i), pagesize, PROT_WRITE|PROT_READ|PROT_EXEC,
+  for (i = memprof_config.pagesize; i < INT_MAX - memprof_config.pagesize; i += memprof_config.pagesize) {
+    ret = mmap((void*)(NULL + i), memprof_config.pagesize, PROT_WRITE|PROT_READ|PROT_EXEC,
                MAP_ANON|MAP_PRIVATE, -1, 0);
 
     if (ret != MAP_FAILED) {
-      memset(ret, 0x90, pagesize);
+      memset(ret, 0x90, memprof_config.pagesize);
       return ret;
     }
   }
@@ -498,6 +490,25 @@ bin_type_member_offset(const char *type, const char *member)
 void
 bin_init()
 {
-  /* mach-o is so cool it needs no initialization */
+  void *file = NULL;
+  int index = 0;
+
+  memset(&mach_config, 0, sizeof(struct mach_config));
+
+  file = get_ruby_file_and_header_index(&index);
+
+  const struct mach_header_64 *hdr = (const struct mach_header_64*) file;
+  if (hdr->magic != MH_MAGIC_64)
+    errx(EX_SOFTWARE, "Magic for Ruby Mach-O file doesn't match");
+
+  mach_config.image_offset = _dyld_get_image_vmaddr_slide(index);
+
+  extract_symbol_table(hdr, &mach_config.symbol_table, &mach_config.string_table, &mach_config.symbol_count, &mach_config.string_table_size);
+
+  assert(mach_config.symbol_table != NULL);
+  assert(mach_config.string_table != NULL);
+  assert(mach_config.symbol_count > 0);
+
+  free(file);
 }
 #endif

data/ext/memprof.c

@@ -4,17 +4,15 @@
 #define _GNU_SOURCE
 #endif
 
-#include <err.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <sysexits.h>
-#include <sys/mman.h>
-#include <err.h>
 #include <assert.h>
+#include <err.h>
+#include <sysexits.h>
 
 #include <st.h>
 #include <intern.h>
@@ -22,22 +20,10 @@
 
 #include "arch.h"
 #include "bin_api.h"
+#include "tramp.h"
+#include "util.h"
 
 
-size_t pagesize;
-
-/*
-   trampoline specific stuff
- */
-struct tramp_st2_entry *tramp_table = NULL;
-size_t tramp_size = 0;
-
-/*
-   inline trampoline specific stuff
- */
-size_t inline_tramp_size = 0;
-struct inline_tramp_st2_entry *inline_tramp_table = NULL;
-
 /*
  * bleak_house stuff
  */
@@ -45,6 +31,8 @@ static VALUE eUnsupported;
 static int track_objs = 0;
 static st_table *objs = NULL;
 
+struct memprof_config memprof_config;
+
 struct obj_track {
   VALUE obj;
   char *source;
@@ -54,6 +42,7 @@ struct obj_track {
 static VALUE gc_hook;
 static void **ptr_to_rb_mark_table_add_filename = NULL;
 static void (*rb_mark_table_add_filename)(char*);
+static void (*rb_add_freelist)(VALUE);
 
 static int
 ree_sourcefile_mark_each(st_data_t key, st_data_t val, st_data_t arg)
@@ -106,7 +95,8 @@ newobj_tramp()
     tracker = malloc(sizeof(*tracker));
 
     if (tracker) {
-      if (ruby_current_node && ruby_current_node->nd_file && *ruby_current_node->nd_file) {
+      if (ruby_current_node && ruby_current_node->nd_file &&
+          *ruby_current_node->nd_file) {
         tracker->source = ruby_current_node->nd_file;
         tracker->line = nd_line(ruby_current_node);
       } else if (ruby_sourcefile) {
@@ -122,15 +112,14 @@ newobj_tramp()
       st_insert(objs, (st_data_t)ret, (st_data_t)tracker);
       rb_gc_enable();
     } else {
-      fprintf(stderr, "Warning, unable to allocate a tracker. You are running dangerously low on RAM!\n");
+      fprintf(stderr, "Warning, unable to allocate a tracker. "
+              "You are running dangerously low on RAM!\n");
     }
   }
 
   return ret;
 }
 
-static void (*rb_add_freelist)(VALUE);
-
 static void
 freelist_tramp(unsigned long rval)
 {
@@ -199,7 +188,7 @@ objs_tabulate(st_data_t key, st_data_t record, st_data_t arg)
 
 struct results {
   char **entries;
-  unsigned long num_entries;
+  size_t num_entries;
 };
 
 static int
@@ -251,7 +240,7 @@ memprof_stats(int argc, VALUE *argv, VALUE self)
 {
   st_table *tmp_table;
   struct results res;
-  int i;
+  size_t i;
   VALUE str;
   FILE *out = NULL;
 
@@ -318,7 +307,7 @@ memprof_track(int argc, VALUE *argv, VALUE self)
 #include "env.h"
 #include "re.h"
 
-yajl_gen_status
+static yajl_gen_status
 yajl_gen_cstr(yajl_gen gen, const char * str)
 {
   if (!str || str[0] == 0)
@@ -327,7 +316,7 @@ yajl_gen_cstr(yajl_gen gen, const char * str)
     return yajl_gen_string(gen, (unsigned char *)str, strlen(str));
 }
 
-yajl_gen_status
+static yajl_gen_status
 yajl_gen_format(yajl_gen gen, char *format, ...)
 {
   va_list args;
@@ -346,7 +335,7 @@ yajl_gen_format(yajl_gen gen, char *format, ...)
   return ret;
 }
 
-yajl_gen_status
+static yajl_gen_status
 yajl_gen_value(yajl_gen gen, VALUE obj)
 {
   if (FIXNUM_P(obj))
@@ -392,7 +381,7 @@ each_ivar(st_data_t key, st_data_t record, st_data_t arg)
   return ST_CONTINUE;
 }
 
-char *
+static char *
 nd_type_str(VALUE obj)
 {
   switch(nd_type(obj)) {
@@ -438,7 +427,7 @@ static VALUE (*rb_classname)(VALUE);
  *  print details on different types of nodes (nd_next, nd_lit, nd_nth, etc)
  */
 
-void
+static void
 obj_dump(VALUE obj, yajl_gen gen)
 {
   int type;
@@ -529,7 +518,7 @@ obj_dump(VALUE obj, yajl_gen gen)
 
       struct SCOPE *scope = (struct SCOPE *)obj;
       if (scope->local_tbl) {
-        int i = 1;
+        int i = 0;
         int n = scope->local_tbl[0];
         VALUE *list = &scope->local_vars[-1];
         VALUE cur = *list++;
@@ -542,9 +531,13 @@ obj_dump(VALUE obj, yajl_gen gen)
           yajl_gen_map_open(gen);
           while (n--) {
             cur = *list++;
+            i++;
+
+            if (!rb_is_local_id(scope->local_tbl[i]))
+              continue;
+
             yajl_gen_cstr(gen, scope->local_tbl[i] == 95 ? "_" : rb_id2name(scope->local_tbl[i]));
             yajl_gen_value(gen, cur);
-            i++;
           }
           yajl_gen_map_close(gen);
         }
@@ -566,9 +559,84 @@ obj_dump(VALUE obj, yajl_gen gen)
       yajl_gen_cstr(gen, "node_code");
       yajl_gen_integer(gen, nd_type(obj));
 
-      switch (nd_type(obj)) {
-        case NODE_SCOPE:
+      #define PRINT_ID(sub) yajl_gen_format(gen, ":%s", rb_id2name(RNODE(obj)->sub.id));
+      #define PRINT_VAL(sub) yajl_gen_value(gen, RNODE(obj)->sub.value);
+
+      int nd_type = nd_type(obj);
+      yajl_gen_cstr(gen, "n1");
+      switch(nd_type) {
+        case NODE_LVAR:
+        case NODE_DVAR:
+        case NODE_IVAR:
+        case NODE_CVAR:
+        case NODE_GVAR:
+        case NODE_CONST:
+        case NODE_ATTRSET:
+        case NODE_LASGN:
+        case NODE_IASGN:
+        case NODE_DASGN:
+        case NODE_CVASGN:
+        case NODE_CVDECL:
+        case NODE_GASGN:
+        case NODE_DASGN_CURR:
+        case NODE_BLOCK_ARG:
+          PRINT_ID(u1);
           break;
+
+        case NODE_SCOPE: {
+          ID *tbl = RNODE(obj)->nd_tbl;
+          yajl_gen_array_open(gen);
+          if (tbl) {
+            int size = tbl[0];
+            int i = 3;
+
+            for (; i < size+1; i++) {
+              yajl_gen_cstr(gen, tbl[i] == 95 ? "_" : rb_id2name(tbl[i]));
+            }
+          }
+          yajl_gen_array_close(gen);
+          break;
+        }
+
+        case NODE_CFUNC: {
+          const char *name = bin_find_symbol_name((void*)RNODE(obj)->u1.value);
+          yajl_gen_format(gen, "0x%x: %s", RNODE(obj)->u1.value, name ? name : "???");
+          break;
+        }
+
+        default:
+          PRINT_VAL(u1);
+      }
+
+      yajl_gen_cstr(gen, "n2");
+      switch(nd_type) {
+        case NODE_CALL:
+        case NODE_FBODY:
+        case NODE_DEFN:
+        case NODE_ATTRASGN:
+        case NODE_FCALL:
+        case NODE_VCALL:
+        case NODE_COLON2:
+        case NODE_COLON3:
+          PRINT_ID(u2);
+          break;
+
+        case NODE_NTH_REF:
+          yajl_gen_integer(gen, RNODE(obj)->u2.argc);
+          break;
+
+        default:
+          PRINT_VAL(u2);
+      }
+
+      yajl_gen_cstr(gen, "n3");
+      switch(nd_type) {
+        case NODE_ARGS:
+          yajl_gen_integer(gen, RNODE(obj)->u3.cnt);
+          break;
+
+        default:
+          PRINT_VAL(u3);
       }
       break;
 
@@ -737,7 +805,17 @@ objs_each_dump(st_data_t key, st_data_t record, st_data_t arg)
   return ST_CONTINUE;
 }
 
-void
+extern st_table *rb_global_tbl;
+
+static int
+globals_each_dump(st_data_t key, st_data_t record, st_data_t arg)
+{
+  yajl_gen_cstr((yajl_gen)arg, rb_id2name((ID)key));
+  yajl_gen_value((yajl_gen)arg, rb_gvar_get((void*)record));
+  return ST_CONTINUE;
+}
+
+static void
 json_print(void *ctx, const char * str, unsigned int len)
 {
   FILE *out = (FILE *)ctx;
@@ -786,28 +864,19 @@ memprof_dump(int argc, VALUE *argv, VALUE self)
 static VALUE
 memprof_dump_all(int argc, VALUE *argv, VALUE self)
 {
-  char *heaps = *(char**)bin_find_symbol("heaps",0);
-  int heaps_used = *(int*)bin_find_symbol("heaps_used",0);
+  if (memprof_config.heaps == NULL ||
+      memprof_config.heaps_used == NULL ||
+      memprof_config.sizeof_RVALUE == 0 ||
+      memprof_config.sizeof_heaps_slot == 0 ||
+      memprof_config.offset_heaps_slot_slot == -1 ||
+      memprof_config.offset_heaps_slot_limit == -1)
+    rb_raise(eUnsupported, "not enough config data to dump heap");
 
-#ifndef sizeof__RVALUE
-  size_t sizeof__RVALUE = bin_type_size("RVALUE");
-#endif
-#ifndef sizeof__heaps_slot
-  size_t sizeof__heaps_slot = bin_type_size("heaps_slot");
-#endif
-#ifndef offset__heaps_slot__limit
-  int offset__heaps_slot__limit = bin_type_member_offset("heaps_slot", "limit");
-#endif
-#ifndef offset__heaps_slot__slot
-  int offset__heaps_slot__slot = bin_type_member_offset("heaps_slot", "slot");
-#endif
+  char *heaps = *(char**)memprof_config.heaps;
+  int heaps_used = *(int*)memprof_config.heaps_used;
 
   char *p, *pend;
   int i, limit;
-
-  if (sizeof__RVALUE == 0 || sizeof__heaps_slot == 0)
-    rb_raise(eUnsupported, "could not find internal heap");
-
   VALUE str;
   FILE *out = NULL;
 
@@ -826,10 +895,26 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
 
   //yajl_gen_array_open(gen);
 
+  yajl_gen_map_open(gen);
+
+  yajl_gen_cstr(gen, "_id");
+  yajl_gen_cstr(gen, "globals");
+
+  yajl_gen_cstr(gen, "type");
+  yajl_gen_cstr(gen, "globals");
+
+  yajl_gen_cstr(gen, "variables");
+
+  yajl_gen_map_open(gen);
+  st_foreach(rb_global_tbl, globals_each_dump, (st_data_t)gen);
+  yajl_gen_map_close(gen);
+
+  yajl_gen_map_close(gen);
+
   for (i=0; i < heaps_used; i++) {
-    p = *(char**)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__slot);
-    limit = *(int*)(heaps + (i * sizeof__heaps_slot) + offset__heaps_slot__limit);
-    pend = p + (sizeof__RVALUE * limit);
+    p = *(char**)(heaps + (i * memprof_config.sizeof_heaps_slot) + memprof_config.offset_heaps_slot_slot);
+    limit = *(int*)(heaps + (i * memprof_config.sizeof_heaps_slot) + memprof_config.offset_heaps_slot_limit);
+    pend = p + (memprof_config.sizeof_RVALUE * limit);
 
     while (p < pend) {
       if (RBASIC(p)->flags) {
@@ -841,7 +926,7 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
         while(fputc('\n', out ? out : stdout) == EOF);
       }
 
-      p += sizeof__RVALUE;
+      p += memprof_config.sizeof_RVALUE;
     }
   }
 
@@ -858,122 +943,134 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
 }
 
 static void
-create_tramp_table()
-{
-  int i = 0;
-  void *region = NULL;
-   size_t tramp_sz = 0, inline_tramp_sz = 0;
-
-  void *ent = arch_get_st2_tramp(&tramp_sz);
-  void *inline_ent = arch_get_inline_st2_tramp(&inline_tramp_sz);
-
-  if ((region = bin_allocate_page()) == MAP_FAILED)
-    errx(EX_SOFTWARE, "Failed to allocate memory for stage 1 trampolines.");
-
-  tramp_table = region;
-  inline_tramp_table = region + pagesize/2;
-
-  for (i = 0; i < (pagesize/2)/tramp_sz; i++) {
-    memcpy(tramp_table + i, ent, tramp_sz);
-  }
-
-  for (i = 0; i < (pagesize/2)/inline_tramp_sz; i++) {
-    memcpy(inline_tramp_table + i, inline_ent, inline_tramp_sz);
-  }
+init_memprof_config_base() {
+  memset(&memprof_config, 0, sizeof(memprof_config));
+  memprof_config.offset_heaps_slot_limit = -1;
+  memprof_config.offset_heaps_slot_slot = -1;
+  memprof_config.pagesize = getpagesize();
+  assert(memprof_config.pagesize);
 }
 
-#define FREELIST_INLINES (3)
-
 static void
-hook_freelist(int entry)
-{
-  size_t sizes[FREELIST_INLINES], i = 0;
-  void *freelist_inliners[FREELIST_INLINES];
-  void *freelist = NULL;
-  unsigned char *byte = NULL;
-  int tramps_completed = 0;
-
-  freelist_inliners[0] = bin_find_symbol("gc_sweep", &sizes[0]);
-  /* sometimes gc_sweep gets inlined in garbage_collect */
-  /* on REE, it gets inlined into garbage_collect_0 */
-  if (!freelist_inliners[0])
-    freelist_inliners[0] = bin_find_symbol("garbage_collect_0", &sizes[0]);
-  if (!freelist_inliners[0])
-    freelist_inliners[0] = bin_find_symbol("garbage_collect", &sizes[0]);
-  if (!freelist_inliners[0]) {
-    /* couldn't find anything containing gc_sweep. */
-    errx(EX_SOFTWARE, "Couldn't find gc_sweep or garbage_collect!");
+init_memprof_config_extended() {
+  /* If we don't have add_freelist, find the functions it gets inlined into */
+  memprof_config.add_freelist               = bin_find_symbol("add_freelist", NULL);
+
+  /*
+   * Sometimes gc_sweep gets inlined in garbage_collect
+   * (e.g., on REE it gets inlined into garbage_collect_0).
+   */
+  if (memprof_config.add_freelist == NULL) {
+    memprof_config.gc_sweep                 = bin_find_symbol("gc_sweep",
+                                                &memprof_config.gc_sweep_size);
+    if (memprof_config.gc_sweep == NULL)
+      memprof_config.gc_sweep               = bin_find_symbol("garbage_collect_0",
+                                                &memprof_config.gc_sweep_size);
+    if (memprof_config.gc_sweep == NULL)
+      memprof_config.gc_sweep               = bin_find_symbol("garbage_collect",
+                                                &memprof_config.gc_sweep_size);
+
+    memprof_config.finalize_list            = bin_find_symbol("finalize_list",
+                                                &memprof_config.finalize_list_size);
+    memprof_config.rb_gc_force_recycle      = bin_find_symbol("rb_gc_force_recycle",
+                                                &memprof_config.rb_gc_force_recycle_size);
+    memprof_config.freelist                 = bin_find_symbol("freelist", NULL);
   }
 
-  freelist_inliners[1] = bin_find_symbol("finalize_list", &sizes[1]);
-  if (!freelist_inliners[1])
-    errx(EX_SOFTWARE, "Couldn't find finalize_list!");
-
-  freelist_inliners[2] = bin_find_symbol("rb_gc_force_recycle", &sizes[2]);
-  if (!freelist_inliners[2])
-    errx(EX_SOFTWARE, "Couldn't find rb_gc_force_recycle!");
-
-  freelist = bin_find_symbol("freelist", NULL);
-  if (!freelist)
-    errx(EX_SOFTWARE, "Couldn't find freelist!");
-
-  /* start the search for places to insert the inline tramp */
-
-  byte = freelist_inliners[i];
-
-  while (i < FREELIST_INLINES) {
-    if (arch_insert_inline_st2_tramp(byte, freelist, freelist_tramp,
-        &inline_tramp_table[entry]) == 0) {
-      /* insert occurred, so increment internal counters for the tramp table */
-      entry++;
-      inline_tramp_size++;
-
-      /* add_freelist() only gets inlined *ONCE* into any of the 3 functions that we're scanning, */
-      /* so move on to the next 'inliner' when after we tramp the first instruction we find. */
-      /* REE's gc_sweep has 2 calls, but this gets optimized into a single inlining and a jmp to it */
-      /* older patchlevels of 1.8.7 don't have an add_freelist(), but the instruction should be the same */
-      tramps_completed++;
-      i++;
-      byte = freelist_inliners[i];
-      continue;
-    }
+  memprof_config.classname                  = bin_find_symbol("classname", NULL);
+  memprof_config.rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL);
+
+  /* Stuff for dumping the heap */
+  memprof_config.heaps                      = bin_find_symbol("heaps", NULL);
+  memprof_config.heaps_used                 = bin_find_symbol("heaps_used", NULL);
+#ifdef sizeof__RVALUE
+  memprof_config.sizeof_RVALUE              = sizeof__RVALUE;
+#else
+  memprof_config.sizeof_RVALUE              = bin_type_size("RVALUE");
+#endif
+#ifdef sizeof__heaps_slot
+  memprof_config.sizeof_heaps_slot          = sizeof__heaps_slot;
+#else
+  memprof_config.sizeof_heaps_slot          = bin_type_size("heaps_slot");
+#endif
+#ifdef offset__heaps_slot__limit
+  memprof_config.offset_heaps_slot_limit    = offset__heaps_slot__limit;
+#else
+  memprof_config.offset_heaps_slot_limit    = bin_type_member_offset("heaps_slot", "limit");
+#endif
+#ifdef offset__heaps_slot__slot
+  memprof_config.offset_heaps_slot_slot     = offset__heaps_slot__slot;
+#else
+  memprof_config.offset_heaps_slot_slot     = bin_type_member_offset("heaps_slot", "slot");
+#endif
 
-    /* if we've looked at all the bytes in this function... */
-    if (((void *)byte - freelist_inliners[i]) >= sizes[i]) {
-      /* move on to the next function */
-      i++;
-      byte = freelist_inliners[i];
+  int heap_errors_printed = 0;
+
+  if (memprof_config.heaps == NULL)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to locate heaps\n");
+  if (memprof_config.heaps_used == NULL)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to locate heaps_used\n");
+  if (memprof_config.sizeof_RVALUE == 0)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to determine sizeof(RVALUE)\n");
+  if (memprof_config.sizeof_heaps_slot == 0)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to determine sizeof(heaps_slot)\n");
+  if (memprof_config.offset_heaps_slot_limit == -1)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to determine offset of heaps_slot->limit\n");
+  if (memprof_config.offset_heaps_slot_slot == -1)
+    heap_errors_printed += fprintf(stderr,
+      "Failed to determine offset of heaps_slot->slot\n");
+
+  if (heap_errors_printed)
+    fprintf(stderr, "You won't be able to dump your heap!\n");
+
+  int errors_printed = 0;
+
+  /* If we can't find add_freelist, we need to make sure we located the functions that it gets inlined into. */
+  if (memprof_config.add_freelist == NULL) {
+    if (memprof_config.gc_sweep == NULL) {
+      errors_printed += fprintf(stderr,
+        "Failed to locate add_freelist (it's probably inlined, but we couldn't find it there either!)\n");
+      errors_printed += fprintf(stderr,
+        "Failed to locate gc_sweep, garbage_collect_0, or garbage_collect\n");
     }
-    byte++;
+    if (memprof_config.gc_sweep_size == 0)
+      errors_printed += fprintf(stderr,
+        "Failed to determine the size of gc_sweep/garbage_collect_0/garbage_collect: %ld\n",
+        memprof_config.gc_sweep_size);
+    if (memprof_config.finalize_list == NULL)
+      errors_printed += fprintf(stderr,
+        "Failed to locate finalize_list\n");
+    if (memprof_config.finalize_list_size == 0)
+      errors_printed += fprintf(stderr,
+        "Failed to determine the size of finalize_list: %ld\n",
+        memprof_config.finalize_list_size);
+    if (memprof_config.rb_gc_force_recycle == NULL)
+      errors_printed += fprintf(stderr,
+        "Failed to locate rb_gc_force_recycle\n");
+    if (memprof_config.rb_gc_force_recycle_size == 0)
+      errors_printed += fprintf(stderr,
+        "Failed to determine the size of rb_gc_force_recycle: %ld\n",
+        memprof_config.rb_gc_force_recycle_size);
+    if (memprof_config.freelist == NULL)
+      errors_printed += fprintf(stderr,
+        "Failed to locate freelist\n");
   }
 
-  if (tramps_completed != 3)
-    errx(EX_SOFTWARE, "Inline add_freelist tramp insertion failed! Only inserted %d tramps.", tramps_completed);
-}
+  if (memprof_config.classname == NULL)
+    errors_printed += fprintf(stderr,
+      "Failed to locate classname\n");
 
-static void
-insert_tramp(const char *trampee, void *tramp)
-{
-  void *trampee_addr = bin_find_symbol(trampee, NULL);
-  int inline_ent = inline_tramp_size;
-
-  if (trampee_addr == NULL) {
-    if (strcmp("add_freelist", trampee) == 0) {
-      /* XXX super hack */
-      inline_tramp_size++;
-      hook_freelist(inline_ent);
-    } else {
-      errx(EX_SOFTWARE, "Failed to locate required symbol %s", trampee);
-    }
-  } else {
-    if (strcmp("add_freelist", trampee) == 0) {
-      rb_add_freelist = trampee_addr;
-    }
-
-    tramp_table[tramp_size].addr = tramp;
-    if (bin_update_image(trampee, &tramp_table[tramp_size]) != 0)
-      errx(EX_SOFTWARE, "Failed to insert tramp for %s", trampee);
-    tramp_size++;
+  if (errors_printed) {
+    VALUE ruby_build_info = rb_eval_string("require 'rbconfig'; RUBY_DESCRIPTION + '\n' + RbConfig::CONFIG['CFLAGS'];");
+    /* who knows what could happen */
+    if (TYPE(ruby_build_info) == T_STRING)
+      fprintf(stderr, "%s\n", StringValuePtr(ruby_build_info));
+    errx(EX_SOFTWARE, "Memprof does not have enough data to run. Please email this output to bugs@memprof.com");
   }
 }
 
@@ -990,21 +1087,24 @@ Init_memprof()
   rb_define_singleton_method(memprof, "dump", memprof_dump, -1);
   rb_define_singleton_method(memprof, "dump_all", memprof_dump_all, -1);
 
-  pagesize = getpagesize();
   objs = st_init_numtable();
+  init_memprof_config_base();
   bin_init();
+  init_memprof_config_extended();
   create_tramp_table();
-  rb_add_freelist = NULL;
 
   gc_hook = Data_Wrap_Struct(rb_cObject, sourcefile_marker, NULL, NULL);
   rb_global_variable(&gc_hook);
-  ptr_to_rb_mark_table_add_filename = bin_find_symbol("rb_mark_table_add_filename", NULL);
+
+  rb_classname = memprof_config.classname;
+  rb_add_freelist = memprof_config.add_freelist;
+  ptr_to_rb_mark_table_add_filename = memprof_config.rb_mark_table_add_filename;
+
+  assert(rb_classname);
 
   insert_tramp("rb_newobj", newobj_tramp);
   insert_tramp("add_freelist", freelist_tramp);
 
-  rb_classname = bin_find_symbol("classname", 0);
-
   if (getenv("MEMPROF"))
     track_objs = 1;