Attempt no. 3 to fix Heap::IsHeapIterable and HeapIterator

src/liveedit.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 #include "v8.h"
 
 #include "liveedit.h"
 
 #include "code-stubs.h"
@@ skipping 921 matching lines @@
 
 // Finds all references to original and replaces them with substitution.
 static void ReplaceCodeObject(Handle<Code> original,
                               Handle<Code> substitution) {
   // Perform a full GC in order to ensure that we are not in the middle of an
   // incremental marking phase when we are replacing the code object.
   // Since we are not in an incremental marking phase we can write pointers
   // to code objects (that are never in new space) without worrying about
   // write barriers.
   Heap* heap = original->GetHeap();
-  heap->CollectAllGarbage(Heap::kMakeHeapIterableMask,
-                          "liveedit.cc ReplaceCodeObject");
+  HeapIterator iterator(heap);
 
   ASSERT(!heap->InNewSpace(*substitution));
 
-  DisallowHeapAllocation no_allocation;
-
   ReplacingVisitor visitor(*original, *substitution);
 
   // Iterate over all roots. Stack frames may have pointer into original code,
   // so temporary replace the pointers with offset numbers
   // in prologue/epilogue.
   heap->IterateRoots(&visitor, VISIT_ALL);
 
   // Now iterate over all pointers of all objects, including code_target
   // implicit pointers.
-  HeapIterator iterator(heap);
   for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
     obj->Iterate(&visitor);
   }
 }
 
 
 // Patch function literals.
 // Name 'literals' is a misnomer. Rather it's a cache for complex object
 // boilerplates and for a native context. We must clean cached values.
 // Additionally we may need to allocate a new array if number of literals
 // changed.
 class LiteralFixer {
  public:
   static void PatchLiterals(FunctionInfoWrapper* compile_info_wrapper,
                             Handle<SharedFunctionInfo> shared_info,
                             Isolate* isolate) {
     int new_literal_count = compile_info_wrapper->GetLiteralCount();
     if (new_literal_count > 0) {
       new_literal_count += JSFunction::kLiteralsPrefixSize;
     }
     int old_literal_count = shared_info->num_literals();
 
     if (old_literal_count == new_literal_count) {
       // If literal count didn't change, simply go over all functions
       // and clear literal arrays.
       ClearValuesVisitor visitor;
-      IterateJSFunctions(*shared_info, &visitor);
+      IterateJSFunctions(shared_info, &visitor);
     } else {
       // When literal count changes, we have to create new array instances.
       // Since we cannot create instances when iterating heap, we should first
       // collect all functions and fix their literal arrays.
       Handle<FixedArray> function_instances =
           CollectJSFunctions(shared_info, isolate);
       for (int i = 0; i < function_instances->length(); i++) {
         Handle<JSFunction> fun(JSFunction::cast(function_instances->get(i)));
         Handle<FixedArray> old_literals(fun->literals());
         Handle<FixedArray> new_literals =
@@ skipping 14 matching lines @@
       }
 
       shared_info->set_num_literals(new_literal_count);
     }
   }
 
  private:
   // Iterates all function instances in the HEAP that refers to the
   // provided shared_info.
   template<typename Visitor>
-  static void IterateJSFunctions(SharedFunctionInfo* shared_info,
+  static void IterateJSFunctions(Handle<SharedFunctionInfo> shared_info,
                                  Visitor* visitor) {
-    DisallowHeapAllocation no_allocation;
-
     HeapIterator iterator(shared_info->GetHeap());
     for (HeapObject* obj = iterator.next(); obj != NULL;
         obj = iterator.next()) {
       if (obj->IsJSFunction()) {
         JSFunction* function = JSFunction::cast(obj);
-        if (function->shared() == shared_info) {
+        if (function->shared() == *shared_info) {
           visitor->visit(function);
         }
       }
     }
   }
 
   // Finds all instances of JSFunction that refers to the provided shared_info
   // and returns array with them.
   static Handle<FixedArray> CollectJSFunctions(
       Handle<SharedFunctionInfo> shared_info, Isolate* isolate) {
     CountVisitor count_visitor;
     count_visitor.count = 0;
-    IterateJSFunctions(*shared_info, &count_visitor);
+    IterateJSFunctions(shared_info, &count_visitor);
     int size = count_visitor.count;
 
     Handle<FixedArray> result = isolate->factory()->NewFixedArray(size);
     if (size > 0) {
       CollectVisitor collect_visitor(result);
-      IterateJSFunctions(*shared_info, &collect_visitor);
+      IterateJSFunctions(shared_info, &collect_visitor);
     }
     return result;
   }
 
   class ClearValuesVisitor {
    public:
     void visit(JSFunction* fun) {
       FixedArray* literals = fun->literals();
       int len = literals->length();
       for (int j = JSFunction::kLiteralsPrefixSize; j < len; j++) {
@@ skipping 99 matching lines @@
 void LiveEdit::ReplaceFunctionCode(
     Handle<JSArray> new_compile_info_array,
     Handle<JSArray> shared_info_array) {
   Isolate* isolate = new_compile_info_array->GetIsolate();
 
   FunctionInfoWrapper compile_info_wrapper(new_compile_info_array);
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
 
   Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
-  isolate->heap()->EnsureHeapIsIterable();
+  isolate->heap()->MakeHeapIterable();
 
   if (IsJSFunctionCode(shared_info->code())) {
     Handle<Code> code = compile_info_wrapper.GetFunctionCode();
     ReplaceCodeObject(Handle<Code>(shared_info->code()), code);
     Handle<Object> code_scope_info = compile_info_wrapper.GetCodeScopeInfo();
     if (code_scope_info->IsFixedArray()) {
       shared_info->set_scope_info(ScopeInfo::cast(*code_scope_info));
     }
     shared_info->DisableOptimization(kLiveEdit);
     // Update the type feedback vector
@@ skipping 216 matching lines @@
                                              position_change_array);
   int new_function_end = TranslatePosition(info->end_position(),
                                            position_change_array);
   int new_function_token_pos =
       TranslatePosition(info->function_token_position(), position_change_array);
 
   info->set_start_position(new_function_start);
   info->set_end_position(new_function_end);
   info->set_function_token_position(new_function_token_pos);
 
-  info->GetIsolate()->heap()->EnsureHeapIsIterable();
+  info->GetIsolate()->heap()->MakeHeapIterable();
 
   if (IsJSFunctionCode(info->code())) {
     // Patch relocation info section of the code.
     Handle<Code> patched_code = PatchPositionsInCode(Handle<Code>(info->code()),
                                                      position_change_array);
     if (*patched_code != info->code()) {
       // Replace all references to the code across the heap. In particular,
       // some stubs may refer to this code and this code may be being executed
       // on stack (it is safe to substitute the code object on stack, because
       // we only change the structure of rinfo and leave instructions
@@ skipping 417 matching lines @@
     }
   }
   return NULL;
 }
 
 
 bool LiveEdit::FindActiveGenerators(Handle<FixedArray> shared_info_array,
                                     Handle<FixedArray> result,
                                     int len) {
   Isolate* isolate = shared_info_array->GetIsolate();
-  Heap* heap = isolate->heap();
-  heap->EnsureHeapIsIterable();
   bool found_suspended_activations = false;
 
   ASSERT_LE(len, result->length());
 
-  DisallowHeapAllocation no_allocation;
-
   FunctionPatchabilityStatus active = FUNCTION_BLOCKED_ACTIVE_GENERATOR;
 
+  Heap* heap = isolate->heap();
   HeapIterator iterator(heap);
   HeapObject* obj = NULL;
   while ((obj = iterator.next()) != NULL) {
     if (!obj->IsJSGeneratorObject()) continue;
 
     JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
     if (gen->is_closed()) continue;
 
     HandleScope scope(isolate);
 
@@ skipping 165 matching lines @@
 void LiveEditFunctionTracker::RecordRootFunctionInfo(Handle<Code> code) {
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 } }  // namespace v8::internal