/deps/v8/src/heap.h - Diff - CSE2410 Fall 2014 Bounce - CS Projects

Revision f230a1cf deps/v8/src/heap.h

       V(Map, scope_info_map, ScopeInfoMap)                                         \
       V(Map, fixed_cow_array_map, FixedCOWArrayMap)                                \
       V(Map, fixed_double_array_map, FixedDoubleArrayMap)                          \
       V(Map, constant_pool_array_map, ConstantPoolArrayMap)                        \
       V(Object, no_interceptor_result_sentinel, NoInterceptorResultSentinel)       \
       V(Map, hash_table_map, HashTableMap)                                         \
       V(FixedArray, empty_fixed_array, EmptyFixedArray)                            \
-...
       V(throw_string, "throw")                                               \
       V(done_string, "done")                                                 \
       V(value_string, "value")                                               \
       V(next_string, "next")
       V(next_string, "next")                                                 \
       V(byte_length_string, "byteLength")                                    \
       V(byte_offset_string, "byteOffset")                                    \
       V(buffer_string, "buffer")
     // Forward declarations.
     class GCTracer;
-...
                                          pretenure);
+      }
       inline MUST_USE_RESULT MaybeObject* AllocateEmptyJSArrayWithAllocationSite(
           ElementsKind elements_kind,
           Handle<AllocationSite> allocation_site);
       // Allocate a JSArray with a specified length but elements that are left
       // uninitialized.
       MUST_USE_RESULT MaybeObject* AllocateJSArrayAndStorage(
-...
           ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS,
           PretenureFlag pretenure = NOT_TENURED);
       MUST_USE_RESULT MaybeObject* AllocateJSArrayAndStorageWithAllocationSite(
           ElementsKind elements_kind,
           int length,
           int capacity,
           Handle<AllocationSite> allocation_site,
           ArrayStorageAllocationMode mode = DONT_INITIALIZE_ARRAY_ELEMENTS);
       MUST_USE_RESULT MaybeObject* AllocateJSArrayStorage(
           JSArray* array,
           int length,
-...
           int length,
           PretenureFlag pretenure = NOT_TENURED);
       // Allocates and initializes a new global object based on a constructor.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateGlobalObject(JSFunction* constructor);
       // Returns a deep copy of the JavaScript object.
       // Properties and elements are copied too.
       // Returns failure if allocation failed.
       MUST_USE_RESULT MaybeObject* CopyJSObject(JSObject* source);
       MUST_USE_RESULT MaybeObject* CopyJSObjectWithAllocationSite(
           JSObject* source, AllocationSite* site);
       // Optionally takes an AllocationSite to be appended in an AllocationMemento.
       MUST_USE_RESULT MaybeObject* CopyJSObject(JSObject* source,
                                                 AllocationSite* site = NULL);
       // Allocates the function prototype.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
-...
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateByteArray(int length,
                                                      PretenureFlag pretenure);
       // Allocate a non-tenured byte array of the specified length
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateByteArray(int length);
       MUST_USE_RESULT MaybeObject* AllocateByteArray(
           int length,
           PretenureFlag pretenure = NOT_TENURED);
       // Allocates an external array of the specified length and type.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
-...
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateSymbol();
       // Allocate a tenured simple cell.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateCell(Object* value);
       // Allocate a tenured JS global property cell.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocatePropertyCell(Object* value);
       // Allocate Box.
       MUST_USE_RESULT MaybeObject* AllocateBox(Object* value,
                                                PretenureFlag pretenure);
       // Allocate a tenured AllocationSite. It's payload is null
       MUST_USE_RESULT MaybeObject* AllocateAllocationSite();
-...
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
       // Please note this does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* AllocateFixedArray(int length,
                                                       PretenureFlag pretenure);
       // Allocates a fixed array initialized with undefined values
       MUST_USE_RESULT MaybeObject* AllocateFixedArray(int length);
       MUST_USE_RESULT MaybeObject* AllocateFixedArray(
           int length,
           PretenureFlag pretenure = NOT_TENURED);
       // Allocates an uninitialized fixed array. It must be filled by the caller.
       //
