Treat links that organize weak objects weakly.

src/heap/objects-visiting.cc

 // Copyright 2011 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 "src/v8.h"
 
 #include "src/heap/objects-visiting.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 235 matching lines @@
     T* candidate = reinterpret_cast<T*>(list);
     list = WeakListVisitor<T>::WeakNext(candidate);
     WeakListVisitor<T>::SetWeakNext(candidate, undefined);
   }
 }
 
 
 template <>
 struct WeakListVisitor<JSFunction> {
   static void SetWeakNext(JSFunction* function, Object* next) {
-    function->set_next_function_link(next);
+    function->set_next_function_link(next, UPDATE_WEAK_WRITE_BARRIER);
   }
 
   static Object* WeakNext(JSFunction* function) {
     return function->next_function_link();
   }
 
   static int WeakNextOffset() { return JSFunction::kNextFunctionLinkOffset; }
 
   static void VisitLiveObject(Heap*, JSFunction*, WeakObjectRetainer*) {}
 
   static void VisitPhantomObject(Heap*, JSFunction*) {}
 };
 
 
 template <>
 struct WeakListVisitor<Code> {
   static void SetWeakNext(Code* code, Object* next) {
-    code->set_next_code_link(next);
+    code->set_next_code_link(next, UPDATE_WEAK_WRITE_BARRIER);
   }
 
   static Object* WeakNext(Code* code) { return code->next_code_link(); }
 
   static int WeakNextOffset() { return Code::kNextCodeLinkOffset; }
 
   static void VisitLiveObject(Heap*, Code*, WeakObjectRetainer*) {}
 
   static void VisitPhantomObject(Heap*, Code*) {}
 };
@@ skipping 50 matching lines @@
                               context->get(Context::OPTIMIZED_FUNCTIONS_LIST));
     ClearWeakList<Code>(heap, context->get(Context::OPTIMIZED_CODE_LIST));
     ClearWeakList<Code>(heap, context->get(Context::DEOPTIMIZED_CODE_LIST));
   }
 };
 
 
 template <>
 struct WeakListVisitor<AllocationSite> {
   static void SetWeakNext(AllocationSite* obj, Object* next) {
-    obj->set_weak_next(next);
+    obj->set_weak_next(next, UPDATE_WEAK_WRITE_BARRIER);
   }
 
   static Object* WeakNext(AllocationSite* obj) { return obj->weak_next(); }
 
   static int WeakNextOffset() { return AllocationSite::kWeakNextOffset; }
 
   static void VisitLiveObject(Heap*, AllocationSite*, WeakObjectRetainer*) {}
 
   static void VisitPhantomObject(Heap*, AllocationSite*) {}
 };
 
 
 template Object* VisitWeakList<Context>(Heap* heap, Object* list,
                                         WeakObjectRetainer* retainer);
 
 template Object* VisitWeakList<AllocationSite>(Heap* heap, Object* list,
                                                WeakObjectRetainer* retainer);
 }
 }  // namespace v8::internal