Revert trunk to bleeding_edge at r12484

src/heap.h

 // Copyright 2012 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 490 matching lines @@
   uintptr_t NewSpaceMask() { return new_space_.mask(); }
   Address NewSpaceTop() { return new_space_.top(); }
 
   NewSpace* new_space() { return &new_space_; }
   OldSpace* old_pointer_space() { return old_pointer_space_; }
   OldSpace* old_data_space() { return old_data_space_; }
   OldSpace* code_space() { return code_space_; }
   MapSpace* map_space() { return map_space_; }
   CellSpace* cell_space() { return cell_space_; }
   LargeObjectSpace* lo_space() { return lo_space_; }
-  PagedSpace* paged_space(int idx) {
-    switch (idx) {
-      case OLD_POINTER_SPACE:
-        return old_pointer_space();
-      case OLD_DATA_SPACE:
-        return old_data_space();
-      case MAP_SPACE:
-        return map_space();
-      case CELL_SPACE:
-        return cell_space();
-      case CODE_SPACE:
-        return code_space();
-      case NEW_SPACE:
-      case LO_SPACE:
-        UNREACHABLE();
-    }
-    return NULL;
-  }
 
   bool always_allocate() { return always_allocate_scope_depth_ != 0; }
   Address always_allocate_scope_depth_address() {
     return reinterpret_cast<Address>(&always_allocate_scope_depth_);
   }
   bool linear_allocation() {
     return linear_allocation_scope_depth_ != 0;
   }
 
   Address* NewSpaceAllocationTopAddress() {
@@ skipping 129 matching lines @@
 
   // Allocates an empty TypeFeedbackInfo.
   MUST_USE_RESULT MaybeObject* AllocateTypeFeedbackInfo();
 
   // Allocates an AliasedArgumentsEntry.
   MUST_USE_RESULT MaybeObject* AllocateAliasedArgumentsEntry(int slot);
 
   // Clear the Instanceof cache (used when a prototype changes).
   inline void ClearInstanceofCache();
 
-  // For use during bootup.
-  void RepairFreeListsAfterBoot();
-
   // Allocates and fully initializes a String.  There are two String
   // encodings: ASCII and two byte. One should choose between the three string
   // allocation functions based on the encoding of the string buffer used to
   // initialized the string.
   //   - ...FromAscii initializes the string from a buffer that is ASCII
   //     encoded (it does not check that the buffer is ASCII encoded) and the
   //     result will be ASCII encoded.
   //   - ...FromUTF8 initializes the string from a buffer that is UTF-8
   //     encoded.  If the characters are all single-byte characters, the
   //     result will be ASCII encoded, otherwise it will converted to two
@@ skipping 632 matching lines @@
   // Callback function passed to Heap::Iterate etc.  Copies an object if
   // necessary, the object might be promoted to an old space.  The caller must
   // ensure the precondition that the object is (a) a heap object and (b) in
   // the heap's from space.
   static inline void ScavengePointer(HeapObject** p);
   static inline void ScavengeObject(HeapObject** p, HeapObject* object);
 
   // Commits from space if it is uncommitted.
   void EnsureFromSpaceIsCommitted();
 
-  // Support for partial snapshots.  After calling this we have a linear
-  // space to write objects in each space.
-  void ReserveSpace(int *sizes, Address* addresses);
+  // Support for partial snapshots.  After calling this we can allocate a
+  // certain number of bytes using only linear allocation (with a
+  // LinearAllocationScope and an AlwaysAllocateScope) without using freelists
+  // or causing a GC.  It returns true of space was reserved or false if a GC is
+  // needed.  For paged spaces the space requested must include the space wasted
+  // at the end of each page when allocating linearly.
+  void ReserveSpace(
+    int new_space_size,
+    int pointer_space_size,
+    int data_space_size,
+    int code_space_size,
+    int map_space_size,
+    int cell_space_size,
+    int large_object_size);
 
   //
   // Support for the API.
   //
 
   bool CreateApiObjects();
 
   // Attempt to find the number in a small cache.  If we finds it, return
   // the string representation of the number.  Otherwise return undefined.
   Object* GetNumberStringCache(Object* number);
@@ skipping 146 matching lines @@
   // mark or if we've already filled the bottom 1/16th of the to space,
   // we try to promote this object.
   inline bool ShouldBePromoted(Address old_address, int object_size);
 
   int MaxObjectSizeInNewSpace() { return kMaxObjectSizeInNewSpace; }
 
   void ClearJSFunctionResultCaches();
 
   void ClearNormalizedMapCaches();
 
+  // Clears the cache of ICs related to this map.
+  void ClearCacheOnMap(Map* map) {
+    if (FLAG_cleanup_code_caches_at_gc) {
+      map->ClearCodeCache(this);
+    }
+  }
+
   GCTracer* tracer() { return tracer_; }
 
   // Returns the size of objects residing in non new spaces.
   intptr_t PromotedSpaceSizeOfObjects();
 
   double total_regexp_code_generated() { return total_regexp_code_generated_; }
   void IncreaseTotalRegexpCodeGenerated(int size) {
     total_regexp_code_generated_ += size;
   }
 
@@ skipping 615 matching lines @@
   VisitorDispatchTable<ScavengingCallback> scavenging_visitors_table_;
 
   MemoryChunk* chunks_queued_for_free_;
 
   Mutex* relocation_mutex_;
 
   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 MarkCompactMarkingVisitor;
   friend class MapCompact;
 
   DISALLOW_COPY_AND_ASSIGN(Heap);
 };
 
 
