memprof 0.2.6 → 0.2.7

data/ext/bin_api.h

@@ -39,6 +39,18 @@ bin_init();
 void *
 bin_find_symbol(const char *sym, size_t *size);
 
+/*
+ * bin_find_symbol_name - find a symbol's name
+ *
+ * Given:
+ *  - sym - a symbol address
+ *
+ * This function will search for the symbol sym and return its name if
+ * found, or NULL if the symbol could not be found.
+ */
+const char *
+bin_find_symbol_name(void *sym);
+
 /*
  * bin_allocate_page - allocate a page suitable for trampolines
  *

data/ext/elf.c

@@ -301,6 +301,58 @@ bin_find_symbol(const char *sym, size_t *size)
   return do_bin_find_symbol(sym, size, ruby_info);
 }
 
+/*
+ * do_bin_find_symbol_name - internal symbol name lookup function.
+ *
+ * Given:
+ *  - sym - the symbol address to look up
+ *  - elf - an elf information structure
+ *
+ * This function will return the name of the symbol
+ * or NULL if nothing can be found.
+ */
+static const char *
+do_bin_find_symbol_name(void *sym, struct elf_info *elf)
+{
+  char *name = NULL;
+  void *ptr;
+
+  assert(sym != NULL);
+  assert(elf != NULL);
+
+  assert(elf->symtab_data != NULL);
+  assert(elf->symtab_data->d_buf != NULL);
+
+  ElfW(Sym) *esym = (ElfW(Sym)*) elf->symtab_data->d_buf;
+  ElfW(Sym) *lastsym = (ElfW(Sym)*) ((char*) elf->symtab_data->d_buf + elf->symtab_data->d_size);
+
+  assert(esym <= lastsym);
+
+  for (; esym < lastsym; esym++){
+    /* ignore weak/numeric/empty symbols */
+    if ((esym->st_value == 0) ||
+        (ELF32_ST_BIND(esym->st_info)== STB_WEAK) ||
+        (ELF32_ST_BIND(esym->st_info)== STB_NUM))
+      continue;
+
+    ptr = elf->base_addr + (void *)esym->st_value;
+    name = elf_strptr(elf->elf, elf->symtab_shdr.sh_link, (size_t)esym->st_name);
+
+    if (ptr == sym)
+      return name;
+  }
+
+  return NULL;
+}
+
+/*
+ * Do the same thing as in bin_find_symbol above, but compare addresses and return the string name.
+ */
+const char *
+bin_find_symbol_name(void *sym) {
+  return do_bin_find_symbol_name(sym, ruby_info);
+}
+
 /*
  * bin_update_image - update the ruby binary image in memory.
  *

data/ext/mach.c

@@ -323,13 +323,6 @@ build_sorted_nlist_table(const struct mach_header_64 *hdr, uint32_t *nsyms, uint
 
 void *
 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);
-  memcpy((real_symbol + 1), symbol, len);
-  memcpy((real_symbol + len + 1), "\0", 1);
-
   void *ptr = NULL;
   void *file = NULL;
 
@@ -354,7 +347,7 @@ bin_find_symbol(const char *symbol, size_t *size) {
     const struct nlist_64 *nlist_entry = nlist_table[i];
     const char *string = string_table + nlist_entry->n_un.n_strx;
 
-    if (strcmp(real_symbol, string) == 0) {
+    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));
@@ -391,6 +384,51 @@ bin_find_symbol(const char *symbol, size_t *size) {
   return ptr;
 }
 
+/*
+ * Do the same thing as in bin_find_symbol above, but compare addresses and return the string name.
+ */
+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;
+
+  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;
+
+  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;
+
+    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));
+
+    if (ptr == symbol) {
+      name = string+1;
+      break;
+    }
+  }
+
+  free(nlist_table);
+  free(file);
+  return name;
+}
+
 /*
  * I will explain bin_update_image with imaginary Ruby code:
  *

data/ext/x86_64.c

@@ -168,7 +168,7 @@ arch_insert_inline_st2_tramp(void *addr, void *marker, void *trampoline, void *t
      * This is to arrange for the new value in freelist to be in %rdi, and as such
      * be the first argument to the C handler. As per the amd64 ABI.
      */
-    default_inline_st2_tramp.frame.rdi_source_displacement = marker - (void *)&(entry->frame.push_rbx);
+    default_inline_st2_tramp.frame.rdi_source_displacement = marker - (void *)&(entry->frame.align_rsp);
 
     /* jmp back to the instruction after stage 1 trampoline was inserted
      *

data/ext/x86_64.h

@@ -90,18 +90,40 @@ static struct tramp_st2_entry {
  *
  * This structure represents the assembly code:
  *
- * mov SOURCE_REGISTER, freelist     # update the freelist
- * push %rdi                         # save %rdi
- * mov freelist, %rdi                # move first entry of freelist into %rdi
- * push %rbp                         # save previous %rbp
- * mov %rsp, %rbp                    # update %rbp to be current stack pointer
- * andl 0xFFFFFFFFFFFFFFF0, %rsp     # align stack pointer as per ABI
- * mov ADDR, %rbx                    # load handler address into %rbx
- * callq *%rbx                       # call handler
- * leave                             # reset stack pointer, restore %rbp
- * pop %rbx                          # restore %rbx
- * pop %rdi                          # restore %rdi
- * jmp NEXT_INSN                     # jmp to instruction after stage 1 tramp
+ * mov    SOURCE_REGISTER,-0x3f90d4a7(%rip)        # update freelist
+ *
+ * # save caller saved registers here
+ *
+ * push   %rax
+ * push   %rcx
+ * push   %rdx
+ * push   %rsi
+ * push   %rdi
+ * push   %r8
+ * push   %r9
+ * push   %r10
+ * push   %r11
+ * push   %rbp
+ * mov    %rsp,%rbp
+ * mov    -0x3f90d4bf(%rip),%rdi        # move freelist into rdi as arg1
+ * and    $0xfffffffffffffff0,%rsp      # align stack pointer
+ * mov    $0x7ffff65e74e0,%rcx          # put handler function into position
+ * callq  *%rcx                         # call handler
+ *
+ * # restore caller saved registers here
+ *
+ * leaveq
+ * pop    %r11
+ * pop    %r10
+ * pop    %r9
+ * pop    %r8
+ * pop    %rdi
+ * pop    %rsi
+ * pop    %rdx
+ * pop    %rcx
+ * pop    %rax
+ *
+ * jmpq   0x433972 <gc_sweep+754>       # jump back
  */
 static struct inline_tramp_st2_entry {
   unsigned char rex;
@@ -110,20 +132,42 @@ static struct inline_tramp_st2_entry {
   uint32_t mov_displacement;
 
   struct {
+    /*
+     * XXX xmm0-xmm7 are caller saved, too.
+     */
+    unsigned char push_rax;
+    unsigned char push_rcx;
+    unsigned char push_rdx;
+    unsigned char push_rsi;
     unsigned char push_rdi;
+    unsigned char push_r8[2];
+    unsigned char push_r9[2];
+    unsigned char push_r10[2];
+    unsigned char push_r11[2];
+
+    unsigned char push_rbp;
+    unsigned char mov_rsp_rbp[3];
+
     unsigned char mov_rdi[3];
     uint32_t rdi_source_displacement;
-    unsigned char push_rbx;
-    unsigned char push_rbp;
-    unsigned char save_rsp[3];
+
     unsigned char align_rsp[4];
     unsigned char mov[2];
     void *addr;
     unsigned char call[2];
+
     unsigned char leave;
-    unsigned char rbx_restore;
-    unsigned char rdi_restore;
-  } __attribute__((__packed__)) frame;
+
+    unsigned char pop_r11[2];
+    unsigned char pop_r10[2];
+    unsigned char pop_r9[2];
+    unsigned char pop_r8[2];
+    unsigned char pop_rdi;
+    unsigned char pop_rsi;
+    unsigned char pop_rdx;
+    unsigned char pop_rcx;
+    unsigned char pop_rax;
+} __attribute__((__packed__)) frame;
 
   unsigned char jmp;
   uint32_t jmp_displacement;
@@ -134,19 +178,33 @@ static struct inline_tramp_st2_entry {
   .mov_displacement = 0,
 
   .frame = {
+    .push_rax = 0x50,
+    .push_rcx = 0x51,
+    .push_rdx = 0x52,
+    .push_rsi = 0x56,
     .push_rdi = 0x57,
+    .push_r8 = {0x41, 0x50},
+    .push_r9 = {0x41, 0x51},
+    .push_r10 = {0x41, 0x52},
+    .push_r11 = {0x41, 0x53},
+    .push_rbp = 0x55,
+    .mov_rsp_rbp = {0x48, 0x89, 0xe5},
     .mov_rdi =  {0x48, 0x8b, 0x3d},
     .rdi_source_displacement = 0,
-    .push_rbx = 0x53,
-    .push_rbp = 0x55,
-    .save_rsp = {0x48, 0x89, 0xe5},
     .align_rsp = {0x48, 0x83, 0xe4, 0xf0},
-    .mov = {0x48, 0xbb},
+    .mov = {0x48, 0xb9},
     .addr = 0,
-    .call = {0xff, 0xd3},
+    .call = {0xff, 0xd1},
     .leave = 0xc9,
-    .rbx_restore = 0x5b,
-    .rdi_restore = 0x5f,
+    .pop_r11 = {0x41, 0x5b},
+    .pop_r10 = {0x41, 0x5a},
+    .pop_r9 = {0x41, 0x59},
+    .pop_r8 = {0x41, 0x58},
+    .pop_rdi = 0x5f,
+    .pop_rsi = 0x5e,
+    .pop_rdx = 0x5a,
+    .pop_rcx = 0x59,
+    .pop_rax = 0x58,
   },
 
   .jmp  = 0xe9,

data/memprof.gemspec

@@ -1,6 +1,6 @@
 spec = Gem::Specification.new do |s|
   s.name = 'memprof'
-  s.version = '0.2.6'
+  s.version = '0.2.7'
   s.date = '2010-03-13'
   s.summary = 'Ruby Memory Profiler'
   s.description = "Ruby memory profiler similar to bleak_house, but without patches to the Ruby VM"

metadata

@@ -1,12 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memprof
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 6
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors: 
 - Joe Damato
@@ -66,20 +61,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
+  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Ruby Memory Profiler