// Copyright 2012 the V8 project authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #ifndef V8_HEAP_HEAP_H_ #define V8_HEAP_HEAP_H_ #include #include #include #include // Clients of this interface shouldn't depend on lots of heap internals. // Do not include anything from src/heap here! #include "include/v8.h" #include "src/allocation.h" #include "src/assert-scope.h" #include "src/base/atomic-utils.h" #include "src/globals.h" #include "src/heap-symbols.h" #include "src/objects.h" #include "src/objects/hash-table.h" #include "src/objects/string-table.h" #include "src/visitors.h" namespace v8 { namespace debug { typedef void (*OutOfMemoryCallback)(void* data); } // namespace debug namespace internal { namespace heap { class HeapTester; class TestMemoryAllocatorScope; } // namespace heap using v8::MemoryPressureLevel; // Defines all the roots in Heap. #define STRONG_ROOT_LIST(V) \ /* Cluster the most popular ones in a few cache lines here at the top. */ \ /* The first 32 entries are most often used in the startup snapshot and */ \ /* can use a shorter representation in the serialization format. */ \ V(Map, free_space_map, FreeSpaceMap) \ V(Map, one_pointer_filler_map, OnePointerFillerMap) \ V(Map, two_pointer_filler_map, TwoPointerFillerMap) \ V(Oddball, uninitialized_value, UninitializedValue) \ V(Oddball, undefined_value, UndefinedValue) \ V(Oddball, the_hole_value, TheHoleValue) \ V(Oddball, null_value, NullValue) \ V(Oddball, true_value, TrueValue) \ V(Oddball, false_value, FalseValue) \ V(String, empty_string, empty_string) \ V(Map, meta_map, MetaMap) \ V(Map, byte_array_map, ByteArrayMap) \ V(Map, fixed_array_map, FixedArrayMap) \ V(Map, fixed_cow_array_map, FixedCOWArrayMap) \ V(Map, hash_table_map, HashTableMap) \ V(Map, symbol_map, SymbolMap) \ V(Map, one_byte_string_map, OneByteStringMap) \ V(Map, one_byte_internalized_string_map, OneByteInternalizedStringMap) \ V(Map, scope_info_map, ScopeInfoMap) \ V(Map, shared_function_info_map, SharedFunctionInfoMap) \ V(Map, code_map, CodeMap) \ V(Map, function_context_map, FunctionContextMap) \ V(Map, cell_map, CellMap) \ V(Map, weak_cell_map, WeakCellMap) \ V(Map, global_property_cell_map, GlobalPropertyCellMap) \ V(Map, foreign_map, ForeignMap) \ V(Map, heap_number_map, HeapNumberMap) \ V(Map, transition_array_map, TransitionArrayMap) \ V(Map, feedback_vector_map, FeedbackVectorMap) \ V(ScopeInfo, empty_scope_info, EmptyScopeInfo) \ V(FixedArray, empty_fixed_array, EmptyFixedArray) \ V(DescriptorArray, empty_descriptor_array, EmptyDescriptorArray) \ /* Entries beyond the first 32 */ \ /* The roots above this line should be boring from a GC point of view. */ \ /* This means they are never in new space and never on a page that is */ \ /* being compacted. */ \ /* Oddballs */ \ V(Oddball, arguments_marker, ArgumentsMarker) \ V(Oddball, exception, Exception) \ V(Oddball, termination_exception, TerminationException) \ V(Oddball, optimized_out, OptimizedOut) \ V(Oddball, stale_register, StaleRegister) \ /* Context maps */ \ V(Map, native_context_map, NativeContextMap) \ V(Map, module_context_map, ModuleContextMap) \ V(Map, eval_context_map, EvalContextMap) \ V(Map, script_context_map, ScriptContextMap) \ V(Map, block_context_map, BlockContextMap) \ V(Map, catch_context_map, CatchContextMap) \ V(Map, with_context_map, WithContextMap) \ V(Map, debug_evaluate_context_map, DebugEvaluateContextMap) \ V(Map, script_context_table_map, ScriptContextTableMap) \ /* Maps */ \ V(Map, fixed_double_array_map, FixedDoubleArrayMap) \ V(Map, mutable_heap_number_map, MutableHeapNumberMap) \ V(Map, ordered_hash_table_map, OrderedHashTableMap) \ V(Map, unseeded_number_dictionary_map, UnseededNumberDictionaryMap) \ V(Map, sloppy_arguments_elements_map, SloppyArgumentsElementsMap) \ V(Map, small_ordered_hash_map_map, SmallOrderedHashMapMap) \ V(Map, small_ordered_hash_set_map, SmallOrderedHashSetMap) \ V(Map, message_object_map, JSMessageObjectMap) \ V(Map, external_map, ExternalMap) \ V(Map, bytecode_array_map, BytecodeArrayMap) \ V(Map, module_info_map, ModuleInfoMap) \ V(Map, no_closures_cell_map, NoClosuresCellMap) \ V(Map, one_closure_cell_map, OneClosureCellMap) \ V(Map, many_closures_cell_map, ManyClosuresCellMap) \ V(Map, property_array_map, PropertyArrayMap) \ V(Map, bigint_map, BigIntMap) \ /* String maps */ \ V(Map, native_source_string_map, NativeSourceStringMap) \ V(Map, string_map, StringMap) \ V(Map, cons_one_byte_string_map, ConsOneByteStringMap) \ V(Map, cons_string_map, ConsStringMap) \ V(Map, thin_one_byte_string_map, ThinOneByteStringMap) \ V(Map, thin_string_map, ThinStringMap) \ V(Map, sliced_string_map, SlicedStringMap) \ V(Map, sliced_one_byte_string_map, SlicedOneByteStringMap) \ V(Map, external_string_map, ExternalStringMap) \ V(Map, external_string_with_one_byte_data_map, \ ExternalStringWithOneByteDataMap) \ V(Map, external_one_byte_string_map, ExternalOneByteStringMap) \ V(Map, short_external_string_map, ShortExternalStringMap) \ V(Map, short_external_string_with_one_byte_data_map, \ ShortExternalStringWithOneByteDataMap) \ V(Map, internalized_string_map, InternalizedStringMap) \ V(Map, external_internalized_string_map, ExternalInternalizedStringMap) \ V(Map, external_internalized_string_with_one_byte_data_map, \ ExternalInternalizedStringWithOneByteDataMap) \ V(Map, external_one_byte_internalized_string_map, \ ExternalOneByteInternalizedStringMap) \ V(Map, short_external_internalized_string_map, \ ShortExternalInternalizedStringMap) \ V(Map, short_external_internalized_string_with_one_byte_data_map, \ ShortExternalInternalizedStringWithOneByteDataMap) \ V(Map, short_external_one_byte_internalized_string_map, \ ShortExternalOneByteInternalizedStringMap) \ V(Map, short_external_one_byte_string_map, ShortExternalOneByteStringMap) \ /* Array element maps */ \ V(Map, fixed_uint8_array_map, FixedUint8ArrayMap) \ V(Map, fixed_int8_array_map, FixedInt8ArrayMap) \ V(Map, fixed_uint16_array_map, FixedUint16ArrayMap) \ V(Map, fixed_int16_array_map, FixedInt16ArrayMap) \ V(Map, fixed_uint32_array_map, FixedUint32ArrayMap) \ V(Map, fixed_int32_array_map, FixedInt32ArrayMap) \ V(Map, fixed_float32_array_map, FixedFloat32ArrayMap) \ V(Map, fixed_float64_array_map, FixedFloat64ArrayMap) \ V(Map, fixed_uint8_clamped_array_map, FixedUint8ClampedArrayMap) \ /* Oddball maps */ \ V(Map, undefined_map, UndefinedMap) \ V(Map, the_hole_map, TheHoleMap) \ V(Map, null_map, NullMap) \ V(Map, boolean_map, BooleanMap) \ V(Map, uninitialized_map, UninitializedMap) \ V(Map, arguments_marker_map, ArgumentsMarkerMap) \ V(Map, exception_map, ExceptionMap) \ V(Map, termination_exception_map, TerminationExceptionMap) \ V(Map, optimized_out_map, OptimizedOutMap) \ V(Map, stale_register_map, StaleRegisterMap) \ /* Canonical empty values */ \ V(EnumCache, empty_enum_cache, EmptyEnumCache) \ V(PropertyArray, empty_property_array, EmptyPropertyArray) \ V(ByteArray, empty_byte_array, EmptyByteArray) \ V(FixedTypedArrayBase, empty_fixed_uint8_array, EmptyFixedUint8Array) \ V(FixedTypedArrayBase, empty_fixed_int8_array, EmptyFixedInt8Array) \ V(FixedTypedArrayBase, empty_fixed_uint16_array, EmptyFixedUint16Array) \ V(FixedTypedArrayBase, empty_fixed_int16_array, EmptyFixedInt16Array) \ V(FixedTypedArrayBase, empty_fixed_uint32_array, EmptyFixedUint32Array) \ V(FixedTypedArrayBase, empty_fixed_int32_array, EmptyFixedInt32Array) \ V(FixedTypedArrayBase, empty_fixed_float32_array, EmptyFixedFloat32Array) \ V(FixedTypedArrayBase, empty_fixed_float64_array, EmptyFixedFloat64Array) \ V(FixedTypedArrayBase, empty_fixed_uint8_clamped_array, \ EmptyFixedUint8ClampedArray) \ V(Script, empty_script, EmptyScript) \ V(Cell, undefined_cell, UndefinedCell) \ V(FixedArray, empty_sloppy_arguments_elements, EmptySloppyArgumentsElements) \ V(SeededNumberDictionary, empty_slow_element_dictionary, \ EmptySlowElementDictionary) \ V(FixedArray, empty_ordered_hash_table, EmptyOrderedHashTable) \ V(PropertyCell, empty_property_cell, EmptyPropertyCell) \ V(WeakCell, empty_weak_cell, EmptyWeakCell) \ V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo) \ /* Protectors */ \ V(Cell, array_constructor_protector, ArrayConstructorProtector) \ V(PropertyCell, array_protector, ArrayProtector) \ V(Cell, is_concat_spreadable_protector, IsConcatSpreadableProtector) \ V(PropertyCell, species_protector, SpeciesProtector) \ V(Cell, string_length_protector, StringLengthProtector) \ V(Cell, fast_array_iteration_protector, FastArrayIterationProtector) \ V(PropertyCell, array_iterator_protector, ArrayIteratorProtector) \ V(PropertyCell, array_buffer_neutering_protector, \ ArrayBufferNeuteringProtector) \ /* Special numbers */ \ V(HeapNumber, nan_value, NanValue) \ V(HeapNumber, hole_nan_value, HoleNanValue) \ V(HeapNumber, infinity_value, InfinityValue) \ V(HeapNumber, minus_zero_value, MinusZeroValue) \ V(HeapNumber, minus_infinity_value, MinusInfinityValue) \ /* Caches */ \ V(FixedArray, number_string_cache, NumberStringCache) \ V(FixedArray, single_character_string_cache, SingleCharacterStringCache) \ V(FixedArray, string_split_cache, StringSplitCache) \ V(FixedArray, regexp_multiple_cache, RegExpMultipleCache) \ /* Lists and dictionaries */ \ V(NameDictionary, empty_property_dictionary, EmptyPropertyDictionary) \ V(NameDictionary, public_symbol_table, PublicSymbolTable) \ V(NameDictionary, api_symbol_table, ApiSymbolTable) \ V(NameDictionary, api_private_symbol_table, ApiPrivateSymbolTable) \ V(Object, script_list, ScriptList) \ V(UnseededNumberDictionary, code_stubs, CodeStubs) \ V(FixedArray, materialized_objects, MaterializedObjects) \ V(FixedArray, microtask_queue, MicrotaskQueue) \ V(FixedArray, detached_contexts, DetachedContexts) \ V(HeapObject, retaining_path_targets, RetainingPathTargets) \ V(ArrayList, retained_maps, RetainedMaps) \ V(WeakHashTable, weak_object_to_code_table, WeakObjectToCodeTable) \ /* weak_new_space_object_to_code_list is an array of weak cells, where */ \ /* slots with even indices refer to the weak object, and the subsequent */ \ /* slots refer to the code with the reference to the weak object. */ \ V(ArrayList, weak_new_space_object_to_code_list, \ WeakNewSpaceObjectToCodeList) \ /* List to hold onto feedback vectors that we need for code coverage */ \ V(Object, code_coverage_list, CodeCoverageList) \ V(Object, weak_stack_trace_list, WeakStackTraceList) \ V(Object, noscript_shared_function_infos, NoScriptSharedFunctionInfos) \ V(FixedArray, serialized_templates, SerializedTemplates) \ V(FixedArray, serialized_global_proxy_sizes, SerializedGlobalProxySizes) \ V(TemplateList, message_listeners, MessageListeners) \ /* JS Entries */ \ V(Code, js_entry_code, JsEntryCode) \ V(Code, js_construct_entry_code, JsConstructEntryCode) // Entries in this list are limited to Smis and are not visited during GC. #define SMI_ROOT_LIST(V) \ V(Smi, stack_limit, StackLimit) \ V(Smi, real_stack_limit, RealStackLimit) \ V(Smi, last_script_id, LastScriptId) \ V(Smi, hash_seed, HashSeed) \ /* To distinguish the function templates, so that we can find them in the */ \ /* function cache of the native context. */ \ V(Smi, next_template_serial_number, NextTemplateSerialNumber) \ V(Smi, arguments_adaptor_deopt_pc_offset, ArgumentsAdaptorDeoptPCOffset) \ V(Smi, construct_stub_create_deopt_pc_offset, \ ConstructStubCreateDeoptPCOffset) \ V(Smi, construct_stub_invoke_deopt_pc_offset, \ ConstructStubInvokeDeoptPCOffset) \ V(Smi, getter_stub_deopt_pc_offset, GetterStubDeoptPCOffset) \ V(Smi, setter_stub_deopt_pc_offset, SetterStubDeoptPCOffset) \ V(Smi, interpreter_entry_return_pc_offset, InterpreterEntryReturnPCOffset) #define ROOT_LIST(V) \ STRONG_ROOT_LIST(V) \ SMI_ROOT_LIST(V) \ V(StringTable, string_table, StringTable) // Heap roots that are known to be immortal immovable, for which we can safely // skip write barriers. This list is not complete and has omissions. #define IMMORTAL_IMMOVABLE_ROOT_LIST(V) \ V(ArgumentsMarker) \ V(ArgumentsMarkerMap) \ V(ArrayBufferNeuteringProtector) \ V(ArrayIteratorProtector) \ V(ArrayProtector) \ V(BigIntMap) \ V(BlockContextMap) \ V(BooleanMap) \ V(ByteArrayMap) \ V(BytecodeArrayMap) \ V(CatchContextMap) \ V(CellMap) \ V(CodeMap) \ V(EmptyByteArray) \ V(EmptyDescriptorArray) \ V(EmptyFixedArray) \ V(EmptyFixedFloat32Array) \ V(EmptyFixedFloat64Array) \ V(EmptyFixedInt16Array) \ V(EmptyFixedInt32Array) \ V(EmptyFixedInt8Array) \ V(EmptyFixedUint16Array) \ V(EmptyFixedUint32Array) \ V(EmptyFixedUint8Array) \ V(EmptyFixedUint8ClampedArray) \ V(EmptyPropertyCell) \ V(EmptyScopeInfo) \ V(EmptyScript) \ V(EmptySloppyArgumentsElements) \ V(EmptySlowElementDictionary) \ V(empty_string) \ V(EmptyWeakCell) \ V(EvalContextMap) \ V(Exception) \ V(FalseValue) \ V(FastArrayIterationProtector) \ V(FixedArrayMap) \ V(FixedCOWArrayMap) \ V(FixedDoubleArrayMap) \ V(ForeignMap) \ V(FreeSpaceMap) \ V(FunctionContextMap) \ V(GlobalPropertyCellMap) \ V(HashTableMap) \ V(HeapNumberMap) \ V(HoleNanValue) \ V(InfinityValue) \ V(IsConcatSpreadableProtector) \ V(JsConstructEntryCode) \ V(JsEntryCode) \ V(JSMessageObjectMap) \ V(ManyClosuresCellMap) \ V(MetaMap) \ V(MinusInfinityValue) \ V(MinusZeroValue) \ V(ModuleContextMap) \ V(ModuleInfoMap) \ V(MutableHeapNumberMap) \ V(NanValue) \ V(NativeContextMap) \ V(NoClosuresCellMap) \ V(NullMap) \ V(NullValue) \ V(OneClosureCellMap) \ V(OnePointerFillerMap) \ V(OptimizedOut) \ V(OrderedHashTableMap) \ V(PropertyArrayMap) \ V(SmallOrderedHashMapMap) \ V(SmallOrderedHashSetMap) \ V(ScopeInfoMap) \ V(ScriptContextMap) \ V(SharedFunctionInfoMap) \ V(SloppyArgumentsElementsMap) \ V(SpeciesProtector) \ V(StaleRegister) \ V(StringLengthProtector) \ V(SymbolMap) \ V(TerminationException) \ V(TheHoleMap) \ V(TheHoleValue) \ V(TransitionArrayMap) \ V(TrueValue) \ V(TwoPointerFillerMap) \ V(UndefinedCell) \ V(UndefinedMap) \ V(UndefinedValue) \ V(UninitializedMap) \ V(UninitializedValue) \ V(WeakCellMap) \ V(WithContextMap) \ PRIVATE_SYMBOL_LIST(V) #define FIXED_ARRAY_ELEMENTS_WRITE_BARRIER(heap, array, start, length) \ do { \ heap->RecordFixedArrayElements(array, start, length); \ heap->incremental_marking()->RecordWrites(array); \ } while (false) class AllocationObserver; class ArrayBufferTracker; class ConcurrentMarking; class GCIdleTimeAction; class GCIdleTimeHandler; class GCIdleTimeHeapState; class GCTracer; class HeapObjectsFilter; class HeapStats; class HistogramTimer; class Isolate; class LocalEmbedderHeapTracer; class MemoryAllocator; class MemoryReducer; class MinorMarkCompactCollector; class ObjectIterator; class ObjectStats; class Page; class PagedSpace; class RootVisitor; class Scavenger; class ScavengeJob; class Space; class StoreBuffer; class TracePossibleWrapperReporter; class WeakObjectRetainer; typedef void (*ObjectSlotCallback)(HeapObject** from, HeapObject* to); enum ArrayStorageAllocationMode { DONT_INITIALIZE_ARRAY_ELEMENTS, INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE }; enum class ClearRecordedSlots { kYes, kNo }; enum class GarbageCollectionReason { kUnknown = 0, kAllocationFailure = 1, kAllocationLimit = 2, kContextDisposal = 3, kCountersExtension = 4, kDebugger = 5, kDeserializer = 6, kExternalMemoryPressure = 7, kFinalizeMarkingViaStackGuard = 8, kFinalizeMarkingViaTask = 9, kFullHashtable = 10, kHeapProfiler = 11, kIdleTask = 12, kLastResort = 13, kLowMemoryNotification = 14, kMakeHeapIterable = 15, kMemoryPressure = 16, kMemoryReducer = 17, kRuntime = 18, kSamplingProfiler = 19, kSnapshotCreator = 20, kTesting = 21 // If you add new items here, then update the incremental_marking_reason, // mark_compact_reason, and scavenge_reason counters in counters.h. // Also update src/tools/metrics/histograms/histograms.xml in chromium. }; enum class YoungGenerationHandling { kRegularScavenge = 0, kFastPromotionDuringScavenge = 1, // Histogram::InspectConstructionArguments in chromium requires us to have at // least three buckets. kUnusedBucket = 2, // If you add new items here, then update the young_generation_handling in // counters.h. // Also update src/tools/metrics/histograms/histograms.xml in chromium. }; class AllocationResult { public: static inline AllocationResult Retry(AllocationSpace space = NEW_SPACE) { return AllocationResult(space); } // Implicit constructor from Object*. AllocationResult(Object* object) // NOLINT : object_(object) { // AllocationResults can't return Smis, which are used to represent // failure and the space to retry in. CHECK(!object->IsSmi()); } AllocationResult() : object_(Smi::FromInt(NEW_SPACE)) {} inline bool IsRetry() { return object_->IsSmi(); } inline HeapObject* ToObjectChecked(); inline AllocationSpace RetrySpace(); template bool To(T** obj) { if (IsRetry()) return false; *obj = T::cast(object_); return true; } private: explicit AllocationResult(AllocationSpace space) : object_(Smi::FromInt(static_cast(space))) {} Object* object_; }; STATIC_ASSERT(sizeof(AllocationResult) == kPointerSize); #ifdef DEBUG struct CommentStatistic { const char* comment; int size; int count; void Clear() { comment = NULL; size = 0; count = 0; } // Must be small, since an iteration is used for lookup. static const int kMaxComments = 64; }; #endif class NumberAndSizeInfo BASE_EMBEDDED { public: NumberAndSizeInfo() : number_(0), bytes_(0) {} int number() const { return number_; } void increment_number(int num) { number_ += num; } int bytes() const { return bytes_; } void increment_bytes(int size) { bytes_ += size; } void clear() { number_ = 0; bytes_ = 0; } private: int number_; int bytes_; }; // HistogramInfo class for recording a single "bar" of a histogram. This // class is used for collecting statistics to print to the log file. class HistogramInfo : public NumberAndSizeInfo { public: HistogramInfo() : NumberAndSizeInfo(), name_(nullptr) {} const char* name() { return name_; } void set_name(const char* name) { name_ = name; } private: const char* name_; }; class Heap { public: // Declare all the root indices. This defines the root list order. enum RootListIndex { #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex, STRONG_ROOT_LIST(ROOT_INDEX_DECLARATION) #undef ROOT_INDEX_DECLARATION #define STRING_INDEX_DECLARATION(name, str) k##name##RootIndex, INTERNALIZED_STRING_LIST(STRING_INDEX_DECLARATION) #undef STRING_DECLARATION #define SYMBOL_INDEX_DECLARATION(name) k##name##RootIndex, PRIVATE_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION) #undef SYMBOL_INDEX_DECLARATION #define SYMBOL_INDEX_DECLARATION(name, description) k##name##RootIndex, PUBLIC_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION) WELL_KNOWN_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION) #undef SYMBOL_INDEX_DECLARATION // Utility type maps #define DECLARE_STRUCT_MAP(NAME, Name, name) k##Name##MapRootIndex, STRUCT_LIST(DECLARE_STRUCT_MAP) #undef DECLARE_STRUCT_MAP kStringTableRootIndex, #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex, SMI_ROOT_LIST(ROOT_INDEX_DECLARATION) #undef ROOT_INDEX_DECLARATION kRootListLength, kStrongRootListLength = kStringTableRootIndex, kSmiRootsStart = kStringTableRootIndex + 1 }; enum FindMementoMode { kForRuntime, kForGC }; enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT, MINOR_MARK_COMPACT }; using PretenuringFeedbackMap = std::unordered_map; // Taking this mutex prevents the GC from entering a phase that relocates // object references. base::Mutex* relocation_mutex() { return &relocation_mutex_; } // Support for partial snapshots. After calling this we have a linear // space to write objects in each space. struct Chunk { uint32_t size; Address start; Address end; }; typedef std::vector Reservation; static const int kInitalOldGenerationLimitFactor = 2; #if V8_OS_ANDROID // Don't apply pointer multiplier on Android since it has no swap space and // should instead adapt it's heap size based on available physical memory. static const int kPointerMultiplier = 1; #else static const int kPointerMultiplier = i::kPointerSize / 4; #endif // Semi-space size needs to be a multiple of page size. static const int kMinSemiSpaceSizeInKB = 1 * kPointerMultiplier * ((1 << kPageSizeBits) / KB); static const int kMaxSemiSpaceSizeInKB = 16 * kPointerMultiplier * ((1 << kPageSizeBits) / KB); // The old space size has to be a multiple of Page::kPageSize. // Sizes are in MB. static const int kMinOldGenerationSize = 128 * kPointerMultiplier; static const int kMaxOldGenerationSize = 1024 * kPointerMultiplier; static const int kTraceRingBufferSize = 512; static const int kStacktraceBufferSize = 512; V8_EXPORT_PRIVATE static const double kMinHeapGrowingFactor; V8_EXPORT_PRIVATE static const double kMaxHeapGrowingFactor; static const double kMaxHeapGrowingFactorMemoryConstrained; static const double kMaxHeapGrowingFactorIdle; static const double kConservativeHeapGrowingFactor; static const double kTargetMutatorUtilization; static const int kNoGCFlags = 0; static const int kReduceMemoryFootprintMask = 1; static const int kAbortIncrementalMarkingMask = 2; static const int kFinalizeIncrementalMarkingMask = 4; // Making the heap iterable requires us to abort incremental marking. static const int kMakeHeapIterableMask = kAbortIncrementalMarkingMask; // The roots that have an index less than this are always in old space. static const int kOldSpaceRoots = 0x20; // The minimum size of a HeapObject on the heap. static const int kMinObjectSizeInWords = 2; static const int kMinPromotedPercentForFastPromotionMode = 90; STATIC_ASSERT(kUndefinedValueRootIndex == Internals::kUndefinedValueRootIndex); STATIC_ASSERT(kTheHoleValueRootIndex == Internals::kTheHoleValueRootIndex); STATIC_ASSERT(kNullValueRootIndex == Internals::kNullValueRootIndex); STATIC_ASSERT(kTrueValueRootIndex == Internals::kTrueValueRootIndex); STATIC_ASSERT(kFalseValueRootIndex == Internals::kFalseValueRootIndex); STATIC_ASSERT(kempty_stringRootIndex == Internals::kEmptyStringRootIndex); // Calculates the maximum amount of filler that could be required by the // given alignment. static int GetMaximumFillToAlign(AllocationAlignment alignment); // Calculates the actual amount of filler required for a given address at the // given alignment. static int GetFillToAlign(Address address, AllocationAlignment alignment); template static inline bool IsOneByte(T t, int chars); static void FatalProcessOutOfMemory(const char* location, bool is_heap_oom = false); V8_EXPORT_PRIVATE static bool RootIsImmortalImmovable(int root_index); // Checks whether the space is valid. static bool IsValidAllocationSpace(AllocationSpace space); // Generated code can embed direct references to non-writable roots if // they are in new space. static bool RootCanBeWrittenAfterInitialization(RootListIndex root_index); // Zapping is needed for verify heap, and always done in debug builds. static inline bool ShouldZapGarbage() { #ifdef DEBUG return true; #else #ifdef VERIFY_HEAP return FLAG_verify_heap; #else return false; #endif #endif } static inline bool IsYoungGenerationCollector(GarbageCollector collector) { return collector == SCAVENGER || collector == MINOR_MARK_COMPACTOR; } static inline GarbageCollector YoungGenerationCollector() { return (FLAG_minor_mc) ? MINOR_MARK_COMPACTOR : SCAVENGER; } static inline const char* CollectorName(GarbageCollector collector) { switch (collector) { case SCAVENGER: return "Scavenger"; case MARK_COMPACTOR: return "Mark-Compact"; case MINOR_MARK_COMPACTOR: return "Minor Mark-Compact"; } return "Unknown collector"; } V8_EXPORT_PRIVATE static double MaxHeapGrowingFactor( size_t max_old_generation_size); V8_EXPORT_PRIVATE static double HeapGrowingFactor(double gc_speed, double mutator_speed, double max_factor); // Copy block of memory from src to dst. Size of block should be aligned // by pointer size. static inline void CopyBlock(Address dst, Address src, int byte_size); // Notifies the heap that is ok to start marking or other activities that // should not happen during deserialization. void NotifyDeserializationComplete(); inline Address* NewSpaceAllocationTopAddress(); inline Address* NewSpaceAllocationLimitAddress(); inline Address* OldSpaceAllocationTopAddress(); inline Address* OldSpaceAllocationLimitAddress(); // FreeSpace objects have a null map after deserialization. Update the map. void RepairFreeListsAfterDeserialization(); // Move len elements within a given array from src_index index to dst_index // index. void MoveElements(FixedArray* array, int dst_index, int src_index, int len); // Initialize a filler object to keep the ability to iterate over the heap // when introducing gaps within pages. If slots could have been recorded in // the freed area, then pass ClearRecordedSlots::kYes as the mode. Otherwise, // pass ClearRecordedSlots::kNo. V8_EXPORT_PRIVATE HeapObject* CreateFillerObjectAt(Address addr, int size, ClearRecordedSlots mode); bool CanMoveObjectStart(HeapObject* object); static bool IsImmovable(HeapObject* object); // Trim the given array from the left. Note that this relocates the object // start and hence is only valid if there is only a single reference to it. FixedArrayBase* LeftTrimFixedArray(FixedArrayBase* obj, int elements_to_trim); // Trim the given array from the right. void RightTrimFixedArray(FixedArrayBase* obj, int elements_to_trim); // Converts the given boolean condition to JavaScript boolean value. inline Oddball* ToBoolean(bool condition); // Notify the heap that a context has been disposed. int NotifyContextDisposed(bool dependant_context); void set_native_contexts_list(Object* object) { native_contexts_list_ = object; } Object* native_contexts_list() const { return native_contexts_list_; } void set_allocation_sites_list(Object* object) { allocation_sites_list_ = object; } Object* allocation_sites_list() { return allocation_sites_list_; } // Used in CreateAllocationSiteStub and the (de)serializer. Object** allocation_sites_list_address() { return &allocation_sites_list_; } void set_encountered_weak_collections(Object* weak_collection) { encountered_weak_collections_ = weak_collection; } Object* encountered_weak_collections() const { return encountered_weak_collections_; } void IterateEncounteredWeakCollections(RootVisitor* visitor); // Number of mark-sweeps. int ms_count() const { return ms_count_; } // Checks whether the given object is allowed to be migrated from it's // current space into the given destination space. Used for debugging. bool AllowedToBeMigrated(HeapObject* object, AllocationSpace dest); void CheckHandleCount(); // Number of "runtime allocations" done so far. uint32_t allocations_count() { return allocations_count_; } // Print short heap statistics. void PrintShortHeapStatistics(); inline HeapState gc_state() { return gc_state_; } void SetGCState(HeapState state); inline bool IsInGCPostProcessing() { return gc_post_processing_depth_ > 0; } // If an object has an AllocationMemento trailing it, return it, otherwise // return NULL; template inline AllocationMemento* FindAllocationMemento(Map* map, HeapObject* object); // Returns false if not able to reserve. bool ReserveSpace(Reservation* reservations, std::vector

