Implement verification of context separation.

src/mark-compact.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 278 matching lines @@
 #ifdef DEBUG
   if (FLAG_verify_heap) {
     VerifyMarking(heap_);
   }
 #endif
 
   SweepSpaces();
 
   if (!FLAG_collect_maps) ReattachInitialMaps();
 
+#ifdef DEBUG
+  if (FLAG_verify_context_separation) {
+    bool was_code_flushing_enabled = is_code_flushing_enabled();
+    EnableCodeFlushing(false);
+    VerifyMarkbitsAreClean();
+    VerifyContextSeparation();
+    EnableCodeFlushing(was_code_flushing_enabled);

[Toon Verwaest, 2012/07/13 09:02:04]

Please move the surrounding code into VerifyContextSeparation and add a comment
explaining the main idea; why code flushing needs to be disabled; why we need to
verify that the mark bits are clean etc.

+  }
+#endif
+
   Finish();
 
   tracer_ = NULL;
 }
 
 
 #ifdef DEBUG
 void MarkCompactCollector::VerifyMarkbitsAreClean(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     Page* p = it.next();
     CHECK(p->markbits()->IsClean());
     CHECK_EQ(0, p->LiveBytes());
   }
 }
 
+
 void MarkCompactCollector::VerifyMarkbitsAreClean(NewSpace* space) {
   NewSpacePageIterator it(space->bottom(), space->top());
 
   while (it.has_next()) {
     NewSpacePage* p = it.next();
     CHECK(p->markbits()->IsClean());
     CHECK_EQ(0, p->LiveBytes());
   }
 }
 
+
 void MarkCompactCollector::VerifyMarkbitsAreClean() {
   VerifyMarkbitsAreClean(heap_->old_pointer_space());
   VerifyMarkbitsAreClean(heap_->old_data_space());
   VerifyMarkbitsAreClean(heap_->code_space());
   VerifyMarkbitsAreClean(heap_->cell_space());
   VerifyMarkbitsAreClean(heap_->map_space());
   VerifyMarkbitsAreClean(heap_->new_space());
 
   LargeObjectIterator it(heap_->lo_space());
   for (HeapObject* obj = it.Next(); obj != NULL; obj = it.Next()) {
@@ skipping 1277 matching lines @@
       collector_->MarkObject(shared->code(), code_mark);
       collector_->MarkObject(shared, shared_mark);
     }
   }
 
  private:
   MarkCompactCollector* collector_;
 };
 
 
+#ifdef DEBUG
+static bool IsKnownInternalContext(Heap* heap, Object* context) {
+  Handle<Context> debug_context = heap->isolate()->debug()->debug_context();
+  if (!debug_context.is_null() && context == *debug_context) return true;
+  return false;
+}
+
+
+void MarkCompactCollector::VerifyContextSeparation() {
+  // Disabling of code cache flushing in maps is known to introduce cross
+  // context leaks and verification will most certainly fail.
+  if (!FLAG_cleanup_code_caches_at_gc) {
+    PrintF("[VerifyContextSeparation: Incompatible flags. Skipped.]\n");
+    return;
+  }
+
+  HeapObjectIterator it(heap_->code_space());
+  for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
+    Code* code = Code::cast(object);
+
+    // TODO(mstarzinger): We currently limit this verification to optimized
+    // code, but should extend it to cover all kinds of code objects.
+    if (code->kind() != Code::OPTIMIZED_FUNCTION) continue;
+
+    // Mark the code object and process transitive closure.
+    MarkingVisitor marker(heap_);
+    code->Iterate(&marker);
+    ProcessMarkingDeque();
+
+    // Count the number of global contexts that are kept alive by this
+    // code object.
+    int number_of_live_global_contexts = 0;
+    Object* context = heap_->global_contexts_list();
+    while (!context->IsUndefined()) {
+      ASSERT(context->IsGlobalContext());

[Toon Verwaest, 2012/07/13 09:02:04]

Can this happen?

+      if (!IsKnownInternalContext(heap_, context) &&
+          Marking::MarkBitFrom(HeapObject::cast(context)).Get()) {
+        number_of_live_global_contexts++;
+      }
+      context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
+    }
+    if (number_of_live_global_contexts > 1) {
+      PrintF("[VerifyContextSeparation: %p keeps %d contexts alive.]\n",
+             reinterpret_cast<void*>(code), number_of_live_global_contexts);
+#ifdef OBJECT_PRINT
+      code->PrintLn();
+      context = heap_->global_contexts_list();
+      while (!context->IsUndefined()) {
+        if (Marking::MarkBitFrom(HeapObject::cast(context)).Get()) {
+          context->PrintLn();
+        }
+        context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
+      }
+#endif
+    }
+    CHECK_LE(number_of_live_global_contexts, 1);
+    ClearMarkbits();
+    ReattachInitialMaps();
+  }
+}
+#endif
+
+
 void MarkCompactCollector::MarkInlinedFunctionsCode(Code* code) {
   // For optimized functions we should retain both non-optimized version
   // of it's code and non-optimized version of all inlined functions.
   // This is required to support bailing out from inlined code.
   DeoptimizationInputData* data =
       DeoptimizationInputData::cast(code->deoptimization_data());
 
   FixedArray* literals = data->LiteralArray();
 
   for (int i = 0, count = data->InlinedFunctionCount()->value();
@@ skipping 2320 matching lines @@
   // Give pages that are queued to be freed back to the OS.
   heap()->FreeQueuedChunks();
 }
 
 
 void MarkCompactCollector::SweepSpaces() {
   GCTracer::Scope gc_scope(tracer_, GCTracer::Scope::MC_SWEEP);
 #ifdef DEBUG
   state_ = SWEEP_SPACES;
 #endif
-  SweeperType how_to_sweep =
-      FLAG_lazy_sweeping ? LAZY_CONSERVATIVE : CONSERVATIVE;
-  if (FLAG_expose_gc) how_to_sweep = CONSERVATIVE;
+  bool lazy_sweeping =
+      FLAG_lazy_sweeping && !FLAG_expose_gc && !FLAG_verify_context_separation;
+  SweeperType how_to_sweep = lazy_sweeping ? LAZY_CONSERVATIVE : CONSERVATIVE;
   if (sweep_precisely_) how_to_sweep = PRECISE;
   // Noncompacting collections simply sweep the spaces to clear the mark
   // bits and free the nonlive blocks (for old and map spaces).  We sweep
   // the map space last because freeing non-live maps overwrites them and
   // the other spaces rely on possibly non-live maps to get the sizes for
   // non-live objects.
   SweepSpace(heap()->old_pointer_space(), how_to_sweep);
   SweepSpace(heap()->old_data_space(), how_to_sweep);
 
   RemoveDeadInvalidatedCode();
@@ skipping 180 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal