Avoid object layout changes during GC.

src/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 7205 matching lines @@
                      : heap->the_hole_value();
     }
   }
 }
 
 
 void ErrorObjectList::DeferredFormatStackTrace(Isolate* isolate) {
   // If formatting the stack trace causes a GC, this method will be
   // recursively called.  In that case, skip the recursive call, since
   // the loop modifies the list while iterating over it.
-  if (nested_) return;
+  if (nested_ || isolate->has_pending_exception()) return;
   nested_ = true;
   HandleScope scope(isolate);
   Handle<String> stack_key = isolate->factory()->stack_symbol();
   int write_index = 0;
   int budget = kBudgetPerGC;
   for (int i = 0; i < list_.length(); i++) {
     Object* object = list_[i];
     // Skip possible holes in the list.
     if (object->IsTheHole()) continue;
     if (isolate->heap()->InNewSpace(object) || budget == 0) {
       list_[write_index++] = object;
       continue;
     }
 
     // Fire the stack property getter, if it is the original marked getter.
     LookupResult lookup(isolate);
     JSObject::cast(object)->LocalLookupRealNamedProperty(*stack_key, &lookup);
     if (!lookup.IsFound() || lookup.type() != CALLBACKS) continue;
     Object* callback = lookup.GetCallbackObject();
     if (!callback->IsAccessorPair()) continue;
     Object* getter_obj = AccessorPair::cast(callback)->getter();
     if (!getter_obj->IsJSFunction()) continue;
     JSFunction* getter_fun = JSFunction::cast(getter_obj);
     String* key = isolate->heap()->hidden_stack_trace_symbol();
     if (key != getter_fun->GetHiddenProperty(key)) continue;
+    budget--;
     bool has_exception = false;
     Execution::Call(Handle<Object>(getter_fun, isolate),
                     Handle<Object>(object, isolate),
                     0,
                     NULL,
                     &has_exception);
-    ASSERT(!has_exception);
-    budget--;
+    if (has_exception) {
+      // Hit an exception (most likely a stack overflow).
+      // Wrap up this pass and retry after another GC.
+      isolate->clear_pending_exception();
+      list_[write_index++] = object;
+      budget = 0;
+    }
   }
   list_.Rewind(write_index);
   list_.Trim();
   nested_ = false;
 }
 
 
 void ErrorObjectList::RemoveUnmarked(Heap* heap) {
   for (int i = 0; i < list_.length(); i++) {
     HeapObject* object = HeapObject::cast(list_[i]);
@@ skipping 130 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 
 } }  // namespace v8::internal