@@ skipping 46 matching lines @@
  public:
   inline AlwaysAllocateScope();
   inline ~AlwaysAllocateScope();
 
  private:
   // Implicitly disable artificial allocation failures.
   DisallowAllocationFailure disallow_allocation_failure_;
 };
 
 
+class LinearAllocationScope {
+ public:
+  inline LinearAllocationScope();
+  inline ~LinearAllocationScope();
+};
+
+
 #ifdef DEBUG
 // Visitor class to verify interior pointers in spaces that do not contain
 // or care about intergenerational references. All heap object pointers have to
 // point into the heap to a location that has a map pointer at its first word.
 // Caveat: Heap::Contains is an approximation because it can return true for
 // objects in a heap space but above the allocation pointer.
 class VerifyPointersVisitor: public ObjectVisitor {
  public:
   inline void VisitPointers(Object** start, Object** end);
 };
@@ skipping 149 matching lines @@
 
   Key keys_[kLength];
   int field_offsets_[kLength];
 
   friend class ExternalReference;
   friend class Isolate;
   DISALLOW_COPY_AND_ASSIGN(KeyedLookupCache);
 };
 
 
-// Cache for mapping (map, property name) into descriptor index.
+// Cache for mapping (array, property name) into descriptor index.
 // The cache contains both positive and negative results.
 // Descriptor index equals kNotFound means the property is absent.
 // Cleared at startup and prior to any gc.
 class DescriptorLookupCache {
  public:
   // Lookup descriptor index for (map, name).
   // If absent, kAbsent is returned.
-  int Lookup(Map* source, String* name) {
+  int Lookup(DescriptorArray* array, String* name) {
     if (!StringShape(name).IsSymbol()) return kAbsent;
-    int index = Hash(source, name);
+    int index = Hash(array, name);
     Key& key = keys_[index];
-    if ((key.source == source) && (key.name == name)) return results_[index];
+    if ((key.array == array) && (key.name == name)) return results_[index];
     return kAbsent;
   }
 
   // Update an element in the cache.
-  void Update(Map* source, String* name, int result) {
+  void Update(DescriptorArray* array, String* name, int result) {
     ASSERT(result != kAbsent);
     if (StringShape(name).IsSymbol()) {
-      int index = Hash(source, name);
+      int index = Hash(array, name);
       Key& key = keys_[index];
-      key.source = source;
+      key.array = array;
       key.name = name;
       results_[index] = result;
     }
   }
 
   // Clear the cache.
   void Clear();
 
   static const int kAbsent = -2;
 
  private:
   DescriptorLookupCache() {
     for (int i = 0; i < kLength; ++i) {
-      keys_[i].source = NULL;
+      keys_[i].array = NULL;
       keys_[i].name = NULL;
       results_[i] = kAbsent;
     }
   }
 
-  static int Hash(Object* source, String* name) {
+  static int Hash(DescriptorArray* array, String* name) {
     // Uses only lower 32 bits if pointers are larger.
-    uint32_t source_hash =
-        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(source))
+    uint32_t array_hash =
+        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(array))
             >> kPointerSizeLog2;
     uint32_t name_hash =
         static_cast<uint32_t>(reinterpret_cast<uintptr_t>(name))
             >> kPointerSizeLog2;
-    return (source_hash ^ name_hash) % kLength;
+    return (array_hash ^ name_hash) % kLength;
   }
 
   static const int kLength = 64;
   struct Key {
-    Map* source;
+    DescriptorArray* array;
     String* name;
   };
 
   Key keys_[kLength];
   int results_[kLength];
 
   friend class Isolate;
   DISALLOW_COPY_AND_ASSIGN(DescriptorLookupCache);
 };
 
@@ skipping 355 matching lines @@
   AssertNoAllocation no_alloc;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_