Add map-based read barrier to WeakCell

src/objects-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.
 //
 // Review notes:
 //
 // - The use of macros in these inline functions may seem superfluous
 // but it is absolutely needed to make sure gcc generates optimal
 // code. gcc is not happy when attempting to inline too deep.
 //
@@ skipping 1931 matching lines @@
 Object* PropertyCell::type_raw() const {
   return READ_FIELD(this, kTypeOffset);
 }
 
 
 void PropertyCell::set_type_raw(Object* val, WriteBarrierMode ignored) {
   WRITE_FIELD(this, kTypeOffset, val);
 }
 
 
-Object* WeakCell::value() const { return READ_FIELD(this, kValueOffset); }
+Object* WeakCell::value(Heap* heap) {
+  Object* pointer = READ_FIELD(this, kValueOffsetDontForgetTheReadBarrier);
+  NOBARRIER_WRITE_FIELD(this, kMapOffset, GetHeap()->used_weak_cell_map());
+  return pointer;
+}
+
+
+Object* WeakCell::ValueNoReadBarrier() {
+  return READ_FIELD(this, kValueOffsetDontForgetTheReadBarrier);
+}
+
+
+void WeakCell::TriggerReadBarrier(Object* possible_weak_cell) {
+  if (possible_weak_cell->IsWeakCell()) {
+    WeakCell* weak_cell = reinterpret_cast<WeakCell*>(possible_weak_cell);
+    weak_cell->value(weak_cell->GetHeap());
+  }
+}
 
 
 void WeakCell::clear() {
   DCHECK(GetHeap()->gc_state() == Heap::MARK_COMPACT);
-  WRITE_FIELD(this, kValueOffset, Smi::FromInt(0));
+  WRITE_FIELD(this, kValueOffsetDontForgetTheReadBarrier, Smi::FromInt(0));
 }
 
 
 void WeakCell::initialize(HeapObject* val) {
-  WRITE_FIELD(this, kValueOffset, val);
-  WRITE_BARRIER(GetHeap(), this, kValueOffset, val);
+  WRITE_FIELD(this, kValueOffsetDontForgetTheReadBarrier, val);
+  WRITE_BARRIER(GetHeap(), this, kValueOffsetDontForgetTheReadBarrier, val);
 }
 
 
-bool WeakCell::cleared() const { return value() == Smi::FromInt(0); }
+bool WeakCell::cleared() const {
+  Object* pointer = READ_FIELD(this, kValueOffsetDontForgetTheReadBarrier);
+  return pointer == Smi::FromInt(0);
+}
 
 
 Object* WeakCell::next() const { return READ_FIELD(this, kNextOffset); }
 
 
 void WeakCell::set_next(Object* val, WriteBarrierMode mode) {
   WRITE_FIELD(this, kNextOffset, val);
   if (mode == UPDATE_WRITE_BARRIER) {
     WRITE_BARRIER(GetHeap(), this, kNextOffset, val);
   }
@@ skipping 375 matching lines @@
 }
 
 
 void FixedDoubleArray::FillWithHoles(int from, int to) {
   for (int i = from; i < to; i++) {
     set_the_hole(i);
   }
 }
 
 
-Object* WeakFixedArray::Get(int index) const {
+Object* WeakFixedArray::Get(Heap* heap, int index) const {
   Object* raw = FixedArray::cast(this)->get(index + kFirstIndex);
   if (raw->IsSmi()) return raw;
-  return WeakCell::cast(raw)->value();
+  return WeakCell::cast(raw)->value(heap);
+}
+
+
+bool WeakFixedArray::EqualAt(int index, Object* object) const {
+  DCHECK(index < Length());
+  Object* raw = FixedArray::cast(this)->get(index + kFirstIndex);
+  if (raw->IsSmi()) return raw == object;
+  return WeakCell::cast(raw)->ValueNoReadBarrier() == object;
 }
 
 
 bool WeakFixedArray::IsEmptySlot(int index) const {
   DCHECK(index < Length());
-  return Get(index)->IsSmi();
+  Object* raw = FixedArray::cast(this)->get(index + kFirstIndex);
+  if (raw->IsSmi()) return true;
+  return WeakCell::cast(raw)->cleared();
 }
 
 
 void WeakFixedArray::clear(int index) {
   FixedArray::cast(this)->set(index + kFirstIndex, Smi::FromInt(0));
 }
 
 
 int WeakFixedArray::Length() const {
   return FixedArray::cast(this)->length() - kFirstIndex;
@@ skipping 5195 matching lines @@
 #undef ACCESSORS
 #undef ACCESSORS_TO_SMI
 #undef SMI_ACCESSORS
 #undef SYNCHRONIZED_SMI_ACCESSORS
 #undef NOBARRIER_SMI_ACCESSORS
 #undef BOOL_GETTER
 #undef BOOL_ACCESSORS
 #undef FIELD_ADDR
 #undef FIELD_ADDR_CONST
 #undef READ_FIELD
-#undef NOBARRIER_READ_FIELD
 #undef WRITE_FIELD
 #undef NOBARRIER_WRITE_FIELD
 #undef WRITE_BARRIER
 #undef CONDITIONAL_WRITE_BARRIER
 #undef READ_DOUBLE_FIELD
 #undef WRITE_DOUBLE_FIELD
 #undef READ_INT_FIELD
 #undef WRITE_INT_FIELD
 #undef READ_INTPTR_FIELD
 #undef WRITE_INTPTR_FIELD
 #undef READ_UINT32_FIELD
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 #undef NOBARRIER_READ_BYTE_FIELD
 #undef NOBARRIER_WRITE_BYTE_FIELD
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_