Add map-based read barrier to WeakCell

src/objects.cc

 // Copyright 2013 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 <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/allocation-site-scopes.h"
@@ skipping 1384 matching lines @@
       HeapStringAllocator allocator;
       StringStream accumulator(&allocator);
       PropertyCell::cast(this)->value()->ShortPrint(&accumulator);
       os << accumulator.ToCString().get();
       break;
     }
     case WEAK_CELL_TYPE: {
       os << "WeakCell for ";
       HeapStringAllocator allocator;
       StringStream accumulator(&allocator);
-      WeakCell::cast(this)->value()->ShortPrint(&accumulator);
+      WeakCell::cast(this)->value(heap)->ShortPrint(&accumulator);
       os << accumulator.ToCString().get();
       break;
     }
     default:
       os << "<Other heap object (" << map()->instance_type() << ")>";
       break;
   }
 }
 
 
@@ skipping 6624 matching lines @@
 Handle<WeakFixedArray> WeakFixedArray::Add(
     Handle<Object> maybe_array, Handle<HeapObject> value,
     SearchForDuplicates search_for_duplicates) {
   Handle<WeakFixedArray> array =
       (maybe_array.is_null() || !maybe_array->IsWeakFixedArray())
           ? Allocate(value->GetIsolate(), 1, Handle<WeakFixedArray>::null())
           : Handle<WeakFixedArray>::cast(maybe_array);
 
   if (search_for_duplicates == kAddIfNotFound) {
     for (int i = 0; i < array->Length(); ++i) {
-      if (array->Get(i) == *value) return array;
+      if (array->EqualAt(i, *value)) return array;
     }
   } else {
 #ifdef DEBUG
     for (int i = 0; i < array->Length(); ++i) {
-      DCHECK_NE(*value, array->Get(i));
+      DCHECK(!array->EqualAt(i, *value));
     }
 #endif
   }
 
   // Try to store the new entry if there's room. Optimize for consecutive
   // accesses.
   int first_index = array->last_used_index();
   for (int i = first_index;;) {
     if (array->IsEmptySlot((i))) {
       WeakFixedArray::Set(array, i, value);
@@ skipping 15 matching lines @@
   }
   WeakFixedArray::Set(new_array, array->Length(), value);
   return new_array;
 }
 
 
 void WeakFixedArray::Remove(Handle<HeapObject> value) {
   // Optimize for the most recently added element to be removed again.
   int first_index = last_used_index();
   for (int i = first_index;;) {
-    if (Get(i) == *value) {
+    if (EqualAt(i, *value)) {
       clear(i);
       // Users of WeakFixedArray should make sure that there are no duplicates,
       // they can use Add(..., kAddIfNotFound) if necessary.
       return;
     }
     i = (i + 1) % Length();
     if (i == first_index) break;
   }
 }
 
@@ skipping 2043 matching lines @@
   return result;
 }
 
 
 Handle<JSObject> Script::GetWrapper(Handle<Script> script) {
   Isolate* isolate = script->GetIsolate();
   if (!script->wrapper()->IsUndefined()) {
     Handle<WeakCell> cell(WeakCell::cast(script->wrapper()));
     if (!cell->cleared()) {
       // Return a handle for the existing script wrapper from the cache.
-      return handle(JSObject::cast(cell->value()));
+      return handle(JSObject::cast(cell->value(isolate->heap())));
     }
     // If we found an empty WeakCell, that means the script wrapper was
     // GCed.  We are not notified directly of that, so we decrement here
     // so that we at least don't count double for any given script.
     isolate->counters()->script_wrappers()->Decrement();
   }
   // Construct a new script wrapper.
   isolate->counters()->script_wrappers()->Increment();
   Handle<JSFunction> constructor = isolate->script_function();
   Handle<JSValue> result =
@@ skipping 482 matching lines @@
 }
 
 
 Object* Code::FindNthObject(int n, Map* match_map) {
   DCHECK(is_inline_cache_stub());
   DisallowHeapAllocation no_allocation;
   int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   for (RelocIterator it(this, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     Object* object = info->target_object();
-    if (object->IsWeakCell()) object = WeakCell::cast(object)->value();
+    Object* original_object = object;
+    if (object->IsWeakCell())
+      object = WeakCell::cast(object)->ValueNoReadBarrier();
     if (object->IsHeapObject()) {
       if (HeapObject::cast(object)->map() == match_map) {
-        if (--n == 0) return object;
+        if (--n == 0) {
+          WeakCell::TriggerReadBarrier(original_object);
+          return object;
+        }
       }
     }
   }
   return NULL;
 }
 
 
 AllocationSite* Code::FindFirstAllocationSite() {
   Object* result = FindNthObject(1, GetHeap()->allocation_site_map());
   return (result != NULL) ? AllocationSite::cast(result) : NULL;
 }
 
 
 Map* Code::FindFirstMap() {
   Object* result = FindNthObject(1, GetHeap()->meta_map());
-  return (result != NULL) ? Map::cast(result) : NULL;
+  if (result == NULL) return NULL;
+  Map* map = Map::cast(result);
+  if (map->instance_type() == WEAK_CELL_TYPE) {
+    // There may be reloc info with weak cell maps. These are just in use by
+    // the read barrier and are not useful to harvest for the type feedback.
+    map = reinterpret_cast<Map*>(FindNthObject(2, GetHeap()->meta_map()));
+  }
+  return map;
 }
 
 
 void Code::FindAndReplace(const FindAndReplacePattern& pattern) {
   DCHECK(is_inline_cache_stub() || is_handler());
   DisallowHeapAllocation no_allocation;
   int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   STATIC_ASSERT(FindAndReplacePattern::kMaxCount < 32);
   int current_pattern = 0;
   for (RelocIterator it(this, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     Object* object = info->target_object();
+    Object* original_object = object;
+    if (object->IsWeakCell())
+      object = WeakCell::cast(object)->ValueNoReadBarrier();
     if (object->IsHeapObject()) {
-      if (object->IsWeakCell()) {
-        object = HeapObject::cast(WeakCell::cast(object)->value());
-      }
       Map* map = HeapObject::cast(object)->map();
       if (map == *pattern.find_[current_pattern]) {
+        WeakCell::TriggerReadBarrier(original_object);
         info->set_target_object(*pattern.replace_[current_pattern]);
         if (++current_pattern == pattern.count_) return;
       }
     }
   }
   UNREACHABLE();
 }
 
 
 void Code::FindAllMaps(MapHandleList* maps) {
   DCHECK(is_inline_cache_stub());
   DisallowHeapAllocation no_allocation;
   int mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   for (RelocIterator it(this, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     Object* object = info->target_object();
-    if (object->IsWeakCell()) object = WeakCell::cast(object)->value();
-    if (object->IsMap()) maps->Add(handle(Map::cast(object)));
+    Object* original_object = object;
+    if (object->IsWeakCell())
+      object = WeakCell::cast(object)->ValueNoReadBarrier();
+    if (object->IsMap()) {
+      Map* map = Map::cast(object);
+      // This 'if' filters out the weak cell map used by the read barrier.
+      if (map->instance_type() != WEAK_CELL_TYPE) {
+        WeakCell::TriggerReadBarrier(original_object);
+        maps->Add(handle(map));
+      }
+    }
   }
 }
 
 
 Code* Code::FindFirstHandler() {
   DCHECK(is_inline_cache_stub());
   DisallowHeapAllocation no_allocation;
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
              RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   bool skip_next_handler = false;
@@ skipping 45 matching lines @@
 
 MaybeHandle<Code> Code::FindHandlerForMap(Map* map) {
   DCHECK(is_inline_cache_stub());
   int mask = RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
              RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   bool return_next = false;
   for (RelocIterator it(this, mask); !it.done(); it.next()) {
     RelocInfo* info = it.rinfo();
     if (info->rmode() == RelocInfo::EMBEDDED_OBJECT) {
       Object* object = info->target_object();
-      if (object->IsWeakCell()) object = WeakCell::cast(object)->value();
-      if (object == map) return_next = true;
+      Object* original_object = object;
+      if (object->IsWeakCell())
+        object = WeakCell::cast(object)->ValueNoReadBarrier();
+      if (object == map) {
+        WeakCell::TriggerReadBarrier(original_object);
+        return_next = true;
+      }
     } else if (return_next) {
       Code* code = Code::GetCodeFromTargetAddress(info->target_address());
       DCHECK(code->kind() == Code::HANDLER);
       return handle(code);
     }
   }
   return MaybeHandle<Code>();
 }
 
 
@@ skipping 279 matching lines @@
       ->SetWeakCellCache(*cell);
   return cell;
 }
 
 
 WeakCell* Code::CachedWeakCell() {
   DCHECK(kind() == OPTIMIZED_FUNCTION);
   Object* weak_cell_cache =
       DeoptimizationInputData::cast(deoptimization_data())->WeakCellCache();
   if (weak_cell_cache->IsWeakCell()) {
-    DCHECK(this == WeakCell::cast(weak_cell_cache)->value());
+    DCHECK(this == WeakCell::cast(weak_cell_cache)->ValueNoReadBarrier());
     return WeakCell::cast(weak_cell_cache);
   }
   return NULL;
 }
 
 
 #ifdef ENABLE_DISASSEMBLER
 
 void DeoptimizationInputData::DeoptimizationInputDataPrint(
     std::ostream& os) {  // NOLINT
@@ skipping 5790 matching lines @@
   Handle<DependentCode> codes =
       DependentCode::Insert(handle(cell->dependent_code(), info->isolate()),
                             DependentCode::kPropertyCellChangedGroup,
                             info->object_wrapper());
   if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
   info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
       cell, info->zone());
 }
 
 } }  // namespace v8::internal