byebug 9.0.5 → 11.1.3

data/ext/byebug/byebug.c

@@ -1,6 +1,6 @@
 #include "byebug.h"
 
-static VALUE mByebug;   /* Ruby Byebug Module object */
+static VALUE mByebug; /* Ruby Byebug Module object */
 
 static VALUE tracing = Qfalse;
 static VALUE post_mortem = Qfalse;
@@ -75,7 +75,7 @@ check_started()
 }
 
 static void
-trace_print(rb_trace_arg_t * trace_arg, debug_context_t * dc,
+trace_print(rb_trace_arg_t *trace_arg, debug_context_t *dc,
             const char *file_filter, const char *debug_msg)
 {
   char *fullpath = NULL;
@@ -127,7 +127,7 @@ trace_print(rb_trace_arg_t * trace_arg, debug_context_t * dc,
 }
 
 static void
-cleanup(debug_context_t * dc)
+cleanup(debug_context_t *dc)
 {
   dc->stop_reason = CTX_STOP_NONE;
 
@@ -156,11 +156,11 @@ cleanup(debug_context_t * dc)
   if (CTX_FL_TEST(dc, CTX_FL_IGNORE))                   \
     return;                                             \
                                                         \
-  acquire_lock(dc);                                     \
-                                                        \
+  acquire_lock(dc);
+
 
-#define CALL_EVENT_SETUP                                      \
-  dc->calced_stack_size++;                                    \
+#define CALL_EVENT_SETUP   \
+  dc->calced_stack_size++; \
   dc->steps_out = dc->steps_out < 0 ? -1 : dc->steps_out + 1;
 
 #define RETURN_EVENT_SETUP \
@@ -176,7 +176,7 @@ cleanup(debug_context_t * dc)
 /* Functions that return control to byebug after the different events */
 
 static VALUE
-call_at(VALUE ctx, debug_context_t * dc, ID mid, int argc, VALUE arg)
+call_at(VALUE ctx, debug_context_t *dc, ID mid, int argc, VALUE arg)
 {
   struct call_with_inspection_data cwi;
   VALUE argv[1];
@@ -193,19 +193,19 @@ call_at(VALUE ctx, debug_context_t * dc, ID mid, int argc, VALUE arg)
 }
 
 static VALUE
-call_at_line(VALUE ctx, debug_context_t * dc)
+call_at_line(VALUE ctx, debug_context_t *dc)
 {
   return call_at(ctx, dc, rb_intern("at_line"), 0, Qnil);
 }
 
 static VALUE
-call_at_tracing(VALUE ctx, debug_context_t * dc)
+call_at_tracing(VALUE ctx, debug_context_t *dc)
 {
   return call_at(ctx, dc, rb_intern("at_tracing"), 0, Qnil);
 }
 
 static VALUE
-call_at_breakpoint(VALUE ctx, debug_context_t * dc, VALUE breakpoint)
+call_at_breakpoint(VALUE ctx, debug_context_t *dc, VALUE breakpoint)
 {
   dc->stop_reason = CTX_STOP_BREAKPOINT;
 
@@ -213,7 +213,7 @@ call_at_breakpoint(VALUE ctx, debug_context_t * dc, VALUE breakpoint)
 }
 
 static VALUE
-call_at_catchpoint(VALUE ctx, debug_context_t * dc, VALUE exp)
+call_at_catchpoint(VALUE ctx, debug_context_t *dc, VALUE exp)
 {
   dc->stop_reason = CTX_STOP_CATCHPOINT;
 
@@ -221,7 +221,7 @@ call_at_catchpoint(VALUE ctx, debug_context_t * dc, VALUE exp)
 }
 
 static VALUE
-call_at_return(VALUE ctx, debug_context_t * dc, VALUE return_value)
+call_at_return(VALUE ctx, debug_context_t *dc, VALUE return_value)
 {
   dc->stop_reason = CTX_STOP_BREAKPOINT;
 
@@ -229,7 +229,7 @@ call_at_return(VALUE ctx, debug_context_t * dc, VALUE return_value)
 }
 
 static VALUE
-call_at_end(VALUE ctx, debug_context_t * dc)
+call_at_end(VALUE ctx, debug_context_t *dc)
 {
   dc->stop_reason = CTX_STOP_BREAKPOINT;
 
@@ -237,14 +237,14 @@ call_at_end(VALUE ctx, debug_context_t * dc)
 }
 
 static void
-call_at_line_check(VALUE ctx, debug_context_t * dc, VALUE breakpoint)
+call_at_line_check(VALUE ctx, debug_context_t *dc, VALUE breakpoint)
 {
   dc->stop_reason = CTX_STOP_STEP;
 
   if (!NIL_P(breakpoint))
     call_at_breakpoint(ctx, dc, breakpoint);
 
-  reset_stepping_stop_points(dc);
+  byebug_reset_stepping_stop_points(dc);
 
   call_at_line(ctx, dc);
 }
@@ -305,14 +305,7 @@ call_event(VALUE trace_point, void *data)
 
   CALL_EVENT_SETUP;
 
-  /* nil method_id means we are at top level so there can't be a method
-   * breakpoint here. Just leave then. */
   msym = rb_tracearg_method_id(trace_arg);
-  if (NIL_P(msym))
-  {
-    EVENT_TEARDOWN;
-    return;
-  }
 
   mid = SYM2ID(msym);
   klass = rb_tracearg_defined_class(trace_arg);
@@ -344,7 +337,7 @@ return_event(VALUE trace_point, void *data)
 
   if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
   {
-    reset_stepping_stop_points(dc);
+    byebug_reset_stepping_stop_points(dc);
 
     call_at_return(context, dc, rb_tracearg_return_value(trace_arg));
   }
@@ -367,7 +360,9 @@ return_event(VALUE trace_point, void *data)
      *   [#7] b_return@/hort/core_ext/numeric/conversions.rb:133 BigDecimal#to_s
      *  [#7] return@:0 Fixnum#to_s # => This guy...
      */
-    if (!NIL_P(file))
+    if (NIL_P(file))
+      rb_warn("The TracePoint API emitted a return event without file information. It might be a bug, please report this.");
+    else
     {
       line = rb_tracearg_lineno(trace_arg);
       binding = rb_tracearg_binding(trace_arg);
@@ -393,7 +388,7 @@ end_event(VALUE trace_point, void *data)
 
   if ((dc->steps_out == 0) && (CTX_FL_TEST(dc, CTX_FL_STOP_ON_RET)))
   {
-    reset_stepping_stop_points(dc);
+    byebug_reset_stepping_stop_points(dc);
 
     call_at_end(context, dc);
   }
@@ -436,7 +431,7 @@ raise_event(VALUE trace_point, void *data)
 
   raised_exception = rb_tracearg_raised_exception(trace_arg);
 
-  if (post_mortem == Qtrue)
+  if (post_mortem == Qtrue && !rb_ivar_defined(raised_exception, rb_intern("@__bb_context")))
   {
     pm_context = context_dup(dc);
     rb_ivar_set(raised_exception, rb_intern("@__bb_context"), pm_context);
@@ -721,7 +716,7 @@ Start(VALUE self)
  *  +stop+ parameter forces byebug to stop at the first line of code in +file+
  */
 static VALUE
-Debug_load(int argc, VALUE * argv, VALUE self)
+Debug_load(int argc, VALUE *argv, VALUE self)
 {
   VALUE file, stop, context;
   debug_context_t *dc;
@@ -747,7 +742,7 @@ Debug_load(int argc, VALUE * argv, VALUE self)
   if (0 != state)
   {
     status = rb_errinfo();
-    reset_stepping_stop_points(dc);
+    byebug_reset_stepping_stop_points(dc);
   }
 
   return status;
@@ -891,8 +886,8 @@ Init_byebug()
   rb_define_module_function(mByebug, "verbose=", Set_verbose, 1);
 
   Init_threads_table(mByebug);
-  Init_context(mByebug);
-  Init_breakpoint(mByebug);
+  Init_byebug_context(mByebug);
+  Init_byebug_breakpoint(mByebug);
 
   rb_global_variable(&breakpoints);
   rb_global_variable(&catchpoints);

data/ext/byebug/byebug.h

@@ -8,18 +8,26 @@
 #define UNUSED(x) (void)(x)
 
 /* flags */
-#define CTX_FL_DEAD         (1<<1)      /* this context belonged to a dead thread */
-#define CTX_FL_IGNORE       (1<<2)      /* this context belongs to ignored thread */
-#define CTX_FL_SUSPEND      (1<<3)      /* thread currently suspended             */
-#define CTX_FL_TRACING      (1<<4)      /* call at_tracing method                 */
-#define CTX_FL_WAS_RUNNING  (1<<5)      /* thread was previously running          */
-#define CTX_FL_STOP_ON_RET  (1<<6)      /* can stop on method 'end'               */
-#define CTX_FL_IGNORE_STEPS (1<<7)      /* doesn't countdown steps to break       */
+#define CTX_FL_DEAD (1 << 1)         /* this context belonged to a dead thread */
+#define CTX_FL_IGNORE (1 << 2)       /* this context belongs to ignored thread */
+#define CTX_FL_SUSPEND (1 << 3)      /* thread currently suspended             */
+#define CTX_FL_TRACING (1 << 4)      /* call at_tracing method                 */
+#define CTX_FL_WAS_RUNNING (1 << 5)  /* thread was previously running          */
+#define CTX_FL_STOP_ON_RET (1 << 6)  /* can stop on method 'end'               */
+#define CTX_FL_IGNORE_STEPS (1 << 7) /* doesn't countdown steps to break       */
 
 /* macro functions */
-#define CTX_FL_TEST(c,f) ((c)->flags & (f))
-#define CTX_FL_SET(c,f) do { (c)->flags |= (f); } while (0)
-#define CTX_FL_UNSET(c,f) do { (c)->flags &= ~(f); } while (0)
+#define CTX_FL_TEST(c, f) ((c)->flags & (f))
+#define CTX_FL_SET(c, f) \
+  do                     \
+  {                      \
+    (c)->flags |= (f);   \
+  } while (0)
+#define CTX_FL_UNSET(c, f) \
+  do                       \
+  {                        \
+    (c)->flags &= ~(f);    \
+  } while (0)
 
 /* types */
 typedef enum
@@ -39,12 +47,12 @@ typedef struct
   VALUE thread;
   int thnum;
 
-  int dest_frame;       /* next stop's frame if stopped by next     */
-  int lines;    /* # of lines in dest_frame before stopping */
-  int steps;    /* # of steps before stopping               */
-  int steps_out;        /* # of returns before stopping             */
+  int dest_frame; /* next stop's frame if stopped by next     */
+  int lines;      /* # of lines in dest_frame before stopping */
+  int steps;      /* # of steps before stopping               */
+  int steps_out;  /* # of returns before stopping             */
 
-  VALUE backtrace;      /* [[loc, self, klass, binding], ...] */
+  VALUE backtrace; /* [[loc, self, klass, binding], ...] */
 } debug_context_t;
 
 typedef enum
@@ -70,10 +78,18 @@ typedef struct
 } threads_table_t;
 
 enum bp_type
-{ BP_POS_TYPE, BP_METHOD_TYPE };
+{
+  BP_POS_TYPE,
+  BP_METHOD_TYPE
+};
 
 enum hit_condition
-{ HIT_COND_NONE, HIT_COND_GE, HIT_COND_EQ, HIT_COND_MOD };
+{
+  HIT_COND_NONE,
+  HIT_COND_GE,
+  HIT_COND_EQ,
+  HIT_COND_MOD
+};
 
 typedef struct
 {
@@ -93,16 +109,16 @@ typedef struct
 } breakpoint_t;
 
 /* functions from locker.c */
-extern void add_to_locked(VALUE thread);
-extern VALUE pop_from_locked();
-extern void remove_from_locked(VALUE thread);
+extern void byebug_add_to_locked(VALUE thread);
+extern VALUE byebug_pop_from_locked();
+extern void byebug_remove_from_locked(VALUE thread);
 
 /* functions from threads.c */
 extern void Init_threads_table(VALUE mByebug);
 extern VALUE create_threads_table(void);
-extern void thread_context_lookup(VALUE thread, VALUE * context);
+extern void thread_context_lookup(VALUE thread, VALUE *context);
 extern int is_living_thread(VALUE thread);
-extern void acquire_lock(debug_context_t * dc);
+extern void acquire_lock(debug_context_t *dc);
 extern void release_lock(void);
 
 /* global variables */
@@ -110,16 +126,16 @@ extern VALUE threads;
 extern VALUE next_thread;
 
 /* functions from context.c */
-extern void Init_context(VALUE mByebug);
-extern VALUE context_create(VALUE thread);
-extern VALUE context_dup(debug_context_t * context);
-extern void reset_stepping_stop_points(debug_context_t * context);
+extern void Init_byebug_context(VALUE mByebug);
+extern VALUE byebug_context_create(VALUE thread);
+extern VALUE context_dup(debug_context_t *context);
+extern void byebug_reset_stepping_stop_points(debug_context_t *context);
 extern VALUE call_with_debug_inspector(struct call_with_inspection_data *data);
-extern VALUE context_backtrace_set(const rb_debug_inspector_t * inspector,
+extern VALUE context_backtrace_set(const rb_debug_inspector_t *inspector,
                                    void *data);
 
 /* functions from breakpoint.c */
-extern void Init_breakpoint(VALUE mByebug);
+extern void Init_byebug_breakpoint(VALUE mByebug);
 extern VALUE find_breakpoint_by_pos(VALUE breakpoints, VALUE source, VALUE pos,
                                     VALUE bind);
 

data/ext/byebug/context.c

@@ -5,9 +5,9 @@ static VALUE cDebugThread;
 static int thnum_max = 0;
 
 /* "Step", "Next" and "Finish" do their work by saving information about where
- * to stop next. reset_stepping_stop_points removes/resets this information. */
+ * to stop next. byebug_reset_stepping_stop_points removes/resets this information. */
 extern void
-reset_stepping_stop_points(debug_context_t * context)
+byebug_reset_stepping_stop_points(debug_context_t *context)
 {
   context->dest_frame = -1;
   context->lines = -1;
@@ -34,19 +34,19 @@ Context_dead(VALUE self)
 static void
 context_mark(void *data)
 {
-  debug_context_t *context = (debug_context_t *) data;
+  debug_context_t *context = (debug_context_t *)data;
 
   rb_gc_mark(context->backtrace);
 }
 
 static VALUE
-dc_backtrace(const debug_context_t * context)
+dc_backtrace(const debug_context_t *context)
 {
   return context->backtrace;
 }
 
 static int
-dc_stack_size(debug_context_t * context)
+dc_stack_size(debug_context_t *context)
 {
 
   if (NIL_P(dc_backtrace(context)))
@@ -56,14 +56,14 @@ dc_stack_size(debug_context_t * context)
 }
 
 extern VALUE
-context_create(VALUE thread)
+byebug_context_create(VALUE thread)
 {
   debug_context_t *context = ALLOC(debug_context_t);
 
   context->flags = 0;
   context->thnum = ++thnum_max;
   context->thread = thread;
-  reset_stepping_stop_points(context);
+  byebug_reset_stepping_stop_points(context);
   context->stop_reason = CTX_STOP_NONE;
 
   rb_debug_inspector_open(context_backtrace_set, (void *)context);
@@ -76,12 +76,12 @@ context_create(VALUE thread)
 }
 
 extern VALUE
-context_dup(debug_context_t * context)
+context_dup(debug_context_t *context)
 {
   debug_context_t *new_context = ALLOC(debug_context_t);
 
   memcpy(new_context, context, sizeof(debug_context_t));
-  reset_stepping_stop_points(new_context);
+  byebug_reset_stepping_stop_points(new_context);
   new_context->backtrace = context->backtrace;
   CTX_FL_SET(new_context, CTX_FL_DEAD);
 
@@ -90,7 +90,7 @@ context_dup(debug_context_t * context)
 
 
 static VALUE
-dc_frame_get(const debug_context_t * context, int frame_index, frame_part type)
+dc_frame_get(const debug_context_t *context, int frame_index, frame_part type)
 {
   VALUE frame;
 
@@ -105,31 +105,31 @@ dc_frame_get(const debug_context_t * context, int frame_index, frame_part type)
 }
 
 static VALUE
-dc_frame_location(const debug_context_t * context, int frame_index)
+dc_frame_location(const debug_context_t *context, int frame_index)
 {
   return dc_frame_get(context, frame_index, LOCATION);
 }
 
 static VALUE
-dc_frame_self(const debug_context_t * context, int frame_index)
+dc_frame_self(const debug_context_t *context, int frame_index)
 {
   return dc_frame_get(context, frame_index, SELF);
 }
 
 static VALUE
-dc_frame_class(const debug_context_t * context, int frame_index)
+dc_frame_class(const debug_context_t *context, int frame_index)
 {
   return dc_frame_get(context, frame_index, CLASS);
 }
 
 static VALUE
-dc_frame_binding(const debug_context_t * context, int frame_index)
+dc_frame_binding(const debug_context_t *context, int frame_index)
 {
   return dc_frame_get(context, frame_index, BINDING);
 }
 
 static VALUE
-load_backtrace(const rb_debug_inspector_t * inspector)
+load_backtrace(const rb_debug_inspector_t *inspector)
 {
   VALUE backtrace = rb_ary_new();
   VALUE locs = rb_debug_inspector_backtrace_locations(inspector);
@@ -151,9 +151,9 @@ load_backtrace(const rb_debug_inspector_t * inspector)
 }
 
 extern VALUE
-context_backtrace_set(const rb_debug_inspector_t * inspector, void *data)
+context_backtrace_set(const rb_debug_inspector_t *inspector, void *data)
 {
-  debug_context_t *dc = (debug_context_t *) data;
+  debug_context_t *dc = (debug_context_t *)data;
 
   dc->backtrace = load_backtrace(inspector);
 
@@ -161,7 +161,7 @@ context_backtrace_set(const rb_debug_inspector_t * inspector, void *data)
 }
 
 static VALUE
-open_debug_inspector_i(const rb_debug_inspector_t * inspector, void *data)
+open_debug_inspector_i(const rb_debug_inspector_t *inspector, void *data)
 {
   struct call_with_inspection_data *cwi =
     (struct call_with_inspection_data *)data;
@@ -177,6 +177,13 @@ open_debug_inspector(struct call_with_inspection_data *cwi)
   return rb_debug_inspector_open(open_debug_inspector_i, cwi);
 }
 
+static VALUE
+open_debug_inspector_ensure(VALUE v)
+{
+  return open_debug_inspector((struct call_with_inspection_data *)v);
+}
+
+
 static VALUE
 close_debug_inspector(struct call_with_inspection_data *cwi)
 {
@@ -184,11 +191,17 @@ close_debug_inspector(struct call_with_inspection_data *cwi)
   return Qnil;
 }
 
+static VALUE
+close_debug_inspector_ensure(VALUE v)
+{
+  return close_debug_inspector((struct call_with_inspection_data *)v);
+}
+
 extern VALUE
 call_with_debug_inspector(struct call_with_inspection_data *data)
 {
-  return rb_ensure(open_debug_inspector, (VALUE) data, close_debug_inspector,
-                   (VALUE) data);
+  return rb_ensure(open_debug_inspector_ensure, (VALUE)data, close_debug_inspector_ensure,
+                   (VALUE)data);
 }
 
 #define FRAME_SETUP                                \
@@ -208,7 +221,7 @@ call_with_debug_inspector(struct call_with_inspection_data *data)
  *  Returns frame's binding.
  */
 static VALUE
-Context_frame_binding(int argc, VALUE * argv, VALUE self)
+Context_frame_binding(int argc, VALUE *argv, VALUE self)
 {
   FRAME_SETUP;
 
@@ -217,12 +230,12 @@ Context_frame_binding(int argc, VALUE * argv, VALUE self)
 
 /*
  *  call-seq:
- *    context.frame_class(frame_position = 0) -> binding
+ *    context.frame_class(frame_position = 0) -> class
  *
  *  Returns frame's defined class.
  */
 static VALUE
-Context_frame_class(int argc, VALUE * argv, VALUE self)
+Context_frame_class(int argc, VALUE *argv, VALUE self)
 {
   FRAME_SETUP;
 
@@ -236,7 +249,7 @@ Context_frame_class(int argc, VALUE * argv, VALUE self)
  *  Returns the name of the file in the frame.
  */
 static VALUE
-Context_frame_file(int argc, VALUE * argv, VALUE self)
+Context_frame_file(int argc, VALUE *argv, VALUE self)
 {
   VALUE loc, absolute_path;
 
@@ -259,7 +272,7 @@ Context_frame_file(int argc, VALUE * argv, VALUE self)
  *  Returns the line number in the file in the frame.
  */
 static VALUE
-Context_frame_line(int argc, VALUE * argv, VALUE self)
+Context_frame_line(int argc, VALUE *argv, VALUE self)
 {
   VALUE loc;
 
@@ -277,7 +290,7 @@ Context_frame_line(int argc, VALUE * argv, VALUE self)
  *  Returns the sym of the method in the frame.
  */
 static VALUE
-Context_frame_method(int argc, VALUE * argv, VALUE self)
+Context_frame_method(int argc, VALUE *argv, VALUE self)
 {
   VALUE loc;
 
@@ -295,7 +308,7 @@ Context_frame_method(int argc, VALUE * argv, VALUE self)
  *  Returns self object of the frame.
  */
 static VALUE
-Context_frame_self(int argc, VALUE * argv, VALUE self)
+Context_frame_self(int argc, VALUE *argv, VALUE self)
 {
   FRAME_SETUP;
 
@@ -395,7 +408,7 @@ Context_stop_reason(VALUE self)
  *  +frame+ (by default the newest one).
  */
 static VALUE
-Context_step_into(int argc, VALUE * argv, VALUE self)
+Context_step_into(int argc, VALUE *argv, VALUE self)
 {
   VALUE steps, v_frame;
   int n_args, from_frame;
@@ -435,7 +448,7 @@ Context_step_into(int argc, VALUE * argv, VALUE self)
  *  event for that frame is triggered.
  */
 static VALUE
-Context_step_out(int argc, VALUE * argv, VALUE self)
+Context_step_out(int argc, VALUE *argv, VALUE self)
 {
   int n_args, n_frames;
   VALUE v_frames, force;
@@ -468,7 +481,7 @@ Context_step_out(int argc, VALUE * argv, VALUE self)
  *  higher (if frame +frame+ finishes).
  */
 static VALUE
-Context_step_over(int argc, VALUE * argv, VALUE self)
+Context_step_over(int argc, VALUE *argv, VALUE self)
 {
   int n_args, frame;
   VALUE lines, v_frame;
@@ -642,7 +655,7 @@ dt_inherited(VALUE klass)
  *   Byebug keeps a single instance of this class per thread.
  */
 void
-Init_context(VALUE mByebug)
+Init_byebug_context(VALUE mByebug)
 {
   cContext = rb_define_class_under(mByebug, "Context", rb_cObject);
 
@@ -669,5 +682,5 @@ Init_context(VALUE mByebug)
   rb_define_method(cContext, "tracing=", Context_set_tracing, 1);
 
   cDebugThread = rb_define_class_under(mByebug, "DebugThread", rb_cThread);
-  rb_define_singleton_method(cDebugThread, "inherited", dt_inherited, 1);
+  rb_define_singleton_method(cDebugThread, "inherited", dt_inherited, 0);
 }

data/ext/byebug/extconf.rb

@@ -1,10 +1,12 @@
-require 'mkmf'
+# frozen_string_literal: true
+
+require "mkmf"
 
 makefile_config = RbConfig::MAKEFILE_CONFIG
 
-makefile_config['CC'] = ENV['CC'] if ENV['CC']
+makefile_config["CC"] = ENV["CC"] if ENV["CC"]
 
-makefile_config['CFLAGS'] << ' -gdwarf-2 -g3 -O0' if ENV['debug']
+makefile_config["CFLAGS"] << " -gdwarf-2 -g3 -O0" if ENV["debug"]
 
-dir_config('ruby')
-with_cflags(makefile_config['CFLAGS']) { create_makefile('byebug/byebug') }
+dir_config("ruby")
+with_cflags(makefile_config["CFLAGS"]) { create_makefile("byebug/byebug") }

data/ext/byebug/locker.c

@@ -29,7 +29,7 @@ is_in_locked(VALUE thread)
 }
 
 extern void
-add_to_locked(VALUE thread)
+byebug_add_to_locked(VALUE thread)
 {
   locked_thread_t *node;
 
@@ -50,7 +50,7 @@ add_to_locked(VALUE thread)
 }
 
 extern VALUE
-pop_from_locked()
+byebug_pop_from_locked()
 {
   VALUE thread;
   locked_thread_t *node;
@@ -71,7 +71,7 @@ pop_from_locked()
 }
 
 extern void
-remove_from_locked(VALUE thread)
+byebug_remove_from_locked(VALUE thread)
 {
   locked_thread_t *node;
   locked_thread_t *next_node;
@@ -81,7 +81,7 @@ remove_from_locked(VALUE thread)
 
   if (locked_head->thread == thread)
   {
-    pop_from_locked();
+    byebug_pop_from_locked();
     return;
   }