Downgrade V8 to 3.1.8.25

There are serious performance regressions both in V8 and our own legacy
networking stack. Until we correct our own problems we are going back to the
old V8.

1 files changed, 80 insertions, 157 deletions

diff --git a/deps/v8/src/mark-compact.h b/deps/v8/src/mark-compact.h
index 179edba74..1b7e60022 100644
--- a/deps/v8/src/mark-compact.h
+++ b/deps/v8/src/mark-compact.h
@@ -28,8 +28,6 @@
 #ifndef V8_MARK_COMPACT_H_
 #define V8_MARK_COMPACT_H_
 
-#include "spaces.h"
-
 namespace v8 {
 namespace internal {
 
@@ -39,77 +37,23 @@ namespace internal {
 typedef bool (*IsAliveFunction)(HeapObject* obj, int* size, int* offset);
 
 // Forward declarations.
-class CodeFlusher;
-class GCTracer;
-class MarkingVisitor;
 class RootMarkingVisitor;
-
-
-// ----------------------------------------------------------------------------
-// Marking stack for tracing live objects.
-
-class MarkingStack {
- public:
-  MarkingStack() : low_(NULL), top_(NULL), high_(NULL), overflowed_(false) { }
-
-  void Initialize(Address low, Address high) {
-    top_ = low_ = reinterpret_cast<HeapObject**>(low);
-    high_ = reinterpret_cast<HeapObject**>(high);
-    overflowed_ = false;
-  }
-
-  bool is_full() const { return top_ >= high_; }
-
-  bool is_empty() const { return top_ <= low_; }
-
-  bool overflowed() const { return overflowed_; }
-
-  void clear_overflowed() { overflowed_ = false; }
-
-  // Push the (marked) object on the marking stack if there is room,
-  // otherwise mark the object as overflowed and wait for a rescan of the
-  // heap.
-  void Push(HeapObject* object) {
-    CHECK(object->IsHeapObject());
-    if (is_full()) {
-      object->SetOverflow();
-      overflowed_ = true;
-    } else {
-      *(top_++) = object;
-    }
-  }
-
-  HeapObject* Pop() {
-    ASSERT(!is_empty());
-    HeapObject* object = *(--top_);
-    CHECK(object->IsHeapObject());
-    return object;
-  }
-
- private:
-  HeapObject** low_;
-  HeapObject** top_;
-  HeapObject** high_;
-  bool overflowed_;
-
-  DISALLOW_COPY_AND_ASSIGN(MarkingStack);
-};
+class MarkingVisitor;
 
 
 // -------------------------------------------------------------------------
 // Mark-Compact collector
+//
+// All methods are static.
 
-class OverflowedObjectsScanner;
-
-class MarkCompactCollector {
+class MarkCompactCollector: public AllStatic {
  public:
   // Type of functions to compute forwarding addresses of objects in
   // compacted spaces.  Given an object and its size, return a (non-failure)
   // Object* that will be the object after forwarding.  There is a separate
   // allocation function for each (compactable) space based on the location
   // of the object before compaction.
-  typedef MaybeObject* (*AllocationFunction)(Heap* heap,
-                                             HeapObject* object,
+  typedef MaybeObject* (*AllocationFunction)(HeapObject* object,
                                              int object_size);
 
   // Type of functions to encode the forwarding address for an object.
@@ -120,21 +64,17 @@ class MarkCompactCollector {
   // page as input, and is updated to contain the offset to be used for the
   // next live object in the same page.  For spaces using a different
   // encoding (ie, contiguous spaces), the offset parameter is ignored.
-  typedef void (*EncodingFunction)(Heap* heap,
-                                   HeapObject* old_object,
+  typedef void (*EncodingFunction)(HeapObject* old_object,
                                    int object_size,
                                    Object* new_object,
                                    int* offset);
 
   // Type of functions to process non-live objects.
-  typedef void (*ProcessNonLiveFunction)(HeapObject* object, Isolate* isolate);
-
-  // Pointer to member function, used in IterateLiveObjects.
-  typedef int (MarkCompactCollector::*LiveObjectCallback)(HeapObject* obj);
+  typedef void (*ProcessNonLiveFunction)(HeapObject* object);
 
   // Set the global force_compaction flag, it must be called before Prepare
   // to take effect.
-  void SetForceCompaction(bool value) {
+  static void SetForceCompaction(bool value) {
     force_compaction_ = value;
   }
 
@@ -143,16 +83,16 @@ class MarkCompactCollector {
 
   // Prepares for GC by resetting relocation info in old and map spaces and
   // choosing spaces to compact.
-  void Prepare(GCTracer* tracer);
+  static void Prepare(GCTracer* tracer);
 
   // Performs a global garbage collection.
-  void CollectGarbage();
+  static void CollectGarbage();
 
   // True if the last full GC performed heap compaction.
-  bool HasCompacted() { return compacting_collection_; }
+  static bool HasCompacted() { return compacting_collection_; }
 
   // True after the Prepare phase if the compaction is taking place.
-  bool IsCompacting() {
+  static bool IsCompacting() {
 #ifdef DEBUG
     // For the purposes of asserts we don't want this to keep returning true
     // after the collection is completed.
@@ -164,20 +104,20 @@ class MarkCompactCollector {
 
   // The count of the number of objects left marked at the end of the last
   // completed full GC (expected to be zero).
-  int previous_marked_count() { return previous_marked_count_; }
+  static int previous_marked_count() { return previous_marked_count_; }
 
   // During a full GC, there is a stack-allocated GCTracer that is used for
   // bookkeeping information.  Return a pointer to that tracer.
-  GCTracer* tracer() { return tracer_; }
+  static GCTracer* tracer() { return tracer_; }
 
 #ifdef DEBUG
   // Checks whether performing mark-compact collection.
-  bool in_use() { return state_ > PREPARE_GC; }
-  bool are_map_pointers_encoded() { return state_ == UPDATE_POINTERS; }
+  static bool in_use() { return state_ > PREPARE_GC; }
+  static bool are_map_pointers_encoded() { return state_ == UPDATE_POINTERS; }
 #endif
 
   // Determine type of object and emit deletion log event.
-  static void ReportDeleteIfNeeded(HeapObject* obj, Isolate* isolate);
+  static void ReportDeleteIfNeeded(HeapObject* obj);
 
   // Returns size of a possibly marked object.
   static int SizeOfMarkedObject(HeapObject* obj);
@@ -187,16 +127,7 @@ class MarkCompactCollector {
   static const uint32_t kSingleFreeEncoding = 0;
   static const uint32_t kMultiFreeEncoding = 1;
 
-  inline Heap* heap() const { return heap_; }
-
-  CodeFlusher* code_flusher() { return code_flusher_; }
-  inline bool is_code_flushing_enabled() const { return code_flusher_ != NULL; }
-  void EnableCodeFlushing(bool enable);
-
  private:
-  MarkCompactCollector();
-  ~MarkCompactCollector();
-
 #ifdef DEBUG
   enum CollectorState {
     IDLE,
@@ -209,28 +140,28 @@ class MarkCompactCollector {
   };
 
   // The current stage of the collector.
-  CollectorState state_;
+  static CollectorState state_;
 #endif
 
   // Global flag that forces a compaction.
-  bool force_compaction_;
+  static bool force_compaction_;
 
   // Global flag indicating whether spaces were compacted on the last GC.
-  bool compacting_collection_;
+  static bool compacting_collection_;
 
   // Global flag indicating whether spaces will be compacted on the next GC.
-  bool compact_on_next_gc_;
+  static bool compact_on_next_gc_;
 
   // The number of objects left marked at the end of the last completed full
   // GC (expected to be zero).
-  int previous_marked_count_;
+  static int previous_marked_count_;
 
   // A pointer to the current stack-allocated GC tracer object during a full
   // collection (NULL before and after).
-  GCTracer* tracer_;
+  static GCTracer* tracer_;
 
   // Finishes GC, performs heap verification if enabled.
-  void Finish();
+  static void Finish();
 
   // -----------------------------------------------------------------------
   // Phase 1: Marking live objects.
@@ -248,86 +179,85 @@ class MarkCompactCollector {
   friend class CodeMarkingVisitor;
   friend class SharedFunctionInfoMarkingVisitor;
 
-  void PrepareForCodeFlushing();
+  static void PrepareForCodeFlushing();
 
   // Marking operations for objects reachable from roots.
-  void MarkLiveObjects();
+  static void MarkLiveObjects();
 
-  void MarkUnmarkedObject(HeapObject* obj);
+  static void MarkUnmarkedObject(HeapObject* obj);
 
-  inline void MarkObject(HeapObject* obj) {
+  static inline void MarkObject(HeapObject* obj) {
     if (!obj->IsMarked()) MarkUnmarkedObject(obj);
   }
 
-  inline void SetMark(HeapObject* obj);
+  static inline void SetMark(HeapObject* obj) {
+    tracer_->increment_marked_count();
+#ifdef DEBUG
+    UpdateLiveObjectCount(obj);
+#endif
+    obj->SetMark();
+  }
 
   // Creates back pointers for all map transitions, stores them in
   // the prototype field.  The original prototype pointers are restored
   // in ClearNonLiveTransitions().  All JSObject maps
   // connected by map transitions have the same prototype object, which
   // is why we can use this field temporarily for back pointers.
-  void CreateBackPointers();
+  static void CreateBackPointers();
 
   // Mark a Map and its DescriptorArray together, skipping transitions.
-  void MarkMapContents(Map* map);
-  void MarkDescriptorArray(DescriptorArray* descriptors);
+  static void MarkMapContents(Map* map);
+  static void MarkDescriptorArray(DescriptorArray* descriptors);
 
   // Mark the heap roots and all objects reachable from them.
-  void MarkRoots(RootMarkingVisitor* visitor);
+  static void MarkRoots(RootMarkingVisitor* visitor);
 
   // Mark the symbol table specially.  References to symbols from the
   // symbol table are weak.
-  void MarkSymbolTable();
+  static void MarkSymbolTable();
 
   // Mark objects in object groups that have at least one object in the
   // group marked.
-  void MarkObjectGroups();
+  static void MarkObjectGroups();
 
-  // Mark objects in implicit references groups if their parent object
-  // is marked.
-  void MarkImplicitRefGroups();
-
-  // Mark all objects which are reachable due to host application
-  // logic like object groups or implicit references' groups.
-  void ProcessExternalMarking();
+  // Mark all objects in an object group with at least one marked
+  // object, then all objects reachable from marked objects in object
+  // groups, and repeat.
+  static void ProcessObjectGroups();
 
   // Mark objects reachable (transitively) from objects in the marking stack
   // or overflowed in the heap.
-  void ProcessMarkingStack();
+  static void ProcessMarkingStack();
 
   // Mark objects reachable (transitively) from objects in the marking
   // stack.  This function empties the marking stack, but may leave
   // overflowed objects in the heap, in which case the marking stack's
   // overflow flag will be set.
-  void EmptyMarkingStack();
+  static void EmptyMarkingStack();
 
   // Refill the marking stack with overflowed objects from the heap.  This
   // function either leaves the marking stack full or clears the overflow
   // flag on the marking stack.
-  void RefillMarkingStack();
-
-  // After reachable maps have been marked process per context object
-  // literal map caches removing unmarked entries.
-  void ProcessMapCaches();
+  static void RefillMarkingStack();
 
   // Callback function for telling whether the object *p is an unmarked
   // heap object.
   static bool IsUnmarkedHeapObject(Object** p);
 
 #ifdef DEBUG
-  void UpdateLiveObjectCount(HeapObject* obj);
+  static void UpdateLiveObjectCount(HeapObject* obj);
 #endif
 
   // We sweep the large object space in the same way whether we are
   // compacting or not, because the large object space is never compacted.
-  void SweepLargeObjectSpace();
+  static void SweepLargeObjectSpace();
 
   // Test whether a (possibly marked) object is a Map.
   static inline bool SafeIsMap(HeapObject* object);
 
   // Map transitions from a live map to a dead map must be killed.
   // We replace them with a null descriptor, with the same key.
-  void ClearNonLiveTransitions();
+  static void ClearNonLiveTransitions();
 
   // -----------------------------------------------------------------------
   // Phase 2: Sweeping to clear mark bits and free non-live objects for
@@ -372,32 +302,32 @@ class MarkCompactCollector {
 
   // Encodes forwarding addresses of objects in compactable parts of the
   // heap.
-  void EncodeForwardingAddresses();
+  static void EncodeForwardingAddresses();
 
   // Encodes the forwarding addresses of objects in new space.
-  void EncodeForwardingAddressesInNewSpace();
+  static void EncodeForwardingAddressesInNewSpace();
 
   // Function template to encode the forwarding addresses of objects in
   // paged spaces, parameterized by allocation and non-live processing
   // functions.
   template<AllocationFunction Alloc, ProcessNonLiveFunction ProcessNonLive>
-  void EncodeForwardingAddressesInPagedSpace(PagedSpace* space);
+  static void EncodeForwardingAddressesInPagedSpace(PagedSpace* space);
 
   // Iterates live objects in a space, passes live objects
   // to a callback function which returns the heap size of the object.
   // Returns the number of live objects iterated.
-  int IterateLiveObjects(NewSpace* space, LiveObjectCallback size_f);
-  int IterateLiveObjects(PagedSpace* space, LiveObjectCallback size_f);
+  static int IterateLiveObjects(NewSpace* space, HeapObjectCallback size_f);
+  static int IterateLiveObjects(PagedSpace* space, HeapObjectCallback size_f);
 
   // Iterates the live objects between a range of addresses, returning the
   // number of live objects.
-  int IterateLiveObjectsInRange(Address start, Address end,
-                                LiveObjectCallback size_func);
+  static int IterateLiveObjectsInRange(Address start, Address end,
+                                       HeapObjectCallback size_func);
 
   // If we are not compacting the heap, we simply sweep the spaces except
   // for the large object space, clearing mark bits and adding unmarked
   // regions to each space's free list.
-  void SweepSpaces();
+  static void SweepSpaces();
 
   // -----------------------------------------------------------------------
   // Phase 3: Updating pointers in live objects.
@@ -411,15 +341,15 @@ class MarkCompactCollector {
   friend class UpdatingVisitor;  // helper for updating visited objects
 
   // Updates pointers in all spaces.
-  void UpdatePointers();
+  static void UpdatePointers();
 
   // Updates pointers in an object in new space.
   // Returns the heap size of the object.
-  int UpdatePointersInNewObject(HeapObject* obj);
+  static int UpdatePointersInNewObject(HeapObject* obj);
 
   // Updates pointers in an object in old spaces.
   // Returns the heap size of the object.
-  int UpdatePointersInOldObject(HeapObject* obj);
+  static int UpdatePointersInOldObject(HeapObject* obj);
 
   // Calculates the forwarding address of an object in an old space.
   static Address GetForwardingAddressInOldSpace(HeapObject* obj);
@@ -433,31 +363,31 @@ class MarkCompactCollector {
   //   After: Objects have been moved to their new addresses.
 
   // Relocates objects in all spaces.
-  void RelocateObjects();
+  static void RelocateObjects();
 
   // Converts a code object's inline target to addresses, convention from
   // address to target happens in the marking phase.
-  int ConvertCodeICTargetToAddress(HeapObject* obj);
+  static int ConvertCodeICTargetToAddress(HeapObject* obj);
 
   // Relocate a map object.
-  int RelocateMapObject(HeapObject* obj);
+  static int RelocateMapObject(HeapObject* obj);
 
   // Relocates an old object.
-  int RelocateOldPointerObject(HeapObject* obj);
-  int RelocateOldDataObject(HeapObject* obj);
+  static int RelocateOldPointerObject(HeapObject* obj);
+  static int RelocateOldDataObject(HeapObject* obj);
 
   // Relocate a property cell object.
-  int RelocateCellObject(HeapObject* obj);
+  static int RelocateCellObject(HeapObject* obj);
 
   // Helper function.
-  inline int RelocateOldNonCodeObject(HeapObject* obj,
-                                      PagedSpace* space);
+  static inline int RelocateOldNonCodeObject(HeapObject* obj,
+                                             PagedSpace* space);
 
   // Relocates an object in the code space.
-  int RelocateCodeObject(HeapObject* obj);
+  static int RelocateCodeObject(HeapObject* obj);
 
   // Copy a new object.
-  int RelocateNewObject(HeapObject* obj);
+  static int RelocateNewObject(HeapObject* obj);
 
 #ifdef DEBUG
   // -----------------------------------------------------------------------
@@ -466,28 +396,28 @@ class MarkCompactCollector {
   // mark-sweep collection.
 
   // Size of live objects in Heap::to_space_.
-  int live_young_objects_size_;
+  static int live_young_objects_size_;
 
   // Size of live objects in Heap::old_pointer_space_.
-  int live_old_pointer_objects_size_;
+  static int live_old_pointer_objects_size_;
 
   // Size of live objects in Heap::old_data_space_.
-  int live_old_data_objects_size_;
+  static int live_old_data_objects_size_;
 
   // Size of live objects in Heap::code_space_.
-  int live_code_objects_size_;
+  static int live_code_objects_size_;
 
   // Size of live objects in Heap::map_space_.
-  int live_map_objects_size_;
+  static int live_map_objects_size_;
 
   // Size of live objects in Heap::cell_space_.
-  int live_cell_objects_size_;
+  static int live_cell_objects_size_;
 
   // Size of live objects in Heap::lo_space_.
-  int live_lo_objects_size_;
+  static int live_lo_objects_size_;
 
   // Number of live bytes in this collection.
-  int live_bytes_;
+  static int live_bytes_;
 
   friend class MarkObjectVisitor;
   static void VisitObject(HeapObject* obj);
@@ -495,13 +425,6 @@ class MarkCompactCollector {
   friend class UnmarkObjectVisitor;
   static void UnmarkObject(HeapObject* obj);
 #endif
-
-  Heap* heap_;
-  MarkingStack marking_stack_;
-  CodeFlusher* code_flusher_;
-
-  friend class Heap;
-  friend class OverflowedObjectsScanner;
 };