[Isolates] Merge from bleeding_edge, revisions 5934-6100.

src/heap.h

 // Copyright 2010 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 472 matching lines @@
   //   - ...FromTwoByte initializes the string from a buffer that is two-byte
   //     encoded.  If the characters are all single-byte characters, the
   //     result will be converted to ASCII, otherwise it will be left as
   //     two-byte.
   // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
   // failed.
   // Please note this does not perform a garbage collection.
   MUST_USE_RESULT MaybeObject* AllocateStringFromAscii(
       Vector<const char> str,
       PretenureFlag pretenure = NOT_TENURED);
-  MUST_USE_RESULT MaybeObject* AllocateStringFromUtf8(
+  MUST_USE_RESULT inline MaybeObject* AllocateStringFromUtf8(
+      Vector<const char> str,
+      PretenureFlag pretenure = NOT_TENURED);
+  MUST_USE_RESULT MaybeObject* AllocateStringFromUtf8Slow(
       Vector<const char> str,
       PretenureFlag pretenure = NOT_TENURED);
   MUST_USE_RESULT MaybeObject* AllocateStringFromTwoByte(
       Vector<const uc16> str,
       PretenureFlag pretenure = NOT_TENURED);
 
   // Allocates a symbol in old space based on the character stream.
   // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
   // failed.
   // Please note this function does not perform a garbage collection.
@@ skipping 700 matching lines @@
   // scavenge since last new space expansion.
   int survived_since_last_expansion_;
 
   int always_allocate_scope_depth_;
   int linear_allocation_scope_depth_;
 
   // For keeping track of context disposals.
   int contexts_disposed_;
 
 #if defined(V8_TARGET_ARCH_X64)
+  static const int kMaxObjectSizeInNewSpace = 1024*KB;
+#else
   static const int kMaxObjectSizeInNewSpace = 512*KB;
-#else
-  static const int kMaxObjectSizeInNewSpace = 256*KB;
 #endif
 
   NewSpace new_space_;
   OldSpace* old_pointer_space_;
   OldSpace* old_data_space_;
   OldSpace* code_space_;
   MapSpace* map_space_;
   CellSpace* cell_space_;
   LargeObjectSpace* lo_space_;
   HeapState gc_state_;
@@ skipping 490 matching lines @@
 
 // A HeapIterator provides iteration over the whole heap. It
 // aggregates the specific iterators for the different spaces as
 // these can only iterate over one space only.
 //
 // HeapIterator can skip free list nodes (that is, de-allocated heap
 // objects that still remain in the heap). As implementation of free
 // nodes filtering uses GC marks, it can't be used during MS/MC GC
 // phases. Also, it is forbidden to interrupt iteration in this mode,
 // as this will leave heap objects marked (and thus, unusable).
-class FreeListNodesFilter;
+class HeapObjectsFilter;
 
 class HeapIterator BASE_EMBEDDED {
  public:
-  enum FreeListNodesFiltering {
+  enum HeapObjectsFiltering {
     kNoFiltering,
-    kPreciseFiltering
+    kFilterFreeListNodes,
+    kFilterUnreachable
   };
 
   HeapIterator();
-  explicit HeapIterator(FreeListNodesFiltering filtering);
+  explicit HeapIterator(HeapObjectsFiltering filtering);
   ~HeapIterator();
 
   HeapObject* next();
   void reset();
 
  private:
   // Perform the initialization.
   void Init();
   // Perform all necessary shutdown (destruction) work.
   void Shutdown();
   HeapObject* NextObject();
 
-  FreeListNodesFiltering filtering_;
-  FreeListNodesFilter* filter_;
+  HeapObjectsFiltering filtering_;
+  HeapObjectsFilter* filter_;
   // Space iterator for iterating all the spaces.
   SpaceIterator* space_iterator_;
   // Object iterator for the space currently being iterated.
   ObjectIterator* object_iterator_;
 };
 
 
 // Cache for mapping (map, property name) into field offset.
 // Cleared at startup and prior to mark sweep collection.
 class KeyedLookupCache {
@@ skipping 293 matching lines @@
   // Size of objects promoted during the current collection.
   intptr_t promoted_objects_size_;
 
   Heap* heap_;
 };
 
 
 class TranscendentalCache {
  public:
   enum Type {ACOS, ASIN, ATAN, COS, EXP, LOG, SIN, TAN, kNumberOfCaches};
+  static const int kTranscendentalTypeBits = 3;
+  STATIC_ASSERT((1 << kTranscendentalTypeBits) >= kNumberOfCaches);
 
   // Returns a heap number with f(input), where f is a math function specified
   // by the 'type' argument.
   MUST_USE_RESULT inline MaybeObject* Get(Type type, double input);
 
   // The cache contains raw Object pointers.  This method disposes of
   // them before a garbage collection.
   void Clear();
 
  private:
   class SubCache {
     static const int kCacheSize = 512;
 
     explicit SubCache(Type t);
 
     MUST_USE_RESULT inline MaybeObject* Get(double input);
 
-    inline double Calculate(double input) {
-      switch (type_) {
-        case ACOS:
-          return acos(input);
-        case ASIN:
-          return asin(input);
-        case ATAN:
-          return atan(input);
-        case COS:
-          return cos(input);
-        case EXP:
-          return exp(input);
-        case LOG:
-          return log(input);
-        case SIN:
-          return sin(input);
-        case TAN:
-          return tan(input);
-        default:
-          return 0.0;  // Never happens.
-      }
-    }
+    inline double Calculate(double input);
 
     struct Element {
       uint32_t in[2];
       Object* output;
     };
 
     union Converter {
       double dbl;
       uint32_t integers[2];
     };
 
     inline static int Hash(const Converter& c) {
       uint32_t hash = (c.integers[0] ^ c.integers[1]);
       hash ^= static_cast<int32_t>(hash) >> 16;
       hash ^= static_cast<int32_t>(hash) >> 8;
       return (hash & (kCacheSize - 1));
     }
 
-    // Inline implementation of the caching.
-    friend class TranscendentalCacheStub;
-
-    // For evaluating value.
-    friend class TranscendentalCache;
-
     Element elements_[kCacheSize];
     Type type_;
     Isolate* isolate_;
 
+    // Allow access to the caches_ array as an ExternalReference.
+    friend class ExternalReference;
+    // Inline implementation of the cache.
+    friend class TranscendentalCacheStub;
+    // For evaluating value.
+    friend class TranscendentalCache;
+
     DISALLOW_COPY_AND_ASSIGN(SubCache);
   };
 
   TranscendentalCache() {
     for (int i = 0; i < kNumberOfCaches; ++i) caches_[i] = NULL;
   }
 
   // Used to create an external reference.
   inline Address cache_array_address();
 
@@ skipping 19 matching lines @@
   // should be returned as in some GC situations the object has been moved.
   virtual Object* RetainAs(Object* object) = 0;
 };
 
 
 } }  // namespace v8::internal
 
 #undef HEAP
 
 #endif  // V8_HEAP_H_