Make backing store for incremental marking deque non-static.

src/heap.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 #ifndef V8_HEAP_H_
 #define V8_HEAP_H_
 
 #include <math.h>
 
 #include "allocation.h"
 #include "globals.h"
 #include "incremental-marking.h"
 #include "list.h"
 #include "mark-compact.h"
+#include "objects-visiting.h"
 #include "spaces.h"
 #include "splay-tree-inl.h"
 #include "store-buffer.h"
 #include "v8-counters.h"
 #include "v8globals.h"
 
 namespace v8 {
 namespace internal {
 
 // TODO(isolates): remove HEAP here
@@ skipping 237 matching lines @@
 
  private:
   // The front of the queue is higher in memory than the rear.
   intptr_t* front_;
   intptr_t* rear_;
 
   DISALLOW_COPY_AND_ASSIGN(PromotionQueue);
 };
 
 
+typedef void (*ScavengingCallback)(Map* map,
+                                   HeapObject** slot,
+                                   HeapObject* object);
+
+
 // External strings table is a place where all external strings are
 // registered.  We need to keep track of such strings to properly
 // finalize them.
 class ExternalStringTable {
  public:
   // Registers an external string.
   inline void AddString(String* string);
 
   inline void Iterate(ObjectVisitor* v);
 
@@ skipping 1009 matching lines @@
     if (global_gc_prologue_callback_ != NULL) global_gc_prologue_callback_();
   }
 
   inline void CallGlobalGCEpilogueCallback() {
     if (global_gc_epilogue_callback_ != NULL) global_gc_epilogue_callback_();
   }
 
 
   inline bool OldGenerationAllocationLimitReached();
 
+  inline void DoScavengeObject(Map* map, HeapObject** slot, HeapObject* obj) {
+    scavenging_visitors_table_.GetVisitor(map)(map, slot, obj);
+  }
+
  private:
   Heap();
 
   // This can be calculated directly from a pointer to the heap; however, it is
   // more expedient to get at the isolate directly from within Heap methods.
   Isolate* isolate_;
 
   int reserved_semispace_size_;
   int max_semispace_size_;
   int initial_semispace_size_;
@@ skipping 194 matching lines @@
 
   void CreateFixedStubs();
 
   MaybeObject* CreateOddball(const char* to_string,
                              Object* to_number,
                              byte kind);
 
   // Allocate empty fixed array.
   MUST_USE_RESULT MaybeObject* AllocateEmptyFixedArray();
 
-  void SwitchScavengingVisitorsTableIfProfilingWasEnabled();
-
   // Performs a minor collection in new generation.
   void Scavenge();
 
   static String* UpdateNewSpaceReferenceInExternalStringTableEntry(
       Heap* heap,
       Object** pointer);
 
   Address DoScavenge(ObjectVisitor* scavenge_visitor, Address new_space_front);
   static void ScavengeStoreBufferCallback(Heap* heap,
                                           MemoryChunk* page,
@@ skipping 122 matching lines @@
 
   // Shared state read by the scavenge collector and set by ScavengeObject.
   PromotionQueue promotion_queue_;
 
   // Flag is set when the heap has been configured.  The heap can be repeatedly
   // configured through the API until it is setup.
   bool configured_;
 
   ExternalStringTable external_string_table_;
 
+  VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
+
   friend class Factory;
   friend class GCTracer;
   friend class DisallowAllocationFailure;
   friend class AlwaysAllocateScope;
   friend class LinearAllocationScope;
   friend class Page;
   friend class Isolate;
   friend class MarkCompactCollector;
   friend class MapCompact;
 
@@ skipping 654 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #undef HEAP
 
 #endif  // V8_HEAP_H_