Oilpan: fix tracing of un-initialized part objects during conservative GCs.

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 503 matching lines @@
 {
     ASSERT(contains(address));
     if (!objectContains(address) || heapObjectHeader()->hasDeadMark())
         return;
 #if ENABLE(GC_PROFILE_MARKING)
     visitor->setHostInfo(&address, "stack");
 #endif
     mark(visitor);
 }
 
+#if ENABLE(ASSERT)
+static bool isUninitializedMemory(void* objectPointer, size_t objectSize)
+{
+    // Scan through the object's fields and check that they are all zero.
+    Address* objectFields = reinterpret_cast<Address*>(objectPointer);
+    for (size_t i = 0; i < objectSize / sizeof(Address); ++i) {
+        if (objectFields[i] != 0)
+            return false;
+    }
+    return true;
+}
+#endif
+
 template<>
 void LargeHeapObject<FinalizedHeapObjectHeader>::mark(Visitor* visitor)
 {
-    if (heapObjectHeader()->hasVTable() && !vTableInitialized(payload()))
-        visitor->markConservatively(heapObjectHeader());
-    else
+    if (heapObjectHeader()->hasVTable() && !vTableInitialized(payload())) {
+        FinalizedHeapObjectHeader* header = heapObjectHeader();
+        visitor->markNoTracing(header);
+        ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
+    } else {
         visitor->mark(heapObjectHeader(), heapObjectHeader()->traceCallback());
+    }
 }
 
 template<>
 void LargeHeapObject<HeapObjectHeader>::mark(Visitor* visitor)
 {
     ASSERT(gcInfo());
-    if (gcInfo()->hasVTable() && !vTableInitialized(payload()))
-        visitor->markConservatively(heapObjectHeader());
-    else
+    if (gcInfo()->hasVTable() && !vTableInitialized(payload())) {
+        HeapObjectHeader* header = heapObjectHeader();
+        visitor->markNoTracing(header);
+        ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
+    } else {
         visitor->mark(heapObjectHeader(), gcInfo()->m_trace);
+    }
 }
 
 template<>
 void LargeHeapObject<FinalizedHeapObjectHeader>::finalize()
 {
     heapObjectHeader()->finalize();
 }
 
 template<>
 void LargeHeapObject<HeapObjectHeader>::finalize()
@@ skipping 804 matching lines @@
 void HeapPage<Header>::checkAndMarkPointer(Visitor* visitor, Address address)
 {
     ASSERT(contains(address));
     Header* header = findHeaderFromAddress(address);
     if (!header || header->hasDeadMark())
         return;
 
 #if ENABLE(GC_PROFILE_MARKING)
     visitor->setHostInfo(&address, "stack");
 #endif
-    if (hasVTable(header) && !vTableInitialized(header->payload()))
-        visitor->markConservatively(header);
-    else
+    if (hasVTable(header) && !vTableInitialized(header->payload())) {
+        visitor->markNoTracing(header);
+        ASSERT(isUninitializedMemory(header->payload(), header->payloadSize()));
+    } else {
         visitor->mark(header, traceCallback(header));
+    }
 }
 
 #if ENABLE(GC_PROFILE_MARKING)
 template<typename Header>
 const GCInfo* HeapPage<Header>::findGCInfo(Address address)
 {
     if (address < payload())
         return 0;
 
     if (gcInfo()) // for non FinalizedObjectHeader
@@ skipping 394 matching lines @@
     }
 
     virtual void mark(const void* objectPointer, TraceCallback callback) OVERRIDE
     {
         if (!objectPointer)
             return;
         FinalizedHeapObjectHeader* header = FinalizedHeapObjectHeader::fromPayload(objectPointer);
         visitHeader(header, header->payload(), callback);
     }
 
-
-    inline void visitConservatively(HeapObjectHeader* header, void* objectPointer, size_t objectSize)
-    {
-        ASSERT(header);
-        ASSERT(objectPointer);
-        if (header->isMarked())
-            return;
-        header->mark();
-
-        // Scan through the object's fields and visit them conservatively.
-        Address* objectFields = reinterpret_cast<Address*>(objectPointer);
-        for (size_t i = 0; i < objectSize / sizeof(Address); ++i)
-            Heap::checkAndMarkPointer(this, objectFields[i]);
-    }
-
-    virtual void markConservatively(HeapObjectHeader* header)
-    {
-        // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
-        // version to correctly find the payload.
-        visitConservatively(header, header->payload(), header->payloadSize());
-    }
-
-    virtual void markConservatively(FinalizedHeapObjectHeader* header)
-    {
-        // We need both the HeapObjectHeader and FinalizedHeapObjectHeader
-        // version to correctly find the payload.
-        visitConservatively(header, header->payload(), header->payloadSize());
-    }
-
     virtual void registerWeakMembers(const void* closure, const void* containingObject, WeakPointerCallback callback) OVERRIDE
     {
         Heap::pushWeakObjectPointerCallback(const_cast<void*>(closure), const_cast<void*>(containingObject), callback);
     }
 
     virtual void registerWeakTable(const void* closure, EphemeronCallback iterationCallback, EphemeronCallback iterationDoneCallback)
     {
         Heap::registerWeakTable(const_cast<void*>(closure), iterationCallback, iterationDoneCallback);
     }
 
@@ skipping 561 matching lines @@
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 }