-...
       MUST_USE_RESULT MaybeObject* CopyFixedDoubleArrayWithMap(
           FixedDoubleArray* src, Map* map);
       // Make a copy of src and return it. Returns
       // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.
       MUST_USE_RESULT inline MaybeObject* CopyConstantPoolArray(
           ConstantPoolArray* src);
       // Make a copy of src, set the map, and return the copy. Returns
       // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.
       MUST_USE_RESULT MaybeObject* CopyConstantPoolArrayWithMap(
           ConstantPoolArray* src, Map* map);
       // Allocates a fixed array initialized with the hole values.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
       // failed.
-...
           int length,
           PretenureFlag pretenure = NOT_TENURED);
       MUST_USE_RESULT MaybeObject* AllocateRawFixedDoubleArray(
           int length,
           PretenureFlag pretenure);
       MUST_USE_RESULT MaybeObject* AllocateConstantPoolArray(
           int first_int64_index,
           int first_ptr_index,
           int first_int32_index);
       // Allocates a fixed double array with uninitialized values. Returns
       // Failure::RetryAfterGC(requested_bytes, space) if the allocation failed.
-...
       // Allocated a HeapNumber from value.
       MUST_USE_RESULT MaybeObject* AllocateHeapNumber(
           double value,
           PretenureFlag pretenure);
       // pretenure = NOT_TENURED
       MUST_USE_RESULT MaybeObject* AllocateHeapNumber(double value);
           double value, PretenureFlag pretenure = NOT_TENURED);
       // Converts an int into either a Smi or a HeapNumber object.
       // Returns Failure::RetryAfterGC(requested_bytes, space) if the allocation
-...
       // self_reference. This allows generated code to reference its own Code
       // object by containing this pointer.
       // Please note this function does not perform a garbage collection.
       MUST_USE_RESULT MaybeObject* CreateCode(const CodeDesc& desc,
                                               Code::Flags flags,
                                               Handle<Object> self_reference,
                                               bool immovable = false,
                                               bool crankshafted = false);
       MUST_USE_RESULT MaybeObject* CreateCode(
           const CodeDesc& desc,
           Code::Flags flags,
           Handle<Object> self_reference,
           bool immovable = false,
           bool crankshafted = false,
           int prologue_offset = Code::kPrologueOffsetNotSet);
       MUST_USE_RESULT MaybeObject* CopyCode(Code* code);
-...
       void GarbageCollectionGreedyCheck();
     #endif
       void AddGCPrologueCallback(
           GCPrologueCallback callback, GCType gc_type_filter);
       void RemoveGCPrologueCallback(GCPrologueCallback callback);
       void AddGCEpilogueCallback(
           GCEpilogueCallback callback, GCType gc_type_filter);
       void RemoveGCEpilogueCallback(GCEpilogueCallback callback);
       void AddGCPrologueCallback(v8::Isolate::GCPrologueCallback callback,
                                  GCType gc_type_filter,
                                  bool pass_isolate = true);
       void RemoveGCPrologueCallback(v8::Isolate::GCPrologueCallback callback);
       void SetGlobalGCPrologueCallback(GCCallback callback) {
         ASSERT((callback == NULL) ^ (global_gc_prologue_callback_ == NULL));
         global_gc_prologue_callback_ = callback;
+      }
       void SetGlobalGCEpilogueCallback(GCCallback callback) {
         ASSERT((callback == NULL) ^ (global_gc_epilogue_callback_ == NULL));
         global_gc_epilogue_callback_ = callback;
+      }
       void AddGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback,
                                  GCType gc_type_filter,
                                  bool pass_isolate = true);
       void RemoveGCEpilogueCallback(v8::Isolate::GCEpilogueCallback callback);
       // Heap root getters.  We have versions with and without type::cast() here.
       // You can't use type::cast during GC because the assert fails.
-...
       Object* allocation_sites_list() { return allocation_sites_list_; }
       Object** allocation_sites_list_address() { return &allocation_sites_list_; }
       Object* weak_object_to_code_table() { return weak_object_to_code_table_; }
       // Number of mark-sweeps.
       unsigned int ms_count() { return ms_count_; }
-...
       void Verify();
       bool weak_embedded_maps_verification_enabled() {
         return no_weak_embedded_maps_verification_scope_depth_ == 0;
       bool weak_embedded_objects_verification_enabled() {
         return no_weak_object_verification_scope_depth_ == 0;
+      }
     #endif
-...
       inline intptr_t AdjustAmountOfExternalAllocatedMemory(
           intptr_t change_in_bytes);
       // Allocate uninitialized fixed array.
       MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(int length);
       MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(int length,
                                                          PretenureFlag pretenure);
       // This is only needed for testing high promotion mode.
       void SetNewSpaceHighPromotionModeActive(bool mode) {
         new_space_high_promotion_mode_active_ = mode;
-...
         total_regexp_code_generated_ += size;
+      }
       void IncrementCodeGeneratedBytes(bool is_crankshafted, int size) {
         if (is_crankshafted) {
           crankshaft_codegen_bytes_generated_ += size;
         } else {
           full_codegen_bytes_generated_ += size;
+        }
+      }
       // Returns maximum GC pause.
       double get_max_gc_pause() { return max_gc_pause_; }
-...
         FIRST_CODE_KIND_SUB_TYPE = LAST_TYPE + 1,
         FIRST_FIXED_ARRAY_SUB_TYPE =
             FIRST_CODE_KIND_SUB_TYPE + Code::NUMBER_OF_KINDS,
         OBJECT_STATS_COUNT =
             FIRST_FIXED_ARRAY_SUB_TYPE + LAST_FIXED_ARRAY_SUB_TYPE + 1
         FIRST_CODE_AGE_SUB_TYPE =
             FIRST_FIXED_ARRAY_SUB_TYPE + LAST_FIXED_ARRAY_SUB_TYPE + 1,
         OBJECT_STATS_COUNT = FIRST_CODE_AGE_SUB_TYPE + Code::kLastCodeAge + 1
       };
       void RecordObjectStats(InstanceType type, int sub_type, size_t size) {
       void RecordObjectStats(InstanceType type, size_t size) {
         ASSERT(type <= LAST_TYPE);
         if (sub_type < 0) {
           object_counts_[type]++;
           object_sizes_[type] += size;
         } else {
           if (type == CODE_TYPE) {
             ASSERT(sub_type < Code::NUMBER_OF_KINDS);
             object_counts_[FIRST_CODE_KIND_SUB_TYPE + sub_type]++;
             object_sizes_[FIRST_CODE_KIND_SUB_TYPE + sub_type] += size;
           } else if (type == FIXED_ARRAY_TYPE) {
             ASSERT(sub_type <= LAST_FIXED_ARRAY_SUB_TYPE);
             object_counts_[FIRST_FIXED_ARRAY_SUB_TYPE + sub_type]++;
             object_sizes_[FIRST_FIXED_ARRAY_SUB_TYPE + sub_type] += size;
+          }
+        }
         object_counts_[type]++;
         object_sizes_[type] += size;
+      }
       void RecordCodeSubTypeStats(int code_sub_type, int code_age, size_t size) {
         ASSERT(code_sub_type < Code::NUMBER_OF_KINDS);
         ASSERT(code_age < Code::kLastCodeAge);
         object_counts_[FIRST_CODE_KIND_SUB_TYPE + code_sub_type]++;
         object_sizes_[FIRST_CODE_KIND_SUB_TYPE + code_sub_type] += size;
         object_counts_[FIRST_CODE_AGE_SUB_TYPE + code_age]++;
         object_sizes_[FIRST_CODE_AGE_SUB_TYPE + code_age] += size;
+      }
       void RecordFixedArraySubTypeStats(int array_sub_type, size_t size) {
         ASSERT(array_sub_type <= LAST_FIXED_ARRAY_SUB_TYPE);
         object_counts_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]++;
         object_sizes_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] += size;
+      }
       void CheckpointObjectStats();
