backtracie 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 69190b4b5e00e3f8d89b96288a795bf79aee1f310d4e40d81d05a4737d99f9eb
-  data.tar.gz: d14cf978670bdd754a257c6b58735fb19921da15e2cd6a7a4c07ed0a8ddd6856
+  metadata.gz: b8ef71cf1cfd9ca005e0ecb0fe7434a9c8121bc46fc70c34209c74ecad1c705c
+  data.tar.gz: 723d3c66fb919432481428609a8316243e160805ff4142757f9ec65cf254f2d8
 SHA512:
-  metadata.gz: 5341c80c6ec5a4aeb9c6e0ad3e8f95126aa1f7502f4665b3a00be55349fd8312b5c3e2601162f5ec7c2ae458229fc38fa668c4919523e781fda5f04a86f01044
-  data.tar.gz: da4b1a46513861bdb05fe0e6d919d0350a1de47b0678b505cb494330677998a68c6c8188f8dfbd5cbd206aad6193c89bb7306f7447ac375c7536387dc3159cab
+  metadata.gz: ceffbd048f44b6563298f301bde8dd498c1ea92be244e90a42390f4d387d58ef3837d936afbd4c63376ebfa2a20984989a2f8e1426ab9cccc30fc8c844c78a68
+  data.tar.gz: cc6e34b726934f01ae92bf089954bace7063619ce8e3d71b1d1eea610d153f10641257399388ef70bcd7730b1aea89039d4f7e6e2b960f2b09e937fd4d802969

data/README.adoc

@@ -8,9 +8,10 @@ A Ruby gem for beautiful backtraces.
 
 Aims to offer alternatives to `Thread#backtrace`, `Thread#backtrace_locations`, `Kernel#caller` and `Kernel#caller_locations` with similar (or better!?) performance, but with better metadata (such as class names).
 
-WARNING: **Currently this gem is an exploration ground for some... questionable low-level techniques.**
-**Due to the way it works, bugs can easily cause your whole Ruby VM to crash.**
-**So please take this into account if you want to use this gem for anything. But contributions and bug reports are mega welcome.**
+WARNING: **⚠️ This gem is currently an exploration ground for the use of low-level techniques to get at internal Ruby VM structures.
+          Due to the way it works, bugs can easily cause your whole Ruby VM to crash;
+          Please take this into account if you plan on using this gem.
+          Still, contributions and bug reports are mega welcome, and I hope to one day be able to remove this warning ⚠️.**
 
 image:https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg["Contributor Covenant", link="CODE_OF_CONDUCT.adoc"]
 image:https://badge.fury.io/rb/backtracie.svg["Gem Version", link="https://badge.fury.io/rb/backtracie"]

data/backtracie.gemspec

@@ -46,4 +46,7 @@ Gem::Specification.new do |spec|
   end
   spec.require_paths = ["lib", "ext"]
   spec.extensions = ["ext/backtracie_native_extension/extconf.rb"]
+
+  # Enables support for Ruby 2.5 and below. Not used at all in the others.
+  spec.add_dependency "debase-ruby_core_source", "~> 0.10", ">= 0.10.12"
 end

data/ext/backtracie_native_extension/backtracie.c

@@ -33,8 +33,6 @@
 static VALUE main_object_instance = Qnil;
 static ID ensure_object_is_thread_id;
 static ID to_s_id;
-static ID current_id;
-static ID backtrace_locations_id;
 static VALUE backtracie_module = Qnil;
 static VALUE backtracie_location_class = Qnil;
 
@@ -52,14 +50,12 @@ static bool is_self_class_singleton(raw_location *the_location);
 static bool is_defined_class_a_refinement(raw_location *the_location);
 static VALUE debug_raw_location(raw_location *the_location);
 static VALUE debug_frame(VALUE frame);
