c_location 0.1

data/LICENSE.MIT

@@ -0,0 +1,19 @@
+Copyright (c) 2012 Conrad Irwin <conrad.irwin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/ext/c_location.c

@@ -0,0 +1,202 @@
+/* Load dladdr() function */
+#include <dlfcn.h>
+
+#include "ruby.h"
+
+// TODO: why is it necessary to define this here? It ought to be in <dlfcn.h>
+typedef struct {
+   const char *dli_fname;  /* Pathname of shared object that contains address */
+   void       *dli_fbase;  /* Address at which shared object is loaded */
+   const char *dli_sname;  /* Name of nearest symbol with address lower than addr */
+   void       *dli_saddr;  /* Exact address of symbol named in dli_sname */
+} Dl2_info;
+
+/* Given the pointer to a C function (called "name" for error handling)
+ * return the filename and offset of the compiled byte code for that function.
+ *
+ * This can then be used with a variety of Linux utilities to find more information about
+ * that function. If you're really lucky, and your programs have been compiled with
+ * debugging information (CFLAGS=-g) then this can even give you the original location of
+ * the source code of the method.
+ */
+static VALUE file_and_offset(void *func, char *name)
+{
+    Dl2_info info;
+    VALUE file;
+    VALUE offset;
+
+    if(!dladdr(func, &info)) {
+        rb_raise(rb_eRuntimeError, "could not find %s: %s", name, dlerror());
+    }
+
+    file = rb_str_new2(info.dli_fname);
+    offset = LL2NUM((long long)(func - info.dli_fbase));
+
+    return rb_ary_new3(2, file, offset);
+}
+
+static VALUE compiled_location(VALUE self);
+
+void
+Init_c_location()
+{
+    VALUE rb_mCompiledLocation = rb_define_module("CompiledLocation");
+
+    rb_define_method(rb_mCompiledLocation, "compiled_location", compiled_location, 0);
+
+    rb_include_module(rb_cMethod, rb_mCompiledLocation);
+    rb_include_module(rb_cUnboundMethod, rb_mCompiledLocation);
+}
+
+#ifdef RUBY_19
+
+typedef enum {
+    NOEX_PUBLIC    = 0x00,
+    NOEX_NOSUPER   = 0x01,
+    NOEX_PRIVATE   = 0x02,
+    NOEX_PROTECTED = 0x04,
+    NOEX_MASK      = 0x06,
+    NOEX_BASIC     = 0x08,
+    NOEX_UNDEF     = NOEX_NOSUPER,
+    NOEX_MODFUNC   = 0x12,
+    NOEX_SUPER     = 0x20,
+    NOEX_VCALL     = 0x40,
+    NOEX_RESPONDS  = 0x80
+} rb_method_flag_t;
+
+typedef enum {
+    VM_METHOD_TYPE_ISEQ,
+    VM_METHOD_TYPE_CFUNC,
+    VM_METHOD_TYPE_ATTRSET,
+    VM_METHOD_TYPE_IVAR,
+    VM_METHOD_TYPE_BMETHOD,
+    VM_METHOD_TYPE_ZSUPER,
+    VM_METHOD_TYPE_UNDEF,
+    VM_METHOD_TYPE_NOTIMPLEMENTED,
+    VM_METHOD_TYPE_OPTIMIZED, /* Kernel#send, Proc#call, etc */
+    VM_METHOD_TYPE_MISSING   /* wrapper for method_missing(id) */
+} rb_method_type_t;
+
+typedef struct rb_method_cfunc_struct {
+    VALUE (*func)(ANYARGS);
+    int argc;
+} rb_method_cfunc_t;
+
+typedef struct rb_method_attr_struct {
+    ID id;
+    VALUE location;
+} rb_method_attr_t;
+
+typedef struct rb_iseq_struct rb_iseq_t;
+typedef struct rb_method_definition_struct {
+    rb_method_type_t type; /* method type */
+    ID original_id;
+    union {
+        rb_iseq_t *iseq;            /* should be mark */
+        rb_method_cfunc_t cfunc;
+        rb_method_attr_t attr;
+        VALUE proc;                 /* should be mark */
+        enum method_optimized_type {
+            OPTIMIZED_METHOD_TYPE_SEND,
+            OPTIMIZED_METHOD_TYPE_CALL
+        } optimize_type;
+    } body;
+    int alias_count;
+} rb_method_definition_t;
+
+typedef struct rb_method_entry_struct {
+    rb_method_flag_t flag;
+    char mark;
+    rb_method_definition_t *def;
+    ID called_id;
+    VALUE klass;                    /* should be mark */
+} rb_method_entry_t;
+
+#ifdef RUBY_193
+
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    ID id;
+    rb_method_entry_t *me;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+static VALUE compiled_location(VALUE self)
+{
+    struct METHOD *data;
+    VALUE name = rb_funcall(self, rb_intern("name"), 0);
+          name = rb_funcall(name, rb_intern("to_s"), 0);
+
+    // TODO: We're not validating that this is definitely a method struct.
+    // It would be nice if we could use TypedData_Get_Struct, but we don't
+    // have access to &method_data_type.
+    data = (struct METHOD *)DATA_PTR(self);
+
+    if (data->me->def->type != VM_METHOD_TYPE_CFUNC) {
+        return Qnil;
+    }
+
+    return file_and_offset(*data->me->def->body.cfunc.func, StringValueCStr(name));
+}
+
+#else /* RUBY_192 */
+
+struct METHOD {
+    VALUE recv;
+    VALUE rclass;
+    ID id;
+    rb_method_entry_t me;
+    struct unlinked_method_entry_list_entry *ume;
+};
+
+static VALUE compiled_location(VALUE self)
+{
+    struct METHOD *data;
+    VALUE name = rb_funcall(self, rb_intern("name"), 0);
+          name = rb_funcall(name, rb_intern("to_s"), 0);
+
+    // TODO: We're not validating that this is definitely a method struct.
+    // It would be nice if we could use TypedData_Get_Struct, but we don't
+    // have access to &method_data_type.
+    data = (struct METHOD *)DATA_PTR(self);
+
+    if (data->me.def->type != VM_METHOD_TYPE_CFUNC) {
+        return Qnil;
+    }
+
+    return file_and_offset(*data->me.def->body.cfunc.func, StringValueCStr(name));
+}
+
+
+#endif
+
+#else /* RUBY18 */
+
+#include "node.h"
+
+/* Copy-pasted out of Ruby 1.8.7, not part of the official C API.*/
+struct METHOD {
+    VALUE klass, rklass;
+    VALUE recv;
+    ID id, oid;
+    int safe_level;
+    NODE *body;
+};
+
+static VALUE compiled_location(VALUE self)
+{
+    struct METHOD *data;
+    VALUE name = rb_funcall(self, rb_intern("name"), 0);
+
+    Data_Get_Struct(self, struct METHOD, data);
+
+    if (nd_type(data->body) != NODE_CFUNC) {
+        return Qnil;
+    }
+
+    return file_and_offset(*data->body->nd_cfnc, StringValueCStr(name));
+}
+
+
+#endif

