Weak Cells

src/heap/objects-visiting-inl.h

 // 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.
 
 #ifndef V8_OBJECTS_VISITING_INL_H_
 #define V8_OBJECTS_VISITING_INL_H_
 
 
 namespace v8 {
 namespace internal {
@@ skipping 173 matching lines @@
   table_.Register(kVisitJSDataView, &VisitJSDataView);
 
   // Registration for kVisitJSRegExp is done by StaticVisitor.
 
   table_.Register(
       kVisitCell,
       &FixedBodyVisitor<StaticVisitor, Cell::BodyDescriptor, void>::Visit);
 
   table_.Register(kVisitPropertyCell, &VisitPropertyCell);
 
+  table_.Register(kVisitWeakCell, &VisitWeakCell);
+
   table_.template RegisterSpecializations<DataObjectVisitor, kVisitDataObject,
                                           kVisitDataObjectGeneric>();
 
   table_.template RegisterSpecializations<JSObjectVisitor, kVisitJSObject,
                                           kVisitJSObjectGeneric>();
 
   table_.template RegisterSpecializations<StructObjectVisitor, kVisitStruct,
                                           kVisitStructGeneric>();
 }
 
@@ skipping 139 matching lines @@
   }
 
   StaticVisitor::VisitPointers(
       heap,
       HeapObject::RawField(object, PropertyCell::kPointerFieldsBeginOffset),
       HeapObject::RawField(object, PropertyCell::kPointerFieldsEndOffset));
 }
 
 
 template <typename StaticVisitor>
+void StaticMarkingVisitor<StaticVisitor>::VisitWeakCell(Map* map,
+                                                        HeapObject* object) {
+  Heap* heap = map->GetHeap();
+  WeakCell* weak_cell = reinterpret_cast<WeakCell*>(object);
+  // Enqueue weak cell in linked list of encountered weak collections.
+  if (weak_cell->next() == heap->undefined_value()) {

[Erik Corry, 2014/10/14 13:37:22]

I think this should set to smi zero.

Since there's no set_value function, there's no need to chain up the weak cell
if it only contains undefined.

Even if there was a set_value method (is there actually one? the design doc says
there isn't...) the write barrier should ensure that we come back here if it is
used.

[ulan, 2014/10/14 14:05:41]

Good idea about skipping cleared weak cells. Added a check.

About setting to smi zero: undefined and smi zero help us distinguish the
following cases:
- weak cell is not in the list (next() == undefined)
- weak cell is the last element of the list (next() == smi zero)
- weak cell is in the list and not the last element (next() == pointer to a weak
cell)

We could probably use smi zero for first two cases, but then it would complicate
debugging.

+    weak_cell->set_next(heap->encountered_weak_cells());
+    heap->set_encountered_weak_cells(weak_cell);
+  }
+}
+
+
+template <typename StaticVisitor>
 void StaticMarkingVisitor<StaticVisitor>::VisitAllocationSite(
     Map* map, HeapObject* object) {
   Heap* heap = map->GetHeap();
 
   Object** slot =
       HeapObject::RawField(object, AllocationSite::kDependentCodeOffset);
   if (FLAG_collect_maps) {
     // Mark allocation site dependent codes array but do not push it onto
     // marking stack, this will make references from it weak. We will clean
     // dead codes when we iterate over allocation sites in
@@ skipping 562 matching lines @@
 
   RelocIterator it(this, mode_mask);
   for (; !it.done(); it.next()) {
     it.rinfo()->template Visit<StaticVisitor>(heap);
   }
 }
 }
 }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_INL_H_