-static inline VALUE to_boolean(bool value) ;
+static inline VALUE to_boolean(bool value);
 
 void Init_backtracie_native_extension(void) {
-  main_object_instance = backtracie_rb_vm_top_self();
+  main_object_instance = rb_funcall(rb_const_get(rb_cObject, rb_intern("TOPLEVEL_BINDING")), rb_intern("eval"), 1, rb_str_new2("self"));
   ensure_object_is_thread_id = rb_intern("ensure_object_is_thread");
   to_s_id = rb_intern("to_s");
-  current_id = rb_intern("current");
-  backtrace_locations_id = rb_intern("backtrace_locations");
 
   backtracie_module = rb_const_get(rb_cObject, rb_intern("Backtracie"));
   rb_global_variable(&backtracie_module);
@@ -79,28 +75,13 @@ static VALUE collect_backtrace_locations(VALUE self, VALUE thread, int ignored_s
   int stack_depth = 0;
   raw_location raw_locations[MAX_STACK_DEPTH];
 
-  #ifndef PRE_MJIT_RUBY
-    if (thread == Qnil) {
-      // Get for own thread
-      stack_depth = backtracie_rb_profile_frames(MAX_STACK_DEPTH, raw_locations);
-    } else {
-      stack_depth = backtracie_rb_profile_frames_for_thread(thread, MAX_STACK_DEPTH, raw_locations);
-      if (stack_depth == 0 && !backtracie_is_thread_alive(thread)) return Qnil;
-    }
-  #else
-    VALUE current_thread = rb_funcall(rb_cThread, current_id, 0);
-
-    if (thread == Qnil || thread == current_thread) {
-      thread = current_thread;
-      // Since we're going to sample the current thread, we don't want Thread#backtrace_locations to show up
-      // on the stack (as we want to match the exact depth we get from MRI), so we ignore one extra frame
-      ignored_stack_top_frames++;
-    }
-
-    VALUE locations_array = rb_funcall(thread, backtrace_locations_id, 0);
-    if (locations_array == Qnil) return Qnil;
-    stack_depth = backtracie_profile_frames_from_ruby_locations(locations_array, raw_locations);
-  #endif
+  if (thread == Qnil) {
+    // Get for own thread
+    stack_depth = backtracie_rb_profile_frames(MAX_STACK_DEPTH, raw_locations);
+  } else {
+    stack_depth = backtracie_rb_profile_frames_for_thread(thread, MAX_STACK_DEPTH, raw_locations);
+    if (stack_depth == 0 && !backtracie_is_thread_alive(thread)) return Qnil;
+  }
 
   VALUE locations = rb_ary_new_capa(stack_depth - ignored_stack_top_frames);
 
@@ -217,9 +198,7 @@ static VALUE cfunc_frame_to_location(raw_location *the_location, raw_location *l
     last_ruby_location != 0 ? frame_from_location(last_ruby_location) : Qnil;
 
   // Replaces label and base_label in cfuncs
-  VALUE method_name =
-    the_location->should_use_cfunc_name ?
-      the_location->cfunc_name : backtracie_rb_profile_frame_method_name(the_location->callable_method_entry);
+  VALUE method_name = backtracie_rb_profile_frame_method_name(the_location->callable_method_entry);
 
   return new_location(
     SAFE_NAVIGATION(rb_profile_frame_absolute_path, last_ruby_frame),
@@ -317,7 +296,6 @@ static VALUE debug_raw_location(raw_location *the_location) {
   VALUE arguments[] = {
     ID2SYM(rb_intern("ruby_frame?"))  ,             /* => */ to_boolean(the_location->is_ruby_frame),
     ID2SYM(rb_intern("should_use_iseq")),           /* => */ to_boolean(the_location->should_use_iseq),
-    ID2SYM(rb_intern("should_use_cfunc_name")),     /* => */ to_boolean(the_location->should_use_cfunc_name),
     ID2SYM(rb_intern("vm_method_type")),            /* => */ INT2FIX(the_location->vm_method_type),
     ID2SYM(rb_intern("line_number")),               /* => */ INT2FIX(the_location->line_number),
     ID2SYM(rb_intern("called_id")),                 /* => */ backtracie_called_id(the_location),
@@ -331,16 +309,13 @@ static VALUE debug_raw_location(raw_location *the_location) {
     ID2SYM(rb_intern("self_class_singleton?")),     /* => */ to_boolean(is_self_class_singleton(the_location)),
     ID2SYM(rb_intern("iseq_is_block?")),            /* => */ to_boolean(backtracie_iseq_is_block(the_location)),
     ID2SYM(rb_intern("iseq_is_eval?")),             /* => */ to_boolean(backtracie_iseq_is_eval(the_location)),
-    ID2SYM(rb_intern("cfunc_name")),                /* => */ the_location->cfunc_name,
     ID2SYM(rb_intern("iseq")),                      /* => */ debug_frame(the_location->iseq),
-    ID2SYM(rb_intern("callable_method_entry")),     /* => */ debug_frame(the_location->callable_method_entry)
+    ID2SYM(rb_intern("callable_method_entry")),     /* => */ debug_frame(the_location->callable_method_entry),
+    ID2SYM(rb_intern("original_id")),               /* => */ the_location->original_id
   };
 
   VALUE debug_hash = rb_hash_new();
-  #ifndef PRE_MJIT_RUBY
-  // FIXME: Hack, need to actually fix this
-  rb_hash_bulk_insert(VALUE_COUNT(arguments), arguments, debug_hash);
-  #endif
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(debug_hash, arguments[i], arguments[i+1]);
   return debug_hash;
 }
 
@@ -361,10 +336,7 @@ static VALUE debug_frame(VALUE frame) {
   };
 
   VALUE debug_hash = rb_hash_new();
-  #ifndef PRE_MJIT_RUBY
-  // FIXME: Hack, need to actually fix this
-  rb_hash_bulk_insert(VALUE_COUNT(arguments), arguments, debug_hash);
-  #endif
+  for (long unsigned int i = 0; i < VALUE_COUNT(arguments); i += 2) rb_hash_aset(debug_hash, arguments[i], arguments[i+1]);
   return debug_hash;
 }
 

data/ext/backtracie_native_extension/extconf.rb

@@ -34,6 +34,10 @@ $CFLAGS << " " << "-Wno-unused-function"
 # Really dislike the "define everything at the beginning of the function" thing, sorry!
 $CFLAGS << " " << "-Wno-declaration-after-statement"
 
+# If we forget to include a Ruby header, the function call may still appear to work, but then
+# cause a segfault later. Let's ensure that never happens.
+$CFLAGS << " " << "-Werror-implicit-function-declaration"
+
 # Enable us to use """modern""" C
 if RUBY_VERSION < "2.4"
   $CFLAGS << " " << "-std=c99"
@@ -44,29 +48,56 @@ if RUBY_VERSION < "3"
   $defs << "-DCFUNC_FRAMES_BACKPORT_NEEDED"
 end
 
-# Backport https://github.com/ruby/ruby/pull/3084 (present in 2.7 and 3.0) to Ruby 2.6
+# Backport https://github.com/ruby/ruby/pull/3084 (present in 2.7 and 3.0) to Ruby <= 2.6
 if RUBY_VERSION.start_with?("2.6")
   $defs << "-DCLASSPATH_BACKPORT_NEEDED"
 end
 
+# Older Rubies don't have the MJIT header, see below for details
 if RUBY_VERSION < "2.6"
   $defs << "-DPRE_MJIT_RUBY"
 end
 
+if RUBY_VERSION < "2.5"
+  $CFLAGS << " " << "-DPRE_EXECUTION_CONTEXT" # Flag that there's no execution context, we need to use threads instead
+  $CFLAGS << " " << "-Wno-attributes" # Silence a few warnings that we can't do anything about
+end
+
+if RUBY_VERSION < "2.4"
+  $CFLAGS << " " << "-DPRE_VM_ENV_RENAMES" # Flag that it's a really old Ruby, and a few constants were since renamed
+end
+
 create_header
 
-# The Ruby MJIT header is always (afaik?) suffixed with the exact RUBY version,
-# including patch (e.g. 2.7.2). Thus, we add to the header file a definition
-# containing the exact file, so that it can be used in a #include in the C code.
-header_contents =
-  File.read($extconf_h)
-    .sub("#endif",
-      <<~EXTCONF_H.strip
-        #define RUBY_MJIT_HEADER "rb_mjit_min_header-#{RUBY_VERSION}.h"
-
-        #endif
-      EXTCONF_H
-    )
-File.open($extconf_h, "w") { |file| file.puts(header_contents) }
-
-create_makefile "backtracie_native_extension"
+if RUBY_VERSION < "2.6"
+  # Use the debase-ruby_core_source gem to get access to Ruby internal structures (no MJIT header -- the preferred
+  # option -- is available for these older Rubies)
+
+  require "debase/ruby_core_source"
+  dir_config("ruby") # allow user to pass in non-standard core include directory
+  if !Debase::RubyCoreSource.create_makefile_with_core(
+    proc { ["vm_core.h", "method.h", "iseq.h", "regenc.h"].map { |it| have_header(it) }.uniq == [true] },
+    "backtracie_native_extension"
+  )
+    raise "Error during native gem setup -- `Debase::RubyCoreSource.create_makefile_with_core` failed"
+  end
+
+else
+  # Use MJIT header to get access to Ruby internal structures.
+
+  # The Ruby MJIT header is always (afaik?) suffixed with the exact RUBY version,
+  # including patch (e.g. 2.7.2). Thus, we add to the header file a definition
+  # containing the exact file, so that it can be used in a #include in the C code.
+  header_contents =
+    File.read($extconf_h)
+      .sub("#endif",
+        <<~EXTCONF_H.strip
+          #define RUBY_MJIT_HEADER "rb_mjit_min_header-#{RUBY_VERSION}.h"
+
+          #endif
+        EXTCONF_H
+      )
+  File.open($extconf_h, "w") { |file| file.puts(header_contents) }
+
+  create_makefile "backtracie_native_extension"
+end

data/ext/backtracie_native_extension/ruby_shards.c

@@ -105,14 +105,31 @@
 #include "extconf.h"
 
 #ifndef PRE_MJIT_RUBY
-
 #ifndef RUBY_MJIT_HEADER_INCLUDED
 #define RUBY_MJIT_HEADER_INCLUDED
 #include RUBY_MJIT_HEADER
 #endif
+#endif
 
 #include "ruby_shards.h"
 
+#ifdef PRE_MJIT_RUBY
+#include <iseq.h>
+#include <regenc.h>
+#endif
+
+#ifdef PRE_EXECUTION_CONTEXT
+// The thread and its execution context were separated on Ruby 2.5; prior to that, everything was part of the thread
+#define rb_execution_context_t rb_thread_t
+#endif
+
+#ifdef PRE_VM_ENV_RENAMES
+#define VM_ENV_LOCAL_P VM_EP_LEP_P
+#define VM_ENV_PREV_EP VM_EP_PREV_EP
+#define VM_ENV_DATA_INDEX_ME_CREF -1
+#define VM_FRAME_RUBYFRAME_P(cfp) RUBY_VM_NORMAL_ISEQ_P(cfp->iseq)
+#endif
+
 /**********************************************************************
   vm_backtrace.c -
   $Author: ko1 $
@@ -187,19 +204,24 @@ static int backtracie_rb_profile_frames_for_execution_context(
     // Initialize the raw_location, to avoid issues
     raw_locations[i].is_ruby_frame = false;
     raw_locations[i].should_use_iseq = false;
-    raw_locations[i].should_use_cfunc_name = false;
     raw_locations[i].vm_method_type = 0;
     raw_locations[i].line_number = 0;
     raw_locations[i].iseq = Qnil;
     raw_locations[i].callable_method_entry = Qnil;
-    raw_locations[i].cfunc_name = Qnil;
+    raw_locations[i].original_id = Qnil;
 
     // The current object this is getting called on!
     raw_locations[i].self = cfp->self;
 
     cme = rb_vm_frame_method_entry(cfp);
 
-    if (VM_FRAME_RUBYFRAME_P(cfp)) {
+    if (cfp->iseq && !cfp->pc) {
+      // Do nothing -- this frame should not be used
+      // Bugfix: rb_profile_frames did not do this (skip a frame when there's no pc), but backtrace_each did, and that
+      // caused the "Backtracie.backtrace_locations when sampling a map from an enumerable returns the same number of items as the Ruby API"
+      // test to fail -- Backtracie returned one more frame than Ruby. I suspect that, as usual, this is yet another case where
+      // rb_profile_frames fails us.
+    } else if (VM_FRAME_RUBYFRAME_P(cfp)) {
       raw_locations[i].is_ruby_frame = true;
       raw_locations[i].iseq = (VALUE) cfp->iseq;
 
@@ -223,6 +245,7 @@ static int backtracie_rb_profile_frames_for_execution_context(
         raw_locations[i].callable_method_entry = (VALUE) cme;
         raw_locations[i].vm_method_type = cme->def->type;
         raw_locations[i].line_number = 0;
+        raw_locations[i].original_id = ID2SYM(cme->def->original_id);
 
         i++;
       }
@@ -235,7 +258,12 @@ static int backtracie_rb_profile_frames_for_execution_context(
 }
 
 int backtracie_rb_profile_frames(int limit, raw_location *raw_locations) {
-  return backtracie_rb_profile_frames_for_execution_context(GET_EC(), limit, raw_locations);
+  #ifndef PRE_EXECUTION_CONTEXT
+    return backtracie_rb_profile_frames_for_execution_context(GET_EC(), limit, raw_locations);
+  #else
+    // FIXME: Figure out how to make GET_EC (GET_THREAD) work for Ruby <= 2.4
+    return 0;
+  #endif
 }
 
 bool backtracie_is_thread_alive(VALUE thread) {
@@ -253,7 +281,11 @@ int backtracie_rb_profile_frames_for_thread(VALUE thread, int limit, raw_locatio
   // the caller, otherwise I see a segfault in your future.
   rb_thread_t *thread_pointer = (rb_thread_t*) DATA_PTR(thread);
 
-  return backtracie_rb_profile_frames_for_execution_context(thread_pointer->ec, limit, raw_locations);
+  #ifndef PRE_EXECUTION_CONTEXT
+    return backtracie_rb_profile_frames_for_execution_context(thread_pointer->ec, limit, raw_locations);
+  #else
+    return backtracie_rb_profile_frames_for_execution_context(thread_pointer, limit, raw_locations);
+  #endif
 }
 
 VALUE backtracie_called_id(raw_location *the_location) {
@@ -273,10 +305,6 @@ VALUE backtracie_defined_class(raw_location *the_location) {
       ->defined_class;
 }
 
-VALUE backtracie_rb_vm_top_self() {
-  return GET_VM()->top_self;
-}
-
 bool backtracie_iseq_is_block(raw_location *the_location) {
   if (the_location->iseq == Qnil) return false;
 
@@ -452,142 +480,54 @@ backported_rb_profile_frame_qualified_method_name(VALUE frame)
 }
 #endif // CLASSPATH_BACKPORT_NEEDED
 
-#endif // ifndef PRE_MJIT_RUBY
-
-// -----------------------------------------------------------------------------
-
 #ifdef PRE_MJIT_RUBY
 
-#include <stdbool.h>
-
-#include "ruby.h"
-
-#include "ruby_shards.h"
+// A few extra functions copied from the Ruby sources, needed to support Ruby < 2.6
 
-typedef struct rb_backtrace_location_struct {
-  enum LOCATION_TYPE {
-    LOCATION_TYPE_ISEQ = 1,
-    LOCATION_TYPE_ISEQ_CALCED,
-    LOCATION_TYPE_CFUNC,
-  } type;
-
-  union {
-    struct {
-      const VALUE iseq; // Originally const rb_iseq_t *
-      union {
-        const VALUE *pc;
-        int lineno;
-      } lineno;
-    } iseq;
-    struct {
-      ID mid;
-      struct rb_backtrace_location_struct *prev_loc;
-    } cfunc;
-  } body;
-} rb_backtrace_location_t;
-
-struct valued_frame_info {
-  rb_backtrace_location_t *loc;
-  VALUE btobj;
-};
-
-// For Ruby < 2.6, we can't rely on the MJIT header. So we need to get... crafty. This alternative to
-// backtracie_rb_profile_frames_for_execution_context(...) piggybacks on the actual
-// Thread::Backtrace::Locations instances returned by Ruby's Thread#backtrace_locations, and then uses
-// knowledge of the VM internal layouts to get the data we need out of them.
-//
-// Currently, this approach gets us a lot less information than the Ruby >= 2.6 approach (e.g. currently we
-// get exactly the same as Thread::Backtrace::Locations offers), so it's a crappier replacement, but it does
-// get us support for older Rubies so it's better than nothing (to check the differences in behavior, check which
-// tests are disabled on < 2.6).
-int backtracie_profile_frames_from_ruby_locations(
-  VALUE ruby_locations_array,
-  raw_location *raw_locations
-) {
-  Check_Type(ruby_locations_array, T_ARRAY);
-  int ruby_locations_array_size = RARRAY_LEN(ruby_locations_array);
-
-  for (int i = 0; i < ruby_locations_array_size; i++) {
-    // FIXME: We should validate that what we get out of the array is a Thread::Backtrace::Location instance
-    VALUE location = rb_ary_entry(ruby_locations_array, i);
-
-    // The leap of faith -- let's get into the data from the Location instance
-    struct valued_frame_info *location_payload = DATA_PTR(location);
+/**********************************************************************
+  vm_insnhelper.c - instruction helper functions.
+  $Author$
+  Copyright (C) 2007 Koichi Sasada
+**********************************************************************/
 
-    if (location_payload->loc->type == LOCATION_TYPE_ISEQ) {
-      // Trigger calculation of the line number; this is calculated lazily when this method is invoked and
-      // it turns the location type from LOCATION_TYPE_ISEQ to LOCATION_TYPE_ISEQ_CALCED.
-      rb_funcall(location, rb_intern("lineno"), 0);
+static rb_callable_method_entry_t *
+check_method_entry(VALUE obj, int can_be_svar)
+{
+    if (obj == Qfalse) return NULL;
 
-      if (location_payload->loc->type == LOCATION_TYPE_ISEQ) {
-        rb_raise(rb_eRuntimeError, "Internal error: Calling #lineno didn't turn a location into a LOCATION_TYPE_ISEQ_CALCED");
-      }
-    }
+#if VM_CHECK_MODE > 0
+    if (!RB_TYPE_P(obj, T_IMEMO)) rb_bug("check_method_entry: unknown type: %s", rb_obj_info(obj));
+#endif
 
-    if (location_payload->loc->type == LOCATION_TYPE_ISEQ || location_payload->loc->type == LOCATION_TYPE_ISEQ_CALCED) {
-      // Ruby frame
-      raw_locations[i].is_ruby_frame = true;
-      raw_locations[i].should_use_iseq = true;
-      raw_locations[i].should_use_cfunc_name = false;
-      raw_locations[i].vm_method_type = -1;
-      // FIXME: Poke MRI to always get the "calced" version, see location_lineno in vm_backtrace for the context
-      raw_locations[i].line_number =
-        location_payload->loc->type == LOCATION_TYPE_ISEQ_CALCED ?
-          location_payload->loc->body.iseq.lineno.lineno : 0;
-      raw_locations[i].iseq = (VALUE) location_payload->loc->body.iseq.iseq;
-      raw_locations[i].callable_method_entry = Qnil;
-      raw_locations[i].self = Qnil;
-      raw_locations[i].cfunc_name = Qnil;
-    } else {
-      // cfunc frame
-      raw_locations[i].is_ruby_frame = false;
-      raw_locations[i].should_use_iseq = false;
-      raw_locations[i].should_use_cfunc_name = true;
-      raw_locations[i].vm_method_type = -1;
-      raw_locations[i].line_number = 0;
-      raw_locations[i].iseq = Qnil;
-      raw_locations[i].callable_method_entry = Qnil;
-      raw_locations[i].self = Qnil;
-      raw_locations[i].cfunc_name = rb_id2str(location_payload->loc->body.cfunc.mid);
-    }
+    switch (imemo_type(obj)) {
+      case imemo_ment:
+  return (rb_callable_method_entry_t *)obj;
+      case imemo_cref:
+  return NULL;
+      case imemo_svar:
+  if (can_be_svar) {
+      return check_method_entry(((struct vm_svar *)obj)->cref_or_me, FALSE);
   }
-
-  return ruby_locations_array_size;
-}
-
-VALUE backtracie_called_id(raw_location *the_location) {
-  // Not available on PRE_MJIT_RUBY
-  return Qnil;
-}
-
-VALUE backtracie_defined_class(raw_location *the_location) {
-  // Not available on PRE_MJIT_RUBY
-  return Qnil;
-}
-
-VALUE backtracie_rb_vm_top_self() {
-  // This is only used on gem initialization so... Let's be a bit lazy :)
-  return rb_eval_string("TOPLEVEL_BINDING.eval('self')");
-}
-
-bool backtracie_iseq_is_block(raw_location *the_location) {
-  // Not available on PRE_MJIT_RUBY
-  return false;
+      default:
+#if VM_CHECK_MODE > 0
+  rb_bug("check_method_entry: svar should not be there:");
+#endif
+  return NULL;
+    }
 }
 
-bool backtracie_iseq_is_eval(raw_location *the_location) {
-  // Not available on PRE_MJIT_RUBY
-  return false;
-}
+const rb_callable_method_entry_t *
+rb_vm_frame_method_entry(const rb_control_frame_t *cfp)
+{
+    const VALUE *ep = cfp->ep;
+    rb_callable_method_entry_t *me;
 
-VALUE backported_rb_profile_frame_method_name(VALUE frame) {
-  // Not available on PRE_MJIT_RUBY
-  return Qnil;
-}
+    while (!VM_ENV_LOCAL_P(ep)) {
+        if ((me = check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], FALSE)) != NULL) return me;
+        ep = VM_ENV_PREV_EP(ep);
+    }
 
-VALUE backtracie_refinement_name(raw_location *the_location) {
-  // Not available on PRE_MJIT_RUBY
-  return Qnil;
+    return check_method_entry(ep[VM_ENV_DATA_INDEX_ME_CREF], TRUE);
 }
 
-#endif // ifdef PRE_MJIT_RUBY
+#endif

data/ext/backtracie_native_extension/ruby_shards.h

@@ -89,6 +89,11 @@
   Copyright (C) 2009 Koichi Sasada
 **********************************************************************/
 
+  #ifdef PRE_MJIT_RUBY
+    #include <stdbool.h>
+    #include <vm_core.h>
+    #include <method.h>
+  #else
   #ifndef RUBY_MJIT_HEADER_INCLUDED
     typedef enum {
       VM_METHOD_TYPE_ISEQ,      /*!< Ruby method */
@@ -104,10 +109,7 @@
       VM_METHOD_TYPE_MISSING,   /*!< wrapper for method_missing(id) */
       VM_METHOD_TYPE_REFINED,   /*!< refinement */
     } rb_method_type_t;
-    #define VM_METHOD_TYPE_MINIMUM_BITS 4
-
-    // Needed for Ruby 2.6 as this is not defined on any public header
-    void rb_hash_bulk_insert(long, const VALUE *, VALUE);
+  #endif
   #endif
 
 // -----------------------------------------------------------------------------
@@ -118,32 +120,24 @@ typedef struct {
   // for ruby frames where the callable_method_entry is not of type VM_METHOD_TYPE_ISEQ, most of the metadata we
   // want can be found by querying the iseq, and there may not even be an callable_method_entry
   unsigned int should_use_iseq : 1;
-  unsigned int should_use_cfunc_name : 1;
 
-  rb_method_type_t vm_method_type : VM_METHOD_TYPE_MINIMUM_BITS;
+  rb_method_type_t vm_method_type;
   int line_number;
   VALUE iseq;
   VALUE callable_method_entry;
   VALUE self;
-  VALUE cfunc_name;
+  VALUE original_id;
 } raw_location;
 
-  #ifndef PRE_MJIT_RUBY
-    int backtracie_rb_profile_frames(int limit, raw_location *raw_locations);
-    int backtracie_rb_profile_frames_for_thread(VALUE thread, int limit, raw_location *raw_locations);
-    bool backtracie_is_thread_alive(VALUE thread);
-  #endif
+int backtracie_rb_profile_frames(int limit, raw_location *raw_locations);
+int backtracie_rb_profile_frames_for_thread(VALUE thread, int limit, raw_location *raw_locations);
+bool backtracie_is_thread_alive(VALUE thread);
 VALUE backtracie_called_id(raw_location *the_location);
 VALUE backtracie_defined_class(raw_location *the_location);
-VALUE backtracie_rb_vm_top_self();
 bool backtracie_iseq_is_block(raw_location *the_location);
 bool backtracie_iseq_is_eval(raw_location *the_location);
 VALUE backtracie_refinement_name(raw_location *the_location);
 
-  #ifdef PRE_MJIT_RUBY
-    int backtracie_profile_frames_from_ruby_locations(VALUE ruby_locations_array, raw_location *raw_locations);
-  #endif
-
 // -----------------------------------------------------------------------------
 
   // Ruby 3.0 finally added support for showing "cfunc frames" (frames for methods written in C) in stack traces:
@@ -159,7 +153,7 @@ VALUE backtracie_refinement_name(raw_location *the_location);
     #define backtracie_rb_profile_frame_method_name rb_profile_frame_method_name
   #endif
 
-  // Backport https://github.com/ruby/ruby/pull/3084 (present in 2.7 and 3.0) to Ruby 2.6
+  // Backport https://github.com/ruby/ruby/pull/3084 (present in 2.7 and 3.0) to Ruby <= 2.6
   // The interesting bit is actually the fix to rb_profile_frame_classpath BUT since rb_profile_frame_qualified_method_name
   // internally relies on rb_profile_frame_classpath we also need to add a copy of that one as well.
   #ifdef CLASSPATH_BACKPORT_NEEDED

data/lib/backtracie/version.rb

@@ -19,5 +19,5 @@
 # along with backtracie.  If not, see <http://www.gnu.org/licenses/>.
 
 module Backtracie
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/backtracie.rb

@@ -28,8 +28,17 @@ require "backtracie_native_extension"
 module Backtracie
   module_function
 
-  def caller_locations
-    Primitive.caller_locations
+  if RUBY_VERSION < "2.5"
+    def caller_locations
+      # FIXME: We're having some trouble getting the current thread on older Rubies, see the FIXME on
+      # backtracie_rb_profile_frames. A workaround is to just pass in the reference to the current thread explicitly
+      # (and slice off a few frames, since caller_locations is supposed to start from the caller of our caller)
+      backtrace_locations(Thread.current)[3..-1]
+    end
+  else
+    def caller_locations
+      Primitive.caller_locations
+    end
   end
 
   # Defined via native code only; not redirecting via Primitive to avoid an extra stack frame on the stack

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: backtracie
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Ivo Anjo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-07-01 00:00:00.000000000 Z
-dependencies: []
+date: 2021-09-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: debase-ruby_core_source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.12
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.10.12
 description: Ruby gem for beautiful backtraces
 email:
 - ivo@ivoanjo.me
@@ -51,7 +71,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.9
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Ruby gem for beautiful backtraces