data/ext/extconf.rb

@@ -0,0 +1,10 @@
+require 'mkmf'
+
+extension_name = "c_location"
+
+$CFLAGS += " -DRUBY_19" if RUBY_VERSION =~ /1.9/
+$CFLAGS += " -DRUBY_193" if RUBY_VERSION =~ /1.9.3/
+
+dir_config(extension_name)
+
+create_makefile(extension_name)

data/lib/c_location.rb

@@ -0,0 +1,13 @@
+require 'shellwords'
+require File.expand_path('../c_location/resolver', __FILE__)
+
+module CompiledLocation
+  def c_location
+    if c = compiled_location
+      CompiledLocation::Resolver.new(*c).source_location
+    end
+  end
+
+  def compiled_location; end
+  require File.expand_path('../../ext/c_location', __FILE__)
+end

data/lib/c_location/resolver.rb

@@ -0,0 +1,106 @@
+module CompiledLocation
+  class Resolver
+    attr_accessor :shared_library, :offset
+
+    def initialize(shared_library, offset)
+      self.shared_library, self.offset = [shared_library, offset]
+      self.shared_library = `which ruby` if self.shared_library == 'ruby'
+    end
+
+    def source_location
+      if RUBY_PLATFORM =~ /darwin/
+        nm(shared_library, offset)
+      else
+        objdump(shared_library, offset)
+      end
+    end
+
+    def objdump(shared_library, offset)
+      command = "#{Shellwords.escape which_objdump} --dwarf=decodedline #{Shellwords.escape shared_library}"
+      output = run(command)
+
+      if m = output.lines.detect{ |line| line =~ /\s+0x#{offset.to_s(16)}$/ }
+        file, line, address = m.split(/\s+/)
+
+        absolutify(file, line.to_i(10), shared_library)
+      else
+        raise "Could not find #{shared_library}@0x#{offset.to_s(16)} using #{command.inspect}." +
+              "This may be because your ruby/extensions are not compiled with -g."
+      end
+    end
+
+    def nm(shared_library, offset)
+      command = "#{Shellwords.escape which_nm} -pa #{Shellwords.escape shared_library}"
+      output = run(command)
+
+      o_file = nil
+
+      output.lines.each do |line|
+        case line
+        when /OSO (.*\.o\)?)/
+          o_file = $1.sub(%r{(.*)/([^/]*)\((.*)\)}, '\1/\3')
+        when /^[01]*#{offset.to_s(16)}.*FUN (.+)/
+          raise "Your version of nm seems to not output OSO lines." unless o_file
+          return objdump_tt(o_file, $1)
+        end
+      end
+
+      raise "Could not find #{shared_library}@0x#{offset.to_s(16)} using #{command.inspect}." +
+            "This may be because your ruby/extensions are not compiled with -g."
+    end
+
+    def objdump_tt(shared_library, name)
+      output = run("#{Shellwords.escape which_objdump} -tT #{Shellwords.escape shared_library}")
+
+      if output.lines.detect{ |line| line =~ /^([0-9a-f]+).*\.text\s#{Regexp.escape name}$/ }
+        objdump(shared_library, $1.to_i(16))
+      else
+        raise "Could not find #{shared_library}##{name} using #{command.inspect}."
+      end
+    end
+
+    def which_objdump
+      objdump = `which gobjdump`.chomp
+      return objdump if $?.success?
+      objdump = `which objdump`.chomp
+      return objdump if $?.success?
+      objdump = `which /usr/local/bin/gobjdump`.chomp
+      return objdump if $?.success?
+
+      raise "You need to have `objdump` installed to use c_location. " +
+            "Try installing the binutils package (apt-get install binutils; brew install binutils)."
+    end
+
+    def which_nm
+      nm = `which nm`.chomp
+      return nm if $?.success?
+
+      raise "You need to have `nm` installed to use c_location. " +
+            "Try installing Xcode from the App Store. (GNU nm from binutils doesn't work unfortunately)"
+
+    end
+
+    def absolutify(file, line, shared_library)
+      if shared_library =~ %r{(.*/(gems|src)/[^/]*)/}
+        potentials = Dir["#{$1}/**/#{file}"]
+      elsif shared_library =~ %r{(.*/(rubies)/[^/]*)/}
+        potentials = Dir["#{$1.sub('/rubies/', '/src/')}/**/#{file}"]
+      else
+        potentials = Dir["./**/#{file}"]
+      end
+
+      if potentials.empty?
+        raise "Could not find the `#{file}:#{line}` that was used to build `#{shared_library}`." +
+              "If you know where this file is please submit a pull request"
+      else
+        [potentials.first, line]
+      end
+    end
+
+    def run(command)
+      `#{command}`.tap do |output|
+        raise "Failed to run #{command.inspect}: #{output}" unless $?.success?
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: c_location
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Conrad Irwin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-08 00:00:00.000000000Z
+dependencies: []
+description: Allows you to find the source location of methods written in C
+email: conrad.irwin@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- lib/c_location.rb
+- lib/c_location/resolver.rb
+- ext/extconf.rb
+- ext/c_location.c
+- README.md
+- LICENSE.MIT
+homepage: http://github.com/ConradIrwin/c_location
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: ! 'Adds a #c_location to Method and UnboundMethod objects.'
+test_files: []
+has_rdoc: