rubinius · Mar 13, 2016 · Mar 13, 2016
diff --git a/core/vm.rb b/core/vm.rb
@@ -5,7 +5,7 @@ class Rubinius::VM
   # Rubinius::VariableScope object that can be used to access the frames
   # running information like locals, self, etc.
   #
-  def self.backtrace(frames_to_skip, include_vars=false)
+  def self.backtrace(frames_to_skip)
     Rubinius.primitive :vm_backtrace
 
     # Add the + 1 to skip this frame

diff --git a/machine/builtin/location.cpp b/machine/builtin/location.cpp
@@ -86,71 +86,87 @@ namespace rubinius {
     return loc;
   }
 
-  Array* Location::from_call_stack(STATE, bool include_vars, bool on_ip, ssize_t up) {
-    CallFrame* frame = state->vm()->call_frame();
-
-    while(frame && up-- > 0) {
-      frame = frame->previous;
-    }
-
-    if(!frame) return nil<Array>();
-
+  Array* Location::debugging_call_stack(STATE) {
+    CallFrame* base = state->vm()->call_frame();
     size_t count = 0;
 
-    CallFrame* base = frame;
     while(base) {
       count++;
       base = base->previous;
     }
 
+    if(!base) return nil<Array>();
+
     Array* array = Array::create(state, count);
     bool first = true;
 
-    while(frame) {
-      if(first) {
-        if(!frame->compiled_code) continue;
-
-        first = false;
-        if(Location* location = Location::create(state, frame, include_vars)) {
-          if(on_ip) location->set_ip_on_current(state);
+    for(CallFrame* frame = base; frame; frame = frame->previous) {
+      if(frame->compiled_code) {
+        if(Location* location = Location::create(state, frame, true)) {
+          if(first) {
+            location->set_ip_on_current(state);
+            first = false;
+          }
           array->append(state, location);
         }
-      } else {
-        if(frame->compiled_code) {
-          array->append(state, Location::create(state, frame, include_vars));
-        } else if(NativeMethodFrame* nmf = frame->native_method_frame()) {
-          if(Location* location = Location::create(state, nmf)) {
-            array->append(state, location);
-          }
+      } else if(NativeMethodFrame* nmf = frame->native_method_frame()) {
+        if(Location* location = Location::create(state, nmf)) {
+          array->append(state, location);
         }
       }
-
-      frame = frame->previous;
     }
 
     return array;
   }
 
-  Array* Location::mri_backtrace(STATE, ssize_t up) {
-    CallFrame* frame = state->vm()->call_frame();
+  Array* Location::from_call_stack(STATE, ssize_t up) {
+    CallFrame* base = state->vm()->call_frame();
+    size_t count = 0;
 
-    while(frame && up-- > 0) {
-      frame = frame->previous;
+    while(base) {
+      if(up-- > 0) {
+        // ignore this frame
+      } else {
+        count++;
+      }
+      base = base->previous;
     }
 
-    if(!frame) return nil<Array>();
+    if(!base) return nil<Array>();
 
+    Array* array = Array::create(state, count);
+
+    for(CallFrame* frame = base; frame; frame = frame->previous) {
+      if(frame->compiled_code) {
+        array->append(state, Location::create(state, frame));
+      } else if(NativeMethodFrame* nmf = frame->native_method_frame()) {
+        if(Location* location = Location::create(state, nmf)) {
+          array->append(state, location);
+        }
+      }
+    }
+
+    return array;
+  }
+
+  Array* Location::mri_backtrace(STATE, ssize_t up) {
+    CallFrame* base = state->vm()->call_frame();
     size_t count = 0;
 
-    CallFrame* base = frame;
     while(base) {
-      count++;
+      if(up-- > 0) {
+        // ignore this frame
+      } else {
+        count++;
+      }
       base = base->previous;
     }
 
+    if(!base) return nil<Array>();
+
     Array* array = Array::create(state, count);
 
-    while(frame) {
+    for(CallFrame* frame = base; frame; frame = frame->previous) {
       if(frame->compiled_code && !frame->compiled_code->core_method(state)) {
         Symbol* name;
         Object* block = cFalse;
@@ -177,8 +193,6 @@ namespace rubinius {
         array->append(state,
             Tuple::from(state, 4, frame->compiled_code, line, block, name));
       }
-
-      frame = frame->previous;
     }
 
     return array;

diff --git a/machine/builtin/location.hpp b/machine/builtin/location.hpp
@@ -71,8 +71,8 @@ namespace rubinius {
     // Rubinius.primitive :location_of_closest_ruby_method
     static Location* of_closest_ruby_method(STATE);
 
-    static Array* from_call_stack(STATE,
-        bool include_vars=false, bool on_ip=false, ssize_t up=1);
+    static Array* debugging_call_stack(STATE);
+    static Array* from_call_stack(STATE, ssize_t up=1);
     static Array* mri_backtrace(STATE, ssize_t up=1);
 
     class Info : public TypeInfo {

diff --git a/machine/builtin/native_method.cpp b/machine/builtin/native_method.cpp
@@ -639,7 +639,7 @@ namespace rubinius {
     if(arity >= 0 && (size_t)arity != args.total()) {
       Exception* exc = Exception::make_argument_error(
           state, arity, args.total(), args.name());
-      exc->locations(state, Location::from_call_stack(state, state->vm()->call_frame()));
+      exc->locations(state, Location::from_call_stack(state));
       state->raise_exception(exc);
 
       return NULL;

diff --git a/machine/builtin/object.cpp b/machine/builtin/object.cpp
@@ -101,7 +101,7 @@ namespace rubinius {
         class_object(state) != other->class_object(state)) {
       Exception* exc =
         Exception::make_type_error(state, type_id(), other);
-      exc->locations(state, Location::from_call_stack(state, state->vm()->call_frame()));
+      exc->locations(state, Location::from_call_stack(state));
       state->raise_exception(exc);
       return NULL;
     }

diff --git a/machine/builtin/system.cpp b/machine/builtin/system.cpp
@@ -941,16 +941,11 @@ namespace rubinius {
    /*  @todo Could possibly capture the system backtrace at this
    *        point. --rue
    */
-  Array* System::vm_backtrace(STATE, Fixnum* skip, Object* inc_vars) {
-    bool include_vars = CBOOL(inc_vars);
-
-    // TODO: CallFrame: fix this API
-    return Location::from_call_stack(state,
-        include_vars, false, skip->to_native());
+  Array* System::vm_backtrace(STATE, Fixnum* skip) {
+    return Location::from_call_stack(state, skip->to_native());
   }
 
   Array* System::vm_mri_backtrace(STATE, Fixnum* skip) {
-    // TODO: CallFrame: fix this API
     return Location::mri_backtrace(state, skip->to_native());
   }
 

diff --git a/machine/builtin/system.hpp b/machine/builtin/system.hpp
@@ -124,7 +124,7 @@ namespace rubinius {
      *  Backtrace as an Array.
      */
     // Rubinius.primitive :vm_backtrace
-    static Array* vm_backtrace(STATE, Fixnum* skip, Object* inc_vars);
+    static Array* vm_backtrace(STATE, Fixnum* skip);
 
     // Rubinius.primitive :vm_mri_backtrace
     static Array* vm_mri_backtrace(STATE, Fixnum* skip);

diff --git a/machine/capi/capi.cpp b/machine/capi/capi.cpp
@@ -156,6 +156,8 @@ namespace rubinius {
       // An exception occurred
       if(!ret) env->current_ep()->return_to(env);
 
+      env->state()->vm()->checkpoint(env->state());
+
       return ret_handle;
     }
 
@@ -201,6 +203,8 @@ namespace rubinius {
       // An exception occurred
       if(!ret) env->current_ep()->return_to(env);
 
+      env->state()->vm()->checkpoint(env->state());
+
       return ret_handle;
     }
 
@@ -254,6 +258,8 @@ namespace rubinius {
       // An exception occurred
       if(!ret) env->current_ep()->return_to(env);
 
+      env->state()->vm()->checkpoint(env->state());
+
       return ret_handle;
     }
 
@@ -300,6 +306,8 @@ namespace rubinius {
       // An exception occurred
       if(!ret) env->current_ep()->return_to(env);
 
+      env->state()->vm()->checkpoint(env->state());
+
       return ret_handle;
     }
 
@@ -357,8 +365,7 @@ namespace rubinius {
 
     void capi_raise_backend(Exception* exception) {
       NativeMethodEnvironment* env = NativeMethodEnvironment::get();
-      exception->locations(env->state(), Location::from_call_stack(env->state(),
-                           env->current_call_frame()));
+      exception->locations(env->state(), Location::from_call_stack(env->state()));
       env->state()->raise_exception(exception);
 
       env->current_ep()->return_to(env);

diff --git a/machine/helpers.cpp b/machine/helpers.cpp
@@ -309,7 +309,7 @@ namespace rubinius {
         cur->control_channel(state, my_control);
       }
 
-      Array* locs = Location::from_call_stack(state, true, true);
+      Array* locs = Location::debugging_call_stack(state);
 
       OnStack<1> os(state, my_control);