-...
         Heap* heap_;
       };
       MaybeObject* AddWeakObjectToCodeDependency(Object* obj, DependentCode* dep);
       DependentCode* LookupWeakObjectToCodeDependency(Object* obj);
       void InitializeWeakObjectToCodeTable() {
         set_weak_object_to_code_table(undefined_value());
+      }
       void EnsureWeakObjectToCodeTable();
      private:
       Heap();
-...
       bool flush_monomorphic_ics_;
       // AllocationMementos found in new space.
       int allocation_mementos_found_;
       int scan_on_scavenge_pages_;
       NewSpace new_space_;
-...
       bool old_gen_exhausted_;
       // Weak list heads, threaded through the objects.
       // List heads are initilized lazily and contain the undefined_value at start.
       Object* native_contexts_list_;
       Object* array_buffers_list_;
       Object* allocation_sites_list_;
       // WeakHashTable that maps objects embedded in optimized code to dependent
       // code list. It is initilized lazily and contains the undefined_value at
       // start.
       Object* weak_object_to_code_table_;
       StoreBufferRebuilder store_buffer_rebuilder_;
       struct StringTypeTable {
-...
       // GC callback function, called before and after mark-compact GC.
       // Allocations in the callback function are disallowed.
       struct GCPrologueCallbackPair {
         GCPrologueCallbackPair(GCPrologueCallback callback, GCType gc_type)
             : callback(callback), gc_type(gc_type) {
         GCPrologueCallbackPair(v8::Isolate::GCPrologueCallback callback,
                                GCType gc_type,
                                bool pass_isolate)
             : callback(callback), gc_type(gc_type), pass_isolate_(pass_isolate) {
+        }
         bool operator==(const GCPrologueCallbackPair& pair) const {
           return pair.callback == callback;
+        }
         GCPrologueCallback callback;
         v8::Isolate::GCPrologueCallback callback;
         GCType gc_type;
         // TODO(dcarney): remove variable
         bool pass_isolate_;
       };
       List<GCPrologueCallbackPair> gc_prologue_callbacks_;
       struct GCEpilogueCallbackPair {
         GCEpilogueCallbackPair(GCEpilogueCallback callback, GCType gc_type)
             : callback(callback), gc_type(gc_type) {
         GCEpilogueCallbackPair(v8::Isolate::GCPrologueCallback callback,
                                GCType gc_type,
                                bool pass_isolate)
             : callback(callback), gc_type(gc_type), pass_isolate_(pass_isolate) {
+        }
         bool operator==(const GCEpilogueCallbackPair& pair) const {
           return pair.callback == callback;
+        }
         GCEpilogueCallback callback;
         v8::Isolate::GCPrologueCallback callback;
         GCType gc_type;
         // TODO(dcarney): remove variable
         bool pass_isolate_;
       };
       List<GCEpilogueCallbackPair> gc_epilogue_callbacks_;
       GCCallback global_gc_prologue_callback_;
       GCCallback global_gc_epilogue_callback_;
       // Support for computing object sizes during GC.
       HeapObjectCallback gc_safe_size_of_old_object_;
       static int GcSafeSizeOfOldObject(HeapObject* object);
-...
       inline void UpdateOldSpaceLimits();
       // Allocate an uninitialized object in map space.  The behavior is identical
       // to Heap::AllocateRaw(size_in_bytes, MAP_SPACE), except that (a) it doesn't
       // have to test the allocation space argument and (b) can reduce code size
       // (since both AllocateRaw and AllocateRawMap are inlined).
       MUST_USE_RESULT inline MaybeObject* AllocateRawMap();
       // Selects the proper allocation space depending on the given object
       // size, pretenuring decision, and preferred old-space.
       static AllocationSpace SelectSpace(int object_size,
                                          AllocationSpace preferred_old_space,
                                          PretenureFlag pretenure) {
         ASSERT(preferred_old_space == OLD_POINTER_SPACE ||
                preferred_old_space == OLD_DATA_SPACE);
         if (object_size > Page::kMaxNonCodeHeapObjectSize) return LO_SPACE;
         return (pretenure == TENURED) ? preferred_old_space : NEW_SPACE;
+      }
       // Allocate an uninitialized fixed array.
       MUST_USE_RESULT MaybeObject* AllocateRawFixedArray(
           int length, PretenureFlag pretenure);
       // Allocate an uninitialized object in the simple cell space.
       MUST_USE_RESULT inline MaybeObject* AllocateRawCell();
       // Allocate an uninitialized fixed double array.
       MUST_USE_RESULT MaybeObject* AllocateRawFixedDoubleArray(
           int length, PretenureFlag pretenure);
       // Allocate an uninitialized object in the global property cell space.
       MUST_USE_RESULT inline MaybeObject* AllocateRawPropertyCell();
       // Allocate an initialized fixed array with the given filler value.
       MUST_USE_RESULT MaybeObject* AllocateFixedArrayWithFiller(
           int length, PretenureFlag pretenure, Object* filler);
       // Initializes a JSObject based on its map.
       void InitializeJSObjectFromMap(JSObject* obj,
-...
           ElementsKind elements_kind,
           PretenureFlag pretenure = NOT_TENURED);
       MUST_USE_RESULT MaybeObject* AllocateJSArrayWithAllocationSite(
           ElementsKind elements_kind,
           Handle<AllocationSite> allocation_site);
       // Allocate empty fixed array.
       MUST_USE_RESULT MaybeObject* AllocateEmptyFixedArray();
-...
       // Allocate empty fixed double array.
       MUST_USE_RESULT MaybeObject* AllocateEmptyFixedDoubleArray();
       // Allocate a tenured simple cell.
       MUST_USE_RESULT MaybeObject* AllocateCell(Object* value);
       // Allocate a tenured JS global property cell initialized with the hole.
       MUST_USE_RESULT MaybeObject* AllocatePropertyCell();
       // Allocate Box.
       MUST_USE_RESULT MaybeObject* AllocateBox(Object* value,
                                                PretenureFlag pretenure);
       // Performs a minor collection in new generation.
       void Scavenge();
-...
       void ClearObjectStats(bool clear_last_time_stats = false);
       void set_weak_object_to_code_table(Object* value) {
         ASSERT(!InNewSpace(value));
         weak_object_to_code_table_ = value;
+      }
       Object** weak_object_to_code_table_address() {
         return &weak_object_to_code_table_;
+      }
       static const int kInitialStringTableSize = 2048;
       static const int kInitialEvalCacheSize = 64;
       static const int kInitialNumberStringCacheSize = 256;
-...
       unsigned int gc_count_at_last_idle_gc_;
       int scavenges_since_last_idle_round_;
       // These two counters are monotomically increasing and never reset.
       size_t full_codegen_bytes_generated_;
       size_t crankshaft_codegen_bytes_generated_;
       // If the --deopt_every_n_garbage_collections flag is set to a positive value,
       // this variable holds the number of garbage collections since the last
       // deoptimization triggered by garbage collection.
       int gcs_since_last_deopt_;
     #ifdef VERIFY_HEAP
       int no_weak_embedded_maps_verification_scope_depth_;
       int no_weak_object_verification_scope_depth_;
     #endif
       static const int kMaxMarkSweepsInIdleRound = 7;
-...
       friend class MarkCompactMarkingVisitor;
       friend class MapCompact;
     #ifdef VERIFY_HEAP
       friend class NoWeakEmbeddedMapsVerificationScope;
       friend class NoWeakObjectVerificationScope;
     #endif
       DISALLOW_COPY_AND_ASSIGN(Heap);
-...
     };
     #ifdef VERIFY_HEAP
     class NoWeakEmbeddedMapsVerificationScope {
     class NoWeakObjectVerificationScope {
      public:
       inline NoWeakEmbeddedMapsVerificationScope();
       inline ~NoWeakEmbeddedMapsVerificationScope();
       inline NoWeakObjectVerificationScope();
       inline ~NoWeakObjectVerificationScope();
     };
     #endif

Also available in: Unified diff