* maps); // // Support for the API. // bool CreateApiObjects(); // Implements the corresponding V8 API function. bool IdleNotification(double deadline_in_seconds); bool IdleNotification(int idle_time_in_ms); void MemoryPressureNotification(MemoryPressureLevel level, bool is_isolate_locked); void CheckMemoryPressure(); void SetOutOfMemoryCallback(v8::debug::OutOfMemoryCallback callback, void* data); double MonotonicallyIncreasingTimeInMs(); void RecordStats(HeapStats* stats, bool take_snapshot = false); // Check new space expansion criteria and expand semispaces if it was hit. void CheckNewSpaceExpansionCriteria(); void VisitExternalResources(v8::ExternalResourceVisitor* visitor); // An object should be promoted if the object has survived a // scavenge operation. inline bool ShouldBePromoted(Address old_address); void ClearNormalizedMapCaches(); void IncrementDeferredCount(v8::Isolate::UseCounterFeature feature); inline uint32_t HashSeed(); inline int NextScriptId(); inline int GetNextTemplateSerialNumber(); void SetArgumentsAdaptorDeoptPCOffset(int pc_offset); void SetConstructStubCreateDeoptPCOffset(int pc_offset); void SetConstructStubInvokeDeoptPCOffset(int pc_offset); void SetGetterStubDeoptPCOffset(int pc_offset); void SetSetterStubDeoptPCOffset(int pc_offset); void SetInterpreterEntryReturnPCOffset(int pc_offset); void SetSerializedTemplates(FixedArray* templates); void SetSerializedGlobalProxySizes(FixedArray* sizes); // For post mortem debugging. void RememberUnmappedPage(Address page, bool compacted); int64_t external_memory_hard_limit() { return MaxOldGenerationSize() / 2; } int64_t external_memory() { return external_memory_; } void update_external_memory(int64_t delta) { external_memory_ += delta; } void update_external_memory_concurrently_freed(intptr_t freed) { external_memory_concurrently_freed_.Increment(freed); } void account_external_memory_concurrently_freed() { external_memory_ -= external_memory_concurrently_freed_.Value(); external_memory_concurrently_freed_.SetValue(0); } void DeoptMarkedAllocationSites(); bool DeoptMaybeTenuredAllocationSites(); void AddWeakNewSpaceObjectToCodeDependency(Handle obj, Handle code); void AddWeakObjectToCodeDependency(Handle obj, Handle dep); DependentCode* LookupWeakObjectToCodeDependency(Handle obj); void CompactWeakFixedArrays(); void AddRetainedMap(Handle map); // This event is triggered after successful allocation of a new object made // by runtime. Allocations of target space for object evacuation do not // trigger the event. In order to track ALL allocations one must turn off // FLAG_inline_new. inline void OnAllocationEvent(HeapObject* object, int size_in_bytes); // This event is triggered after object is moved to a new place. inline void OnMoveEvent(HeapObject* target, HeapObject* source, int size_in_bytes); bool deserialization_complete() const { return deserialization_complete_; } bool HasLowAllocationRate(); bool HasHighFragmentation(); bool HasHighFragmentation(size_t used, size_t committed); void ActivateMemoryReducerIfNeeded(); bool ShouldOptimizeForMemoryUsage(); bool HighMemoryPressure() { return memory_pressure_level_.Value() != MemoryPressureLevel::kNone; } size_t HeapLimitForDebugging() { const size_t kDebugHeapSizeFactor = 4; size_t max_limit = std::numeric_limits::max() / 4; return Min(max_limit, initial_max_old_generation_size_ * kDebugHeapSizeFactor); } void IncreaseHeapLimitForDebugging() { max_old_generation_size_ = Max(max_old_generation_size_, HeapLimitForDebugging()); } void RestoreOriginalHeapLimit() { // Do not set the limit lower than the live size + some slack. size_t min_limit = SizeOfObjects() + SizeOfObjects() / 4; max_old_generation_size_ = Min(max_old_generation_size_, Max(initial_max_old_generation_size_, min_limit)); } bool IsHeapLimitIncreasedForDebugging() { return max_old_generation_size_ == HeapLimitForDebugging(); } // =========================================================================== // Initialization. =========================================================== // =========================================================================== // Configure heap sizes // max_semi_space_size_in_kb: maximum semi-space size in KB // max_old_generation_size_in_mb: maximum old generation size in MB // code_range_size_in_mb: code range size in MB // Return false if the heap has been set up already. bool ConfigureHeap(size_t max_semi_space_size_in_kb, size_t max_old_generation_size_in_mb, size_t code_range_size_in_mb); bool ConfigureHeapDefault(); // Prepares the heap, setting up memory areas that are needed in the isolate // without actually creating any objects. bool SetUp(); // (Re-)Initialize hash seed from flag or RNG. void InitializeHashSeed(); // Bootstraps the object heap with the core set of objects required to run. // Returns whether it succeeded. bool CreateHeapObjects(); // Create ObjectStats if live_object_stats_ or dead_object_stats_ are nullptr. void CreateObjectStats(); // Destroys all memory allocated by the heap. void TearDown(); // Returns whether SetUp has been called. bool HasBeenSetUp(); bool use_tasks() const { return use_tasks_; } // =========================================================================== // Getters for spaces. ======================================================= // =========================================================================== inline Address NewSpaceTop(); NewSpace* new_space() { return new_space_; } OldSpace* old_space() { return old_space_; } OldSpace* code_space() { return code_space_; } MapSpace* map_space() { return map_space_; } LargeObjectSpace* lo_space() { return lo_space_; } inline PagedSpace* paged_space(int idx); inline Space* space(int idx); // Returns name of the space. const char* GetSpaceName(int idx); // =========================================================================== // Getters to other components. ============================================== // =========================================================================== GCTracer* tracer() { return tracer_; } MemoryAllocator* memory_allocator() { return memory_allocator_; } inline Isolate* isolate(); MarkCompactCollector* mark_compact_collector() { return mark_compact_collector_; } MinorMarkCompactCollector* minor_mark_compact_collector() { return minor_mark_compact_collector_; } // =========================================================================== // Root set access. ========================================================== // =========================================================================== // Heap root getters. #define ROOT_ACCESSOR(type, name, camel_name) inline type* name(); ROOT_LIST(ROOT_ACCESSOR) #undef ROOT_ACCESSOR // Utility type maps. #define STRUCT_MAP_ACCESSOR(NAME, Name, name) inline Map* name##_map(); STRUCT_LIST(STRUCT_MAP_ACCESSOR) #undef STRUCT_MAP_ACCESSOR #define STRING_ACCESSOR(name, str) inline String* name(); INTERNALIZED_STRING_LIST(STRING_ACCESSOR) #undef STRING_ACCESSOR #define SYMBOL_ACCESSOR(name) inline Symbol* name(); PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR) #undef SYMBOL_ACCESSOR #define SYMBOL_ACCESSOR(name, description) inline Symbol* name(); PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR) WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR) #undef SYMBOL_ACCESSOR Object* root(RootListIndex index) { return roots_[index]; } Handle