memprof 0.2.5 → 0.2.6

data/ext/mach.c

@@ -18,21 +18,25 @@
 #include <mach-o/ldsyms.h>
 #include <mach-o/nlist.h>
 
-// The jmp instructions in the dyld stub table are 6 bytes,
-// 2 bytes for the instruction and 4 bytes for the offset operand
-//
-// This jmp does not jump to the offset operand, but instead
-// looks up an absolute address stored at the offset and jumps to that.
-// Offset is the offset from the address of the _next_ instruction sequence.
-//
-// We need to deference the address at this offset to find the real
-// target of the dyld stub entry.
+/*
+ * The jmp instructions in the dyld stub table are 6 bytes,
+ * 2 bytes for the instruction and 4 bytes for the offset operand
+ *
+ * This jmp does not jump to the offset operand, but instead
+ * looks up an absolute address stored at the offset and jumps to that.
+ * Offset is the offset from the address of the _next_ instruction sequence.
+ *
+ * We need to deference the address at this offset to find the real
+ * target of the dyld stub entry.
+ */
 
 struct dyld_stub_entry {
   unsigned char jmp[2];
   uint32_t offset;
 } __attribute((__packed__));
 
+/* Return the jmp target of a stub entry */
+
 static inline void*
 get_dyld_stub_target(struct dyld_stub_entry *entry) {
   // If the instructions match up, then dereference the address at the offset
@@ -42,14 +46,23 @@ get_dyld_stub_target(struct dyld_stub_entry *entry) {
   return NULL;
 }
 
+/* Set the jmp target of a stub entry */
+
 static inline void
 set_dyld_stub_target(struct dyld_stub_entry *entry, void *addr) {
   *((void**)((void*)(entry + 1) + entry->offset)) = addr;
 }
 
-static void
+/*
+ * Search all entries in a stub table for the stub that corresponds to trampee_addr,
+ * and overwrite to point at our trampoline code.
+ * Returns 0 if any tramps were successfully inserted.
+ */
+
+static int
 update_dyld_stub_table(void *table, uint64_t len, void *trampee_addr, struct tramp_st2_entry *tramp)
 {
+  int ret = -1;
   struct dyld_stub_entry *entry = (struct dyld_stub_entry*) table;
   void *max_addr = table + len;
 
@@ -57,17 +70,20 @@ update_dyld_stub_table(void *table, uint64_t len, void *trampee_addr, struct tra
     void *target = get_dyld_stub_target(entry);
     if (trampee_addr == target) {
       set_dyld_stub_target(entry, tramp->addr);
+      ret = 0;
     }
   }
+  return ret;
 }
 
-
-// This function tells us if the passed stub table address
-// is something that we should try to update (by looking at it's filename)
+/*
+ * This function tells us if the passed stub table address
+ * is something that we should try to update (by looking at it's filename)
+ * Only try to update dyld stub entries in files that match "libruby.dylib" or "*.bundle" (other C gems)
+ */
 
 static inline int
 should_update_stub_table(void *addr) {
-  // Only try to update dyld stub entries in files that match "libruby.dylib" or "*.bundle" (other C gems)
   Dl_info info;
 
   if (dladdr(addr, &info)) {
@@ -88,54 +104,94 @@ should_update_stub_table(void *addr) {
   return 0;
 }
 
-static void
+/*
+ * Attempts to update all necessary code in a given 'section' of a Mach-O image, to redirect
+ * the given function to the trampoline. This function takes care of both normal calls as well as
+ * shared library cases.
+ * Returns 0 if any tramps were successfully inserted.
+ */
+
+static int
 update_mach_section(const struct mach_header *header, const struct section_64 *sect, intptr_t slide, void *trampee_addr, struct tramp_st2_entry *tramp) {
+  int ret = -1;
   uint64_t len = 0;
+  /*
+   * We should be able to calculate this information from the section_64 struct ourselves,
+   * but I encountered problems going that route, so using this helper function is fine.
+   *
+   * The segment "__TEXT" means "executable code and other read-only data." Segments have "sections", like "__text", "__const", etc.
+   * We want "__text" for normal function calls, and "__symbol_stub" (with variations like "__symbol_stub1") for shared lib stubs.
+   */
   void *section = getsectdatafromheader_64((const struct mach_header_64*)header, "__TEXT", sect->sectname, &len) + slide;
 
   if (strncmp(sect->sectname, "__symbol_stub", 13) == 0) {
-    if (should_update_stub_table(section))
-      update_dyld_stub_table(section, sect->size, trampee_addr, tramp);
+    if (should_update_stub_table(section)) {
+      if (update_dyld_stub_table(section, sect->size, trampee_addr, tramp) == 0) {
+        ret = 0;
+      }
+    }
+    return ret;
   }
 
+  /* TODO: check the filename just like we do above for stub sections. No reason to look at unrelated files. */
   if (strcmp(sect->sectname, "__text") == 0) {
     size_t count = 0;
     for(; count < len; section++, count++) {
-      if (arch_insert_st1_tramp(section, trampee_addr, tramp)) {
-        // printf("tramped %p for %s\n", byte, trampee);
+      if (arch_insert_st1_tramp(section, trampee_addr, tramp) == 0) {
+        ret = 0;
       }
     }
   }
+  return ret;
 }
 
-static void
+/*
+ * For a given Mach-O image, iterates over all segments and their sections, passing
+ * the sections to update_mach_section for potential tramping.
+ * Returns 0 if any tramps were successfully inserted.
+ */
+
+static int
 update_bin_for_mach_header(const struct mach_header *header, intptr_t slide, void *trampee_addr, struct tramp_st2_entry *tramp) {
+  int ret = -1;
   int i, j;
   int lc_count = header->ncmds;
 
-  // this as a char* because we need to step it forward by an arbitrary number of bytes
+  /* Load commands start immediately after the Mach header.
+   * This as a char* because we need to step it forward by an arbitrary number of bytes,
+   * specified in the 'cmdsize' field of each load command.
+   */
   const char *lc = ((const char*) header) + sizeof(struct mach_header_64);
 
-  // Check all the load commands in the object to see if they are segment commands
+  /* Check all the load commands in the object to see if they are segment commands */
   for (i = 0; i < lc_count; i++, lc += ((struct load_command*)lc)->cmdsize) {
     if (((struct load_command*)lc)->cmd == LC_SEGMENT_64) {
+      /* If it's a segment command, we want to iterate over each of it's sections. */
       const struct segment_command_64 *seg = (const struct segment_command_64 *) lc;
       const struct section_64 * sect = (const struct section_64*)(lc + sizeof(struct segment_command_64));
+      /* Sections start immediately after the segment_command, and are included in the segment's "cmdsize" */
       int section_count = (seg->cmdsize - sizeof(struct segment_command_64)) / sizeof(struct section_64);
 
+      /* Attempt to tramp the sections */
       for (j=0; j < section_count; j++, sect++) {
-        update_mach_section(header, sect, slide, trampee_addr, tramp);
+        if (update_mach_section(header, sect, slide, trampee_addr, tramp) == 0) {
+          ret = 0;
+        }
       }
     }
   }
+  return ret;
 }
 
+/* This function takes a pointer to an *in process* mach_header_64
+ * and returns it's image index, which is required to specify the image
+ * in many dyld functions.
+ *
+ * This will NOT work for mach objects read manually from a file, since
+ * that's just arbitrary data and the dyld system knows nothing about it.
+ */
 
-// This function takes a pointer to a loaded *in memory* mach_header_64
-// and returns it's image index. This will NOT work for mach objects read
-// from a file.
-
-int
+static int
 find_dyld_image_index(const struct mach_header_64 *hdr) {
   int i;
 
@@ -147,16 +203,20 @@ find_dyld_image_index(const struct mach_header_64 *hdr) {
   errx(EX_SOFTWARE, "Could not find image index");
 }
 
-
-// This function returns a buffer containing the file that is presumed
-// to be either the Ruby executable or libruby. (Wherever rb_newobj is found.)
-//
-// The passed pointer index is set to the image index for the associated
-// in-memory mach image.
-//
-// !!! The pointer returned by this function must be freed !!!
-
-void *
+/*
+ * This function returns a buffer containing the file that is presumed
+ * to be either the Ruby executable or libruby. (Wherever rb_newobj is found.)
+ *
+ * The passed pointer index is set to the dyld image index for the associated
+ * in-process mach image.
+ *
+ * The reason that we read in the file is because the symbol table is not loaded
+ * into memory with everything else at load time (at least not anywhere I can find).
+ *
+ * !!! The pointer returned by this function must be freed !!!
+ */
+
+static void *
 get_ruby_file_and_header_index(int *index) {
   void *ptr = NULL;
   void *buf = NULL;
@@ -189,11 +249,12 @@ get_ruby_file_and_header_index(int *index) {
   return buf;
 }
 
+/*
+ * This function compares two nlist_64 structures by their n_value field (address, usually).
+ * It is used by qsort in build_sorted_nlist_table.
+ */
 
-// This function compares two nlist_64 structures by their n_value field (address)
-// used by qsort in build_sorted_nlist_table
-
-int
+static int
 nlist_cmp(const void *obj1, const void *obj2) {
   const struct nlist_64 *nlist1 = *(const struct nlist_64**) obj1;
   const struct nlist_64 *nlist2 = *(const struct nlist_64**) obj2;
@@ -206,14 +267,15 @@ nlist_cmp(const void *obj1, const void *obj2) {
     return 1;
 }
 
+/*
+ * 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.
+ *
+ * !!! The pointer returned by this function must be freed !!!
+ */
 
-// This function returns an array of pointers to nlist_64 entries in the symbol table
-// of the file 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.
-//
-// !!! The pointer returned by this function must be freed !!!
-
-const struct nlist_64 **
+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;
   uint32_t i, j;
@@ -225,6 +287,7 @@ build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint
       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);
 
+      /* TODO: qsort this table *IN PLACE* instead of making a copy of it. */
       base = malloc(sc->nsyms * sizeof(struct nlist_64*));
 
       for (j = 0; j < sc->nsyms; j++)
@@ -242,9 +305,25 @@ build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint
   errx(EX_SOFTWARE, "Unable to find LC_SYMTAB");
 }
 
+/*
+ * 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.
+ */
+
 void *
-bin_find_symbol(char *symbol, size_t *size) {
-  // Correctly prefix the symbol with a '_' (whats a prettier way to do this?)
+bin_find_symbol(const char *symbol, size_t *size) {
+  /* Correctly prefix the symbol with a '_' (whats a prettier way to do this?) */
   size_t len = strlen(symbol);
   char real_symbol[len + 2];
   memcpy(real_symbol, "_", 1);
@@ -265,6 +344,10 @@ bin_find_symbol(char *symbol, size_t *size) {
     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++) {
@@ -273,11 +356,17 @@ bin_find_symbol(char *symbol, size_t *size) {
 
     if (strcmp(real_symbol, string) == 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));
 
       if (size) {
         const struct nlist_64 *next_entry = NULL;
 
+        /*
+         * There can be multiple entries in the symbol table with the same n_value (address).
+         * This means that the 'next' one isn't always good enough. We have to make sure it's
+         * really a different symbol.
+         */
         j = 1;
         while (next_entry == NULL) {
           const struct nlist_64 *tmp_entry = nlist_table[i + j];
@@ -286,6 +375,11 @@ bin_find_symbol(char *symbol, size_t *size) {
           j++;
         }
 
+        /*
+         * Subtract our address from the address of the next symbol to get it's rough size.
+         * My observation is that the start of the next symbol will be padded to 16 byte alignment from the end of this one.
+         * This should be fine, since the point of getting the size is just to minimize scan area for tramp insertions.
+         */
         *size = (next_entry->n_value - addr);
       }
       break;
@@ -297,9 +391,26 @@ bin_find_symbol(char *symbol, size_t *size) {
   return ptr;
 }
 
-void
-bin_update_image(int entry, char *trampee, struct tramp_st2_entry *tramp)
+/*
+ * I will explain bin_update_image with imaginary Ruby code:
+ *
+ * Process.mach_images.each do |image|
+ *   image.segments.each do |segment|
+ *     segment.sections.each do |section|
+ *       if section.name == "__text"
+ *         tramp_normal_callsites(section)
+ *       elsif section.name =~ /__symbol_stub/ && image.filename =~ /libruby\.dylib|bundle/
+ *         tramp_dyld_stubs(section)
+ *       end
+ *     end
+ *   end
+ * end
+ */
+
+int
+bin_update_image(const char *trampee, struct tramp_st2_entry *tramp)
 {
+  int ret = -1;
   int i;
   int header_count = _dyld_image_count();
   void *trampee_addr = bin_find_symbol(trampee, NULL);
@@ -310,8 +421,10 @@ bin_update_image(int entry, char *trampee, struct tramp_st2_entry *tramp)
     if ((void*)current_hdr == &_mh_bundle_header)
       continue;
 
-    update_bin_for_mach_header(current_hdr, _dyld_get_image_vmaddr_slide(i), trampee_addr, tramp);
+    if (update_bin_for_mach_header(current_hdr, _dyld_get_image_vmaddr_slide(i), trampee_addr, tramp) == 0)
+      ret = 0;
   }
+  return ret;
 }
 
 void *
@@ -332,14 +445,14 @@ bin_allocate_page()
   return NULL;
 }
 
-int
-bin_type_size(char *type)
+size_t
+bin_type_size(const char *type)
 {
-  return -1;
+  return 0;
 }
 
 int
-bin_type_member_offset(char *type, char *member)
+bin_type_member_offset(const char *type, const char *member)
 {
   return -1;
 }

data/ext/memprof.c

@@ -51,6 +51,51 @@ struct obj_track {
   int line;
 };
 
+static VALUE gc_hook;
+static void **ptr_to_rb_mark_table_add_filename = NULL;
+static void (*rb_mark_table_add_filename)(char*);
+
+static int
+ree_sourcefile_mark_each(st_data_t key, st_data_t val, st_data_t arg)
+{
+  struct obj_track *tracker = (struct obj_track *)val;
+  assert(tracker != NULL);
+
+  if (tracker->source)
+    rb_mark_table_add_filename(tracker->source);
+  return ST_CONTINUE;
+}
+
+static int
+mri_sourcefile_mark_each(st_data_t key, st_data_t val, st_data_t arg)
+{
+  struct obj_track *tracker = (struct obj_track *)val;
+  assert(tracker != NULL);
+
+  if (tracker->source)
+    (tracker->source)[-1] = 1;
+  return ST_CONTINUE;
+}
+
+/* Accomodate the different source file marking techniques of MRI and REE.
+ *
+ * The function pointer for REE changes depending on whether COW is enabled,
+ * which can be toggled at runtime. We need to deference it to get the
+ * real function every time we come here, as it may have changed.
+ */
+
+static void
+sourcefile_marker()
+{
+  if (ptr_to_rb_mark_table_add_filename) {
+    rb_mark_table_add_filename = *ptr_to_rb_mark_table_add_filename;
+    assert(rb_mark_table_add_filename != NULL);
+    st_foreach(objs, ree_sourcefile_mark_each, (st_data_t)NULL);
+  } else {
+    st_foreach(objs, mri_sourcefile_mark_each, (st_data_t)NULL);
+  }
+}
+
 static VALUE
 newobj_tramp()
 {
@@ -62,13 +107,13 @@ newobj_tramp()
 
     if (tracker) {
       if (ruby_current_node && ruby_current_node->nd_file && *ruby_current_node->nd_file) {
-        tracker->source = strdup(ruby_current_node->nd_file);
+        tracker->source = ruby_current_node->nd_file;
         tracker->line = nd_line(ruby_current_node);
       } else if (ruby_sourcefile) {
-        tracker->source = strdup(ruby_sourcefile);
+        tracker->source = ruby_sourcefile;
         tracker->line = ruby_sourceline;
       } else {
-        tracker->source = strdup("__null__");
+        tracker->source = NULL;
         tracker->line = 0;
       }
 
@@ -98,7 +143,6 @@ freelist_tramp(unsigned long rval)
   if (track_objs && objs) {
     st_delete(objs, (st_data_t *) &rval, (st_data_t *) &tracker);
     if (tracker) {
-      free(tracker->source);
       free(tracker);
     }
   }
@@ -108,7 +152,6 @@ static int
 objs_free(st_data_t key, st_data_t record, st_data_t arg)
 {
   struct obj_track *tracker = (struct obj_track *)record;
-  free(tracker->source);
   free(tracker);
   return ST_DELETE;
 }
@@ -121,6 +164,7 @@ objs_tabulate(st_data_t key, st_data_t record, st_data_t arg)
   char *source_key = NULL;
   unsigned long count = 0;
   char *type = NULL;
+  int bytes_printed = 0;
 
   switch (TYPE(tracker->obj)) {
     case T_NONE:
@@ -143,7 +187,8 @@ objs_tabulate(st_data_t key, st_data_t record, st_data_t arg)
       }
   }
 
-  asprintf(&source_key, "%s:%d:%s", tracker->source, tracker->line, type);
+  bytes_printed = asprintf(&source_key, "%s:%d:%s", tracker->source ? tracker->source : "__null__", tracker->line, type);
+  assert(bytes_printed != -1);
   st_lookup(table, (st_data_t)source_key, (st_data_t *)&count);
   if (st_insert(table, (st_data_t)source_key, ++count)) {
     free(source_key);
@@ -163,8 +208,10 @@ objs_to_array(st_data_t key, st_data_t record, st_data_t arg)
   struct results *res = (struct results *)arg;
   unsigned long count = (unsigned long)record;
   char *source = (char *)key;
-  
-  asprintf(&(res->entries[res->num_entries++]), "%7li %s", count, source);
+  int bytes_printed = 0;
+
+  bytes_printed = asprintf(&(res->entries[res->num_entries++]), "%7li %s", count, source);
+  assert(bytes_printed != -1);
 
   free(source);
   return ST_DELETE;
@@ -285,10 +332,13 @@ yajl_gen_format(yajl_gen gen, char *format, ...)
 {
   va_list args;
   char *str;
+  int bytes_printed = 0;
+
   yajl_gen_status ret;
 
   va_start(args, format);
-  vasprintf(&str, format, args);
+  bytes_printed = vasprintf(&str, format, args);
+  assert(bytes_printed != -1);
   va_end(args);
 
   ret = yajl_gen_string(gen, (unsigned char *)str, strlen(str));
@@ -423,6 +473,16 @@ obj_dump(VALUE obj, yajl_gen gen)
       }
       break;
 
+    case T_STRUCT:
+      yajl_gen_cstr(gen, "struct");
+
+      yajl_gen_cstr(gen, "class");
+      yajl_gen_value(gen, RBASIC(obj)->klass);
+
+      yajl_gen_cstr(gen, "class_name");
+      yajl_gen_cstr(gen, rb_obj_classname(obj));
+      break;
+
     case T_FILE:
       yajl_gen_cstr(gen, "file");
       break;
@@ -730,10 +790,10 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
   int heaps_used = *(int*)bin_find_symbol("heaps_used",0);
 
 #ifndef sizeof__RVALUE
-  int sizeof__RVALUE = bin_type_size("RVALUE");
+  size_t sizeof__RVALUE = bin_type_size("RVALUE");
 #endif
 #ifndef sizeof__heaps_slot
-  int sizeof__heaps_slot = bin_type_size("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");
@@ -745,7 +805,7 @@ memprof_dump_all(int argc, VALUE *argv, VALUE self)
   char *p, *pend;
   int i, limit;
 
-  if (sizeof__RVALUE < 0 || sizeof__heaps_slot < 0)
+  if (sizeof__RVALUE == 0 || sizeof__heaps_slot == 0)
     rb_raise(eUnsupported, "could not find internal heap");
 
   VALUE str;
@@ -807,10 +867,8 @@ create_tramp_table()
   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) {
-    fprintf(stderr, "Failed to allocate memory for stage 1 trampolines.\n");
-    return;
-  }
+  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;
@@ -844,27 +902,20 @@ hook_freelist(int entry)
     freelist_inliners[0] = bin_find_symbol("garbage_collect", &sizes[0]);
   if (!freelist_inliners[0]) {
     /* couldn't find anything containing gc_sweep. */
-    fprintf(stderr, "Couldn't find gc_sweep or garbage_collect!\n");
-    return;
+    errx(EX_SOFTWARE, "Couldn't find gc_sweep or garbage_collect!");
   }
 
   freelist_inliners[1] = bin_find_symbol("finalize_list", &sizes[1]);
-  if (!freelist_inliners[1]) {
-    fprintf(stderr, "Couldn't find finalize_list!\n");
-    /* XXX continue or exit? */
-  }
+  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]) {
-    fprintf(stderr, "Couldn't find rb_gc_force_recycle!\n");
-    /* XXX continue or exit? */
-  }
+  if (!freelist_inliners[2])
+    errx(EX_SOFTWARE, "Couldn't find rb_gc_force_recycle!");
 
   freelist = bin_find_symbol("freelist", NULL);
-  if (!freelist) {
-    fprintf(stderr, "Couldn't find freelist!\n");
-    return;
-  }
+  if (!freelist)
+    errx(EX_SOFTWARE, "Couldn't find freelist!");
 
   /* start the search for places to insert the inline tramp */
 
@@ -896,14 +947,14 @@ hook_freelist(int entry)
     byte++;
   }
 
-  assert(tramps_completed == 3);
+  if (tramps_completed != 3)
+    errx(EX_SOFTWARE, "Inline add_freelist tramp insertion failed! Only inserted %d tramps.", tramps_completed);
 }
 
 static void
-insert_tramp(char *trampee, void *tramp)
+insert_tramp(const char *trampee, void *tramp)
 {
   void *trampee_addr = bin_find_symbol(trampee, NULL);
-  int entry = tramp_size;
   int inline_ent = inline_tramp_size;
 
   if (trampee_addr == NULL) {
@@ -912,7 +963,7 @@ insert_tramp(char *trampee, void *tramp)
       inline_tramp_size++;
       hook_freelist(inline_ent);
     } else {
-      return;
+      errx(EX_SOFTWARE, "Failed to locate required symbol %s", trampee);
     }
   } else {
     if (strcmp("add_freelist", trampee) == 0) {
@@ -920,7 +971,8 @@ insert_tramp(char *trampee, void *tramp)
     }
 
     tramp_table[tramp_size].addr = tramp;
-    bin_update_image(entry, trampee, &tramp_table[tramp_size]);
+    if (bin_update_image(trampee, &tramp_table[tramp_size]) != 0)
+      errx(EX_SOFTWARE, "Failed to insert tramp for %s", trampee);
     tramp_size++;
   }
 }
@@ -944,6 +996,10 @@ Init_memprof()
   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);
+
   insert_tramp("rb_newobj", newobj_tramp);
   insert_tramp("add_freelist", freelist_tramp);