Implement IdentityMap<V>, a robust, GC-safe object-identity HashMap.

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 123 matching lines @@
       full_codegen_bytes_generated_(0),
       crankshaft_codegen_bytes_generated_(0),
       gcs_since_last_deopt_(0),
       allocation_sites_scratchpad_length_(0),
       promotion_queue_(this),
       configured_(false),
       external_string_table_(this),
       chunks_queued_for_free_(NULL),
       gc_callbacks_depth_(0),
       deserialization_complete_(false),
-      concurrent_sweeping_enabled_(false) {
+      concurrent_sweeping_enabled_(false),
+      strong_roots_list_(NULL) {
 // Allow build-time customization of the max semispace size. Building
 // V8 with snapshots and a non-default max semispace size is much
 // easier if you can define it as part of the build environment.
 #if defined(V8_MAX_SEMISPACE_SIZE)
   max_semi_space_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif
 
   // Ensure old_generation_size_ is a multiple of kPageSize.
   DCHECK(MB >= Page::kPageSize);
 
@@ skipping 4837 matching lines @@
   // During deserialization of the startup snapshot this creates the partial
   // snapshot cache and deserializes the objects it refers to.  During
   // serialization this does nothing, since the partial snapshot cache is
   // empty.  However the next thing we do is create the partial snapshot,
   // filling up the partial snapshot cache with objects it needs as we go.
   SerializerDeserializer::Iterate(isolate_, v);
   // We don't do a v->Synchronize call here, because in debug mode that will
   // output a flag to the snapshot.  However at this point the serializer and
   // deserializer are deliberately a little unsynchronized (see above) so the
   // checking of the sync flag in the snapshot would fail.
+  for (StrongRootsList* list = strong_roots_list_; list; list = list->next_) {

[Erik Corry, 2015/04/27 15:39:13]

It looks like this stuff should be before the serializer/deserializer iteration
and should have its own call to v->Synchronize

[titzer, 2015/05/06 09:40:36]

Done.

+    v->VisitPointers(list->start_, list->end_);
+  }
 }
 
 
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semi_space_size, int max_old_space_size,
                          int max_executable_size, size_t code_range_size) {
   if (HasBeenSetUp()) return false;
 
@@ skipping 470 matching lines @@
 
   if (lo_space_ != NULL) {
     lo_space_->TearDown();
     delete lo_space_;
     lo_space_ = NULL;
   }
 
   store_buffer()->TearDown();
 
   isolate_->memory_allocator()->TearDown();
+
+  StrongRootsList* next = NULL;
+  for (StrongRootsList* list = strong_roots_list_; list; list = next) {
+    next = list->next_;
+    delete list;
+  }
+  strong_roots_list_ = NULL;
 }
 
 
 void Heap::AddGCPrologueCallback(v8::Isolate::GCPrologueCallback callback,
                                  GCType gc_type, bool pass_isolate) {
   DCHECK(callback != NULL);
   GCPrologueCallbackPair pair(callback, gc_type, pass_isolate);
   DCHECK(!gc_prologue_callbacks_.Contains(pair));
   return gc_prologue_callbacks_.Add(pair);
 }
@@ skipping 879 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