Just visit young array buffers during scavenge.

src/heap/heap.cc

 // 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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 88 matching lines @@
       ms_count_(0),
       gc_count_(0),
       remembered_unmapped_pages_index_(0),
       unflattened_strings_length_(0),
 #ifdef DEBUG
       allocation_timeout_(0),
 #endif  // DEBUG
       old_generation_allocation_limit_(initial_old_generation_size_),
       old_gen_exhausted_(false),
       inline_allocation_disabled_(false),
+      last_array_buffers_young_object_(NULL),
+      last_native_contexts_young_object_(NULL),
       store_buffer_rebuilder_(store_buffer()),
       hidden_string_(NULL),
       gc_safe_size_of_old_object_(NULL),
       total_regexp_code_generated_(0),
       tracer_(this),
       high_survival_rate_period_length_(0),
       promoted_objects_size_(0),
       promotion_ratio_(0),
       semi_space_copied_object_size_(0),
       previous_semi_space_copied_object_size_(0),
@@ skipping 1564 matching lines @@
     Object** start = &external_string_table_.old_space_strings_[0];
     Object** end = start + external_string_table_.old_space_strings_.length();
     for (Object** p = start; p < end; ++p) *p = updater_func(this, p);
   }
 
   UpdateNewSpaceReferencesInExternalStringTable(updater_func);
 }
 
 
 void Heap::ProcessAllWeakReferences(WeakObjectRetainer* retainer) {
-  ProcessArrayBuffers(retainer);
-  ProcessNativeContexts(retainer);
+  ProcessArrayBuffers(retainer, NULL);
+  ProcessNativeContexts(retainer, NULL);
   ProcessAllocationSites(retainer);
 }
 
 
 void Heap::ProcessYoungWeakReferences(WeakObjectRetainer* retainer) {
-  ProcessArrayBuffers(retainer);
-  ProcessNativeContexts(retainer);
+  ProcessArrayBuffers(retainer, last_array_buffers_young_object_);
+  ProcessNativeContexts(retainer, last_native_contexts_young_object_);
 }
 
 
-void Heap::ProcessNativeContexts(WeakObjectRetainer* retainer) {
-  Object* head = VisitWeakList<Context>(this, native_contexts_list(), retainer);
+void Heap::ProcessNativeContexts(WeakObjectRetainer* retainer,
+                                 Object* last_native_contexts_young_object) {
+  Object* last_young_object_recorded = NULL;
+  Object* head = VisitWeakList<Context>(this, native_contexts_list(), retainer,
+                                        last_native_contexts_young_object,
+                                        &last_young_object_recorded);

[ulan, 2015/02/03 11:15:21]

It just occurred to me that this won't work because of weak list hanging off the
native contexts (list of optimized functions for example). We need to process
all of them even if they are in old space because optimized functions can in new
space.

   // Update the head of the list of contexts.
   set_native_contexts_list(head);
+  last_native_contexts_young_object_ = last_young_object_recorded;
 }
 
 
-void Heap::ProcessArrayBuffers(WeakObjectRetainer* retainer) {
-  Object* array_buffer_obj =
-      VisitWeakList<JSArrayBuffer>(this, array_buffers_list(), retainer);
+void Heap::ProcessArrayBuffers(WeakObjectRetainer* retainer,
+                               Object* last_array_buffers_young_object) {
+  Object* last_young_object_recorded = NULL;
+  Object* array_buffer_obj = VisitWeakList<JSArrayBuffer>(
+      this, array_buffers_list(), retainer, last_array_buffers_young_object,
+      &last_young_object_recorded);
   set_array_buffers_list(array_buffer_obj);
+  last_array_buffers_young_object_ = last_young_object_recorded;
 }
 
 
 void Heap::TearDownArrayBuffers() {
   Object* undefined = undefined_value();
   for (Object* o = array_buffers_list(); o != undefined;) {
     JSArrayBuffer* buffer = JSArrayBuffer::cast(o);
     Runtime::FreeArrayBuffer(isolate(), buffer);
     o = buffer->weak_next();
   }
   set_array_buffers_list(undefined);
 }
 
 
 void Heap::ProcessAllocationSites(WeakObjectRetainer* retainer) {
-  Object* allocation_site_obj =
-      VisitWeakList<AllocationSite>(this, allocation_sites_list(), retainer);
+  Object* allocation_site_obj = VisitWeakList<AllocationSite>(
+      this, allocation_sites_list(), retainer, NULL, NULL);
   set_allocation_sites_list(allocation_site_obj);
 }
 
 
 void Heap::ResetAllAllocationSitesDependentCode(PretenureFlag flag) {
   DisallowHeapAllocation no_allocation_scope;
   Object* cur = allocation_sites_list();
   bool marked = false;
   while (cur->IsAllocationSite()) {
     AllocationSite* casted = AllocationSite::cast(cur);
@@ skipping 4707 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal