LCOV - code coverage report
Current view: top level - src/heap - heap.h (source / functions) Hit Total Coverage
Test: app.info Lines: 125 129 96.9 %
Date: 2017-04-26 Functions: 30 37 81.1 %

          Line data    Source code
       1             : // Copyright 2012 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_HEAP_HEAP_H_
       6             : #define V8_HEAP_HEAP_H_
       7             : 
       8             : #include <cmath>
       9             : #include <map>
      10             : 
      11             : // Clients of this interface shouldn't depend on lots of heap internals.
      12             : // Do not include anything from src/heap here!
      13             : #include "include/v8.h"
      14             : #include "src/allocation.h"
      15             : #include "src/assert-scope.h"
      16             : #include "src/base/atomic-utils.h"
      17             : #include "src/debug/debug-interface.h"
      18             : #include "src/globals.h"
      19             : #include "src/heap-symbols.h"
      20             : #include "src/list.h"
      21             : #include "src/objects.h"
      22             : #include "src/objects/hash-table.h"
      23             : #include "src/objects/string-table.h"
      24             : #include "src/visitors.h"
      25             : 
      26             : namespace v8 {
      27             : namespace internal {
      28             : 
      29             : using v8::MemoryPressureLevel;
      30             : 
      31             : // Defines all the roots in Heap.
      32             : #define STRONG_ROOT_LIST(V)                                                    \
      33             :   /* Cluster the most popular ones in a few cache lines here at the top.    */ \
      34             :   /* The first 32 entries are most often used in the startup snapshot and   */ \
      35             :   /* can use a shorter representation in the serialization format.          */ \
      36             :   V(Map, free_space_map, FreeSpaceMap)                                         \
      37             :   V(Map, one_pointer_filler_map, OnePointerFillerMap)                          \
      38             :   V(Map, two_pointer_filler_map, TwoPointerFillerMap)                          \
      39             :   V(Oddball, uninitialized_value, UninitializedValue)                          \
      40             :   V(Oddball, undefined_value, UndefinedValue)                                  \
      41             :   V(Oddball, the_hole_value, TheHoleValue)                                     \
      42             :   V(Oddball, null_value, NullValue)                                            \
      43             :   V(Oddball, true_value, TrueValue)                                            \
      44             :   V(Oddball, false_value, FalseValue)                                          \
      45             :   V(String, empty_string, empty_string)                                        \
      46             :   V(Map, meta_map, MetaMap)                                                    \
      47             :   V(Map, byte_array_map, ByteArrayMap)                                         \
      48             :   V(Map, fixed_array_map, FixedArrayMap)                                       \
      49             :   V(Map, fixed_cow_array_map, FixedCOWArrayMap)                                \
      50             :   V(Map, hash_table_map, HashTableMap)                                         \
      51             :   V(Map, symbol_map, SymbolMap)                                                \
      52             :   V(Map, one_byte_string_map, OneByteStringMap)                                \
      53             :   V(Map, one_byte_internalized_string_map, OneByteInternalizedStringMap)       \
      54             :   V(Map, scope_info_map, ScopeInfoMap)                                         \
      55             :   V(Map, shared_function_info_map, SharedFunctionInfoMap)                      \
      56             :   V(Map, code_map, CodeMap)                                                    \
      57             :   V(Map, function_context_map, FunctionContextMap)                             \
      58             :   V(Map, cell_map, CellMap)                                                    \
      59             :   V(Map, weak_cell_map, WeakCellMap)                                           \
      60             :   V(Map, global_property_cell_map, GlobalPropertyCellMap)                      \
      61             :   V(Map, foreign_map, ForeignMap)                                              \
      62             :   V(Map, heap_number_map, HeapNumberMap)                                       \
      63             :   V(Map, transition_array_map, TransitionArrayMap)                             \
      64             :   V(Map, feedback_vector_map, FeedbackVectorMap)                               \
      65             :   V(ScopeInfo, empty_scope_info, EmptyScopeInfo)                               \
      66             :   V(FixedArray, empty_fixed_array, EmptyFixedArray)                            \
      67             :   V(DescriptorArray, empty_descriptor_array, EmptyDescriptorArray)             \
      68             :   /* Entries beyond the first 32                                            */ \
      69             :   /* The roots above this line should be boring from a GC point of view.    */ \
      70             :   /* This means they are never in new space and never on a page that is     */ \
      71             :   /* being compacted.                                                       */ \
      72             :   /* Oddballs */                                                               \
      73             :   V(Oddball, arguments_marker, ArgumentsMarker)                                \
      74             :   V(Oddball, exception, Exception)                                             \
      75             :   V(Oddball, termination_exception, TerminationException)                      \
      76             :   V(Oddball, optimized_out, OptimizedOut)                                      \
      77             :   V(Oddball, stale_register, StaleRegister)                                    \
      78             :   /* Context maps */                                                           \
      79             :   V(Map, native_context_map, NativeContextMap)                                 \
      80             :   V(Map, module_context_map, ModuleContextMap)                                 \
      81             :   V(Map, eval_context_map, EvalContextMap)                                     \
      82             :   V(Map, script_context_map, ScriptContextMap)                                 \
      83             :   V(Map, block_context_map, BlockContextMap)                                   \
      84             :   V(Map, catch_context_map, CatchContextMap)                                   \
      85             :   V(Map, with_context_map, WithContextMap)                                     \
      86             :   V(Map, debug_evaluate_context_map, DebugEvaluateContextMap)                  \
      87             :   V(Map, script_context_table_map, ScriptContextTableMap)                      \
      88             :   /* Maps */                                                                   \
      89             :   V(Map, fixed_double_array_map, FixedDoubleArrayMap)                          \
      90             :   V(Map, mutable_heap_number_map, MutableHeapNumberMap)                        \
      91             :   V(Map, ordered_hash_table_map, OrderedHashTableMap)                          \
      92             :   V(Map, unseeded_number_dictionary_map, UnseededNumberDictionaryMap)          \
      93             :   V(Map, sloppy_arguments_elements_map, SloppyArgumentsElementsMap)            \
      94             :   V(Map, message_object_map, JSMessageObjectMap)                               \
      95             :   V(Map, external_map, ExternalMap)                                            \
      96             :   V(Map, bytecode_array_map, BytecodeArrayMap)                                 \
      97             :   V(Map, module_info_map, ModuleInfoMap)                                       \
      98             :   V(Map, no_closures_cell_map, NoClosuresCellMap)                              \
      99             :   V(Map, one_closure_cell_map, OneClosureCellMap)                              \
     100             :   V(Map, many_closures_cell_map, ManyClosuresCellMap)                          \
     101             :   /* String maps */                                                            \
     102             :   V(Map, native_source_string_map, NativeSourceStringMap)                      \
     103             :   V(Map, string_map, StringMap)                                                \
     104             :   V(Map, cons_one_byte_string_map, ConsOneByteStringMap)                       \
     105             :   V(Map, cons_string_map, ConsStringMap)                                       \
     106             :   V(Map, thin_one_byte_string_map, ThinOneByteStringMap)                       \
     107             :   V(Map, thin_string_map, ThinStringMap)                                       \
     108             :   V(Map, sliced_string_map, SlicedStringMap)                                   \
     109             :   V(Map, sliced_one_byte_string_map, SlicedOneByteStringMap)                   \
     110             :   V(Map, external_string_map, ExternalStringMap)                               \
     111             :   V(Map, external_string_with_one_byte_data_map,                               \
     112             :     ExternalStringWithOneByteDataMap)                                          \
     113             :   V(Map, external_one_byte_string_map, ExternalOneByteStringMap)               \
     114             :   V(Map, short_external_string_map, ShortExternalStringMap)                    \
     115             :   V(Map, short_external_string_with_one_byte_data_map,                         \
     116             :     ShortExternalStringWithOneByteDataMap)                                     \
     117             :   V(Map, internalized_string_map, InternalizedStringMap)                       \
     118             :   V(Map, external_internalized_string_map, ExternalInternalizedStringMap)      \
     119             :   V(Map, external_internalized_string_with_one_byte_data_map,                  \
     120             :     ExternalInternalizedStringWithOneByteDataMap)                              \
     121             :   V(Map, external_one_byte_internalized_string_map,                            \
     122             :     ExternalOneByteInternalizedStringMap)                                      \
     123             :   V(Map, short_external_internalized_string_map,                               \
     124             :     ShortExternalInternalizedStringMap)                                        \
     125             :   V(Map, short_external_internalized_string_with_one_byte_data_map,            \
     126             :     ShortExternalInternalizedStringWithOneByteDataMap)                         \
     127             :   V(Map, short_external_one_byte_internalized_string_map,                      \
     128             :     ShortExternalOneByteInternalizedStringMap)                                 \
     129             :   V(Map, short_external_one_byte_string_map, ShortExternalOneByteStringMap)    \
     130             :   /* Array element maps */                                                     \
     131             :   V(Map, fixed_uint8_array_map, FixedUint8ArrayMap)                            \
     132             :   V(Map, fixed_int8_array_map, FixedInt8ArrayMap)                              \
     133             :   V(Map, fixed_uint16_array_map, FixedUint16ArrayMap)                          \
     134             :   V(Map, fixed_int16_array_map, FixedInt16ArrayMap)                            \
     135             :   V(Map, fixed_uint32_array_map, FixedUint32ArrayMap)                          \
     136             :   V(Map, fixed_int32_array_map, FixedInt32ArrayMap)                            \
     137             :   V(Map, fixed_float32_array_map, FixedFloat32ArrayMap)                        \
     138             :   V(Map, fixed_float64_array_map, FixedFloat64ArrayMap)                        \
     139             :   V(Map, fixed_uint8_clamped_array_map, FixedUint8ClampedArrayMap)             \
     140             :   /* Oddball maps */                                                           \
     141             :   V(Map, undefined_map, UndefinedMap)                                          \
     142             :   V(Map, the_hole_map, TheHoleMap)                                             \
     143             :   V(Map, null_map, NullMap)                                                    \
     144             :   V(Map, boolean_map, BooleanMap)                                              \
     145             :   V(Map, uninitialized_map, UninitializedMap)                                  \
     146             :   V(Map, arguments_marker_map, ArgumentsMarkerMap)                             \
     147             :   V(Map, exception_map, ExceptionMap)                                          \
     148             :   V(Map, termination_exception_map, TerminationExceptionMap)                   \
     149             :   V(Map, optimized_out_map, OptimizedOutMap)                                   \
     150             :   V(Map, stale_register_map, StaleRegisterMap)                                 \
     151             :   /* Canonical empty values */                                                 \
     152             :   V(ByteArray, empty_byte_array, EmptyByteArray)                               \
     153             :   V(FixedTypedArrayBase, empty_fixed_uint8_array, EmptyFixedUint8Array)        \
     154             :   V(FixedTypedArrayBase, empty_fixed_int8_array, EmptyFixedInt8Array)          \
     155             :   V(FixedTypedArrayBase, empty_fixed_uint16_array, EmptyFixedUint16Array)      \
     156             :   V(FixedTypedArrayBase, empty_fixed_int16_array, EmptyFixedInt16Array)        \
     157             :   V(FixedTypedArrayBase, empty_fixed_uint32_array, EmptyFixedUint32Array)      \
     158             :   V(FixedTypedArrayBase, empty_fixed_int32_array, EmptyFixedInt32Array)        \
     159             :   V(FixedTypedArrayBase, empty_fixed_float32_array, EmptyFixedFloat32Array)    \
     160             :   V(FixedTypedArrayBase, empty_fixed_float64_array, EmptyFixedFloat64Array)    \
     161             :   V(FixedTypedArrayBase, empty_fixed_uint8_clamped_array,                      \
     162             :     EmptyFixedUint8ClampedArray)                                               \
     163             :   V(Script, empty_script, EmptyScript)                                         \
     164             :   V(Cell, undefined_cell, UndefinedCell)                                       \
     165             :   V(FixedArray, empty_sloppy_arguments_elements, EmptySloppyArgumentsElements) \
     166             :   V(SeededNumberDictionary, empty_slow_element_dictionary,                     \
     167             :     EmptySlowElementDictionary)                                                \
     168             :   V(PropertyCell, empty_property_cell, EmptyPropertyCell)                      \
     169             :   V(WeakCell, empty_weak_cell, EmptyWeakCell)                                  \
     170             :   V(InterceptorInfo, noop_interceptor_info, NoOpInterceptorInfo)               \
     171             :   /* Protectors */                                                             \
     172             :   V(PropertyCell, array_protector, ArrayProtector)                             \
     173             :   V(Cell, is_concat_spreadable_protector, IsConcatSpreadableProtector)         \
     174             :   V(Cell, species_protector, SpeciesProtector)                                 \
     175             :   V(PropertyCell, string_length_protector, StringLengthProtector)              \
     176             :   V(Cell, fast_array_iteration_protector, FastArrayIterationProtector)         \
     177             :   V(PropertyCell, array_iterator_protector, ArrayIteratorProtector)            \
     178             :   V(PropertyCell, array_buffer_neutering_protector,                            \
     179             :     ArrayBufferNeuteringProtector)                                             \
     180             :   /* Special numbers */                                                        \
     181             :   V(HeapNumber, nan_value, NanValue)                                           \
     182             :   V(HeapNumber, hole_nan_value, HoleNanValue)                                  \
     183             :   V(HeapNumber, infinity_value, InfinityValue)                                 \
     184             :   V(HeapNumber, minus_zero_value, MinusZeroValue)                              \
     185             :   V(HeapNumber, minus_infinity_value, MinusInfinityValue)                      \
     186             :   /* Caches */                                                                 \
     187             :   V(FixedArray, number_string_cache, NumberStringCache)                        \
     188             :   V(FixedArray, single_character_string_cache, SingleCharacterStringCache)     \
     189             :   V(FixedArray, string_split_cache, StringSplitCache)                          \
     190             :   V(FixedArray, regexp_multiple_cache, RegExpMultipleCache)                    \
     191             :   V(Object, instanceof_cache_function, InstanceofCacheFunction)                \
     192             :   V(Object, instanceof_cache_map, InstanceofCacheMap)                          \
     193             :   V(Object, instanceof_cache_answer, InstanceofCacheAnswer)                    \
     194             :   /* Lists and dictionaries */                                                 \
     195             :   V(NameDictionary, empty_properties_dictionary, EmptyPropertiesDictionary)    \
     196             :   V(NameDictionary, public_symbol_table, PublicSymbolTable)                    \
     197             :   V(NameDictionary, api_symbol_table, ApiSymbolTable)                          \
     198             :   V(NameDictionary, api_private_symbol_table, ApiPrivateSymbolTable)           \
     199             :   V(Object, script_list, ScriptList)                                           \
     200             :   V(UnseededNumberDictionary, code_stubs, CodeStubs)                           \
     201             :   V(FixedArray, materialized_objects, MaterializedObjects)                     \
     202             :   V(FixedArray, microtask_queue, MicrotaskQueue)                               \
     203             :   V(FixedArray, detached_contexts, DetachedContexts)                           \
     204             :   V(ArrayList, retained_maps, RetainedMaps)                                    \
     205             :   V(WeakHashTable, weak_object_to_code_table, WeakObjectToCodeTable)           \
     206             :   /* weak_new_space_object_to_code_list is an array of weak cells, where */    \
     207             :   /* slots with even indices refer to the weak object, and the subsequent */   \
     208             :   /* slots refer to the code with the reference to the weak object. */         \
     209             :   V(ArrayList, weak_new_space_object_to_code_list,                             \
     210             :     WeakNewSpaceObjectToCodeList)                                              \
     211             :   /* List to hold onto feedback vectors that we need for code coverage */      \
     212             :   V(Object, code_coverage_list, CodeCoverageList)                              \
     213             :   V(Object, weak_stack_trace_list, WeakStackTraceList)                         \
     214             :   V(Object, noscript_shared_function_infos, NoScriptSharedFunctionInfos)       \
     215             :   V(FixedArray, serialized_templates, SerializedTemplates)                     \
     216             :   V(FixedArray, serialized_global_proxy_sizes, SerializedGlobalProxySizes)     \
     217             :   V(TemplateList, message_listeners, MessageListeners)                         \
     218             :   /* per-Isolate map for JSPromiseCapability. */                               \
     219             :   /* TODO(caitp): Make this a Struct */                                        \
     220             :   V(Map, js_promise_capability_map, JSPromiseCapabilityMap)                    \
     221             :   /* JS Entries */                                                             \
     222             :   V(Code, js_entry_code, JsEntryCode)                                          \
     223             :   V(Code, js_construct_entry_code, JsConstructEntryCode)
     224             : 
     225             : // Entries in this list are limited to Smis and are not visited during GC.
     226             : #define SMI_ROOT_LIST(V)                                                       \
     227             :   V(Smi, stack_limit, StackLimit)                                              \
     228             :   V(Smi, real_stack_limit, RealStackLimit)                                     \
     229             :   V(Smi, last_script_id, LastScriptId)                                         \
     230             :   V(Smi, hash_seed, HashSeed)                                                  \
     231             :   /* To distinguish the function templates, so that we can find them in the */ \
     232             :   /* function cache of the native context. */                                  \
     233             :   V(Smi, next_template_serial_number, NextTemplateSerialNumber)                \
     234             :   V(Smi, arguments_adaptor_deopt_pc_offset, ArgumentsAdaptorDeoptPCOffset)     \
     235             :   V(Smi, construct_stub_create_deopt_pc_offset,                                \
     236             :     ConstructStubCreateDeoptPCOffset)                                          \
     237             :   V(Smi, construct_stub_invoke_deopt_pc_offset,                                \
     238             :     ConstructStubInvokeDeoptPCOffset)                                          \
     239             :   V(Smi, getter_stub_deopt_pc_offset, GetterStubDeoptPCOffset)                 \
     240             :   V(Smi, setter_stub_deopt_pc_offset, SetterStubDeoptPCOffset)                 \
     241             :   V(Smi, interpreter_entry_return_pc_offset, InterpreterEntryReturnPCOffset)
     242             : 
     243             : #define ROOT_LIST(V)  \
     244             :   STRONG_ROOT_LIST(V) \
     245             :   SMI_ROOT_LIST(V)    \
     246             :   V(StringTable, string_table, StringTable)
     247             : 
     248             : 
     249             : // Heap roots that are known to be immortal immovable, for which we can safely
     250             : // skip write barriers. This list is not complete and has omissions.
     251             : #define IMMORTAL_IMMOVABLE_ROOT_LIST(V) \
     252             :   V(ArgumentsMarker)                    \
     253             :   V(ArgumentsMarkerMap)                 \
     254             :   V(ArrayBufferNeuteringProtector)      \
     255             :   V(ArrayIteratorProtector)             \
     256             :   V(ArrayProtector)                     \
     257             :   V(BlockContextMap)                    \
     258             :   V(BooleanMap)                         \
     259             :   V(ByteArrayMap)                       \
     260             :   V(BytecodeArrayMap)                   \
     261             :   V(CatchContextMap)                    \
     262             :   V(CellMap)                            \
     263             :   V(CodeMap)                            \
     264             :   V(EmptyByteArray)                     \
     265             :   V(EmptyDescriptorArray)               \
     266             :   V(EmptyFixedArray)                    \
     267             :   V(EmptyFixedFloat32Array)             \
     268             :   V(EmptyFixedFloat64Array)             \
     269             :   V(EmptyFixedInt16Array)               \
     270             :   V(EmptyFixedInt32Array)               \
     271             :   V(EmptyFixedInt8Array)                \
     272             :   V(EmptyFixedUint16Array)              \
     273             :   V(EmptyFixedUint32Array)              \
     274             :   V(EmptyFixedUint8Array)               \
     275             :   V(EmptyFixedUint8ClampedArray)        \
     276             :   V(EmptyPropertyCell)                  \
     277             :   V(EmptyScopeInfo)                     \
     278             :   V(EmptyScript)                        \
     279             :   V(EmptySloppyArgumentsElements)       \
     280             :   V(EmptySlowElementDictionary)         \
     281             :   V(empty_string)                       \
     282             :   V(EmptyWeakCell)                      \
     283             :   V(EvalContextMap)                     \
     284             :   V(Exception)                          \
     285             :   V(FalseValue)                         \
     286             :   V(FastArrayIterationProtector)        \
     287             :   V(FixedArrayMap)                      \
     288             :   V(FixedCOWArrayMap)                   \
     289             :   V(FixedDoubleArrayMap)                \
     290             :   V(ForeignMap)                         \
     291             :   V(FreeSpaceMap)                       \
     292             :   V(FunctionContextMap)                 \
     293             :   V(GlobalPropertyCellMap)              \
     294             :   V(HashTableMap)                       \
     295             :   V(HeapNumberMap)                      \
     296             :   V(HoleNanValue)                       \
     297             :   V(InfinityValue)                      \
     298             :   V(IsConcatSpreadableProtector)        \
     299             :   V(JsConstructEntryCode)               \
     300             :   V(JsEntryCode)                        \
     301             :   V(JSMessageObjectMap)                 \
     302             :   V(ManyClosuresCellMap)                \
     303             :   V(MetaMap)                            \
     304             :   V(MinusInfinityValue)                 \
     305             :   V(MinusZeroValue)                     \
     306             :   V(ModuleContextMap)                   \
     307             :   V(ModuleInfoMap)                      \
     308             :   V(MutableHeapNumberMap)               \
     309             :   V(NanValue)                           \
     310             :   V(NativeContextMap)                   \
     311             :   V(NoClosuresCellMap)                  \
     312             :   V(NullMap)                            \
     313             :   V(NullValue)                          \
     314             :   V(OneClosureCellMap)                  \
     315             :   V(OnePointerFillerMap)                \
     316             :   V(OptimizedOut)                       \
     317             :   V(OrderedHashTableMap)                \
     318             :   V(ScopeInfoMap)                       \
     319             :   V(ScriptContextMap)                   \
     320             :   V(SharedFunctionInfoMap)              \
     321             :   V(SloppyArgumentsElementsMap)         \
     322             :   V(SpeciesProtector)                   \
     323             :   V(StaleRegister)                      \
     324             :   V(StringLengthProtector)              \
     325             :   V(SymbolMap)                          \
     326             :   V(TerminationException)               \
     327             :   V(TheHoleMap)                         \
     328             :   V(TheHoleValue)                       \
     329             :   V(TransitionArrayMap)                 \
     330             :   V(TrueValue)                          \
     331             :   V(TwoPointerFillerMap)                \
     332             :   V(UndefinedCell)                      \
     333             :   V(UndefinedMap)                       \
     334             :   V(UndefinedValue)                     \
     335             :   V(UninitializedMap)                   \
     336             :   V(UninitializedValue)                 \
     337             :   V(WeakCellMap)                        \
     338             :   V(WithContextMap)                     \
     339             :   PRIVATE_SYMBOL_LIST(V)
     340             : 
     341             : // Forward declarations.
     342             : class AllocationObserver;
     343             : class ArrayBufferTracker;
     344             : class ConcurrentMarking;
     345             : class GCIdleTimeAction;
     346             : class GCIdleTimeHandler;
     347             : class GCIdleTimeHeapState;
     348             : class GCTracer;
     349             : class HeapObjectsFilter;
     350             : class HeapStats;
     351             : class HistogramTimer;
     352             : class Isolate;
     353             : class LocalEmbedderHeapTracer;
     354             : class MemoryAllocator;
     355             : class MemoryReducer;
     356             : class MinorMarkCompactCollector;
     357             : class ObjectIterator;
     358             : class ObjectStats;
     359             : class Page;
     360             : class PagedSpace;
     361             : class RootVisitor;
     362             : class Scavenger;
     363             : class ScavengeJob;
     364             : class Space;
     365             : class StoreBuffer;
     366             : class TracePossibleWrapperReporter;
     367             : class WeakObjectRetainer;
     368             : 
     369             : typedef void (*ObjectSlotCallback)(HeapObject** from, HeapObject* to);
     370             : 
     371             : enum ArrayStorageAllocationMode {
     372             :   DONT_INITIALIZE_ARRAY_ELEMENTS,
     373             :   INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE
     374             : };
     375             : 
     376             : enum class ClearRecordedSlots { kYes, kNo };
     377             : 
     378             : enum class GarbageCollectionReason {
     379             :   kUnknown = 0,
     380             :   kAllocationFailure = 1,
     381             :   kAllocationLimit = 2,
     382             :   kContextDisposal = 3,
     383             :   kCountersExtension = 4,
     384             :   kDebugger = 5,
     385             :   kDeserializer = 6,
     386             :   kExternalMemoryPressure = 7,
     387             :   kFinalizeMarkingViaStackGuard = 8,
     388             :   kFinalizeMarkingViaTask = 9,
     389             :   kFullHashtable = 10,
     390             :   kHeapProfiler = 11,
     391             :   kIdleTask = 12,
     392             :   kLastResort = 13,
     393             :   kLowMemoryNotification = 14,
     394             :   kMakeHeapIterable = 15,
     395             :   kMemoryPressure = 16,
     396             :   kMemoryReducer = 17,
     397             :   kRuntime = 18,
     398             :   kSamplingProfiler = 19,
     399             :   kSnapshotCreator = 20,
     400             :   kTesting = 21
     401             :   // If you add new items here, then update the incremental_marking_reason,
     402             :   // mark_compact_reason, and scavenge_reason counters in counters.h.
     403             :   // Also update src/tools/metrics/histograms/histograms.xml in chromium.
     404             : };
     405             : 
     406             : enum class YoungGenerationHandling {
     407             :   kRegularScavenge = 0,
     408             :   kFastPromotionDuringScavenge = 1,
     409             :   // Histogram::InspectConstructionArguments in chromium requires us to have at
     410             :   // least three buckets.
     411             :   kUnusedBucket = 2,
     412             :   // If you add new items here, then update the young_generation_handling in
     413             :   // counters.h.
     414             :   // Also update src/tools/metrics/histograms/histograms.xml in chromium.
     415             : };
     416             : 
     417             : // A queue of objects promoted during scavenge. Each object is accompanied by
     418             : // its size to avoid dereferencing a map pointer for scanning. The last page in
     419             : // to-space is used for the promotion queue. On conflict during scavenge, the
     420             : // promotion queue is allocated externally and all entries are copied to the
     421             : // external queue.
     422             : class PromotionQueue {
     423             :  public:
     424             :   explicit PromotionQueue(Heap* heap)
     425             :       : front_(nullptr),
     426             :         rear_(nullptr),
     427             :         limit_(nullptr),
     428             :         emergency_stack_(nullptr),
     429       60782 :         heap_(heap) {}
     430             : 
     431             :   void Initialize();
     432             :   void Destroy();
     433             : 
     434             :   inline void SetNewLimit(Address limit);
     435             :   inline bool IsBelowPromotionQueue(Address to_space_top);
     436             : 
     437             :   inline void insert(HeapObject* target, int32_t size, bool was_marked_black);
     438             :   inline void remove(HeapObject** target, int32_t* size,
     439             :                      bool* was_marked_black);
     440             : 
     441             :   bool is_empty() {
     442    48276782 :     return (front_ == rear_) &&
     443    23557684 :            (emergency_stack_ == nullptr || emergency_stack_->length() == 0);
     444             :   }
     445             : 
     446             :  private:
     447             :   struct Entry {
     448             :     Entry(HeapObject* obj, int32_t size, bool was_marked_black)
     449    10341098 :         : obj_(obj), size_(size), was_marked_black_(was_marked_black) {}
     450             : 
     451             :     HeapObject* obj_;
     452             :     int32_t size_ : 31;
     453             :     bool was_marked_black_ : 1;
     454             :   };
     455             : 
     456             :   inline Page* GetHeadPage();
     457             : 
     458             :   void RelocateQueueHead();
     459             : 
     460             :   // The front of the queue is higher in the memory page chain than the rear.
     461             :   struct Entry* front_;
     462             :   struct Entry* rear_;
     463             :   struct Entry* limit_;
     464             : 
     465             :   List<Entry>* emergency_stack_;
     466             :   Heap* heap_;
     467             : 
     468             :   DISALLOW_COPY_AND_ASSIGN(PromotionQueue);
     469             : };
     470             : 
     471             : class AllocationResult {
     472             :  public:
     473       67776 :   static inline AllocationResult Retry(AllocationSpace space = NEW_SPACE) {
     474       67776 :     return AllocationResult(space);
     475             :   }
     476             : 
     477             :   // Implicit constructor from Object*.
     478  1458524894 :   AllocationResult(Object* object)  // NOLINT
     479  1458524894 :       : object_(object) {
     480             :     // AllocationResults can't return Smis, which are used to represent
     481             :     // failure and the space to retry in.
     482  1458524894 :     CHECK(!object->IsSmi());
     483  1458524894 :   }
     484             : 
     485             :   AllocationResult() : object_(Smi::FromInt(NEW_SPACE)) {}
     486             : 
     487   876307406 :   inline bool IsRetry() { return object_->IsSmi(); }
     488             :   inline HeapObject* ToObjectChecked();
     489             :   inline AllocationSpace RetrySpace();
     490             : 
     491             :   template <typename T>
     492             :   bool To(T** obj) {
     493  2314809617 :     if (IsRetry()) return false;
     494    27873567 :     *obj = T::cast(object_);
     495             :     return true;
     496             :   }
     497             : 
     498             :  private:
     499             :   explicit AllocationResult(AllocationSpace space)
     500       73276 :       : object_(Smi::FromInt(static_cast<int>(space))) {}
     501             : 
     502             :   Object* object_;
     503             : };
     504             : 
     505             : STATIC_ASSERT(sizeof(AllocationResult) == kPointerSize);
     506             : 
     507             : #ifdef DEBUG
     508             : struct CommentStatistic {
     509             :   const char* comment;
     510             :   int size;
     511             :   int count;
     512             :   void Clear() {
     513             :     comment = NULL;
     514             :     size = 0;
     515             :     count = 0;
     516             :   }
     517             :   // Must be small, since an iteration is used for lookup.
     518             :   static const int kMaxComments = 64;
     519             : };
     520             : #endif
     521             : 
     522             : class NumberAndSizeInfo BASE_EMBEDDED {
     523             :  public:
     524    30029519 :   NumberAndSizeInfo() : number_(0), bytes_(0) {}
     525             : 
     526             :   int number() const { return number_; }
     527           0 :   void increment_number(int num) { number_ += num; }
     528             : 
     529             :   int bytes() const { return bytes_; }
     530           0 :   void increment_bytes(int size) { bytes_ += size; }
     531             : 
     532             :   void clear() {
     533           0 :     number_ = 0;
     534           0 :     bytes_ = 0;
     535             :   }
     536             : 
     537             :  private:
     538             :   int number_;
     539             :   int bytes_;
     540             : };
     541             : 
     542             : // HistogramInfo class for recording a single "bar" of a histogram.  This
     543             : // class is used for collecting statistics to print to the log file.
     544             : class HistogramInfo : public NumberAndSizeInfo {
     545             :  public:
     546    30029519 :   HistogramInfo() : NumberAndSizeInfo(), name_(nullptr) {}
     547             : 
     548             :   const char* name() { return name_; }
     549    17142498 :   void set_name(const char* name) { name_ = name; }
     550             : 
     551             :  private:
     552             :   const char* name_;
     553             : };
     554             : 
     555      118570 : class Heap {
     556             :  public:
     557             :   // Declare all the root indices.  This defines the root list order.
     558             :   enum RootListIndex {
     559             : #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex,
     560             :     STRONG_ROOT_LIST(ROOT_INDEX_DECLARATION)
     561             : #undef ROOT_INDEX_DECLARATION
     562             : 
     563             : #define STRING_INDEX_DECLARATION(name, str) k##name##RootIndex,
     564             :         INTERNALIZED_STRING_LIST(STRING_INDEX_DECLARATION)
     565             : #undef STRING_DECLARATION
     566             : 
     567             : #define SYMBOL_INDEX_DECLARATION(name) k##name##RootIndex,
     568             :             PRIVATE_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION)
     569             : #undef SYMBOL_INDEX_DECLARATION
     570             : 
     571             : #define SYMBOL_INDEX_DECLARATION(name, description) k##name##RootIndex,
     572             :                 PUBLIC_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION)
     573             :                     WELL_KNOWN_SYMBOL_LIST(SYMBOL_INDEX_DECLARATION)
     574             : #undef SYMBOL_INDEX_DECLARATION
     575             : 
     576             : // Utility type maps
     577             : #define DECLARE_STRUCT_MAP(NAME, Name, name) k##Name##MapRootIndex,
     578             :                         STRUCT_LIST(DECLARE_STRUCT_MAP)
     579             : #undef DECLARE_STRUCT_MAP
     580             :                             kStringTableRootIndex,
     581             : 
     582             : #define ROOT_INDEX_DECLARATION(type, name, camel_name) k##camel_name##RootIndex,
     583             :     SMI_ROOT_LIST(ROOT_INDEX_DECLARATION)
     584             : #undef ROOT_INDEX_DECLARATION
     585             :         kRootListLength,
     586             :     kStrongRootListLength = kStringTableRootIndex,
     587             :     kSmiRootsStart = kStringTableRootIndex + 1
     588             :   };
     589             : 
     590             :   enum FindMementoMode { kForRuntime, kForGC };
     591             : 
     592             :   enum HeapState { NOT_IN_GC, SCAVENGE, MARK_COMPACT, MINOR_MARK_COMPACT };
     593             : 
     594             :   enum UpdateAllocationSiteMode { kGlobal, kCached };
     595             : 
     596             :   // Taking this lock prevents the GC from entering a phase that relocates
     597             :   // object references.
     598             :   class RelocationLock {
     599             :    public:
     600             :     explicit RelocationLock(Heap* heap) : heap_(heap) {
     601      122535 :       heap_->relocation_mutex_.Lock();
     602             :     }
     603             : 
     604      122535 :     ~RelocationLock() { heap_->relocation_mutex_.Unlock(); }
     605             : 
     606             :    private:
     607             :     Heap* heap_;
     608             :   };
     609             : 
     610             :   // Support for partial snapshots.  After calling this we have a linear
     611             :   // space to write objects in each space.
     612             :   struct Chunk {
     613             :     uint32_t size;
     614             :     Address start;
     615             :     Address end;
     616             :   };
     617             :   typedef List<Chunk> Reservation;
     618             : 
     619             :   static const int kInitalOldGenerationLimitFactor = 2;
     620             : 
     621             : #if V8_OS_ANDROID
     622             :   // Don't apply pointer multiplier on Android since it has no swap space and
     623             :   // should instead adapt it's heap size based on available physical memory.
     624             :   static const int kPointerMultiplier = 1;
     625             : #else
     626             :   static const int kPointerMultiplier = i::kPointerSize / 4;
     627             : #endif
     628             : 
     629             :   // The new space size has to be a power of 2. Sizes are in MB.
     630             :   static const int kMaxSemiSpaceSizeLowMemoryDevice = 1 * kPointerMultiplier;
     631             :   static const int kMaxSemiSpaceSizeMediumMemoryDevice = 4 * kPointerMultiplier;
     632             :   static const int kMaxSemiSpaceSizeHighMemoryDevice = 8 * kPointerMultiplier;
     633             :   static const int kMaxSemiSpaceSizeHugeMemoryDevice = 8 * kPointerMultiplier;
     634             : 
     635             :   // The old space size has to be a multiple of Page::kPageSize.
     636             :   // Sizes are in MB.
     637             :   static const int kMaxOldSpaceSizeLowMemoryDevice = 128 * kPointerMultiplier;
     638             :   static const int kMaxOldSpaceSizeMediumMemoryDevice =
     639             :       256 * kPointerMultiplier;
     640             :   static const int kMaxOldSpaceSizeHighMemoryDevice = 512 * kPointerMultiplier;
     641             :   static const int kMaxOldSpaceSizeHugeMemoryDevice = 1024 * kPointerMultiplier;
     642             : 
     643             :   // The executable size has to be a multiple of Page::kPageSize.
     644             :   // Sizes are in MB.
     645             :   static const int kMaxExecutableSizeLowMemoryDevice = 96 * kPointerMultiplier;
     646             :   static const int kMaxExecutableSizeMediumMemoryDevice =
     647             :       192 * kPointerMultiplier;
     648             :   static const int kMaxExecutableSizeHighMemoryDevice =
     649             :       256 * kPointerMultiplier;
     650             :   static const int kMaxExecutableSizeHugeMemoryDevice =
     651             :       256 * kPointerMultiplier;
     652             : 
     653             :   static const int kTraceRingBufferSize = 512;
     654             :   static const int kStacktraceBufferSize = 512;
     655             : 
     656             :   V8_EXPORT_PRIVATE static const double kMinHeapGrowingFactor;
     657             :   V8_EXPORT_PRIVATE static const double kMaxHeapGrowingFactor;
     658             :   static const double kMaxHeapGrowingFactorMemoryConstrained;
     659             :   static const double kMaxHeapGrowingFactorIdle;
     660             :   static const double kConservativeHeapGrowingFactor;
     661             :   static const double kTargetMutatorUtilization;
     662             : 
     663             :   static const int kNoGCFlags = 0;
     664             :   static const int kReduceMemoryFootprintMask = 1;
     665             :   static const int kAbortIncrementalMarkingMask = 2;
     666             :   static const int kFinalizeIncrementalMarkingMask = 4;
     667             : 
     668             :   // Making the heap iterable requires us to abort incremental marking.
     669             :   static const int kMakeHeapIterableMask = kAbortIncrementalMarkingMask;
     670             : 
     671             :   // The roots that have an index less than this are always in old space.
     672             :   static const int kOldSpaceRoots = 0x20;
     673             : 
     674             :   // The minimum size of a HeapObject on the heap.
     675             :   static const int kMinObjectSizeInWords = 2;
     676             : 
     677             :   static const int kMinPromotedPercentForFastPromotionMode = 90;
     678             : 
     679             :   STATIC_ASSERT(kUndefinedValueRootIndex ==
     680             :                 Internals::kUndefinedValueRootIndex);
     681             :   STATIC_ASSERT(kTheHoleValueRootIndex == Internals::kTheHoleValueRootIndex);
     682             :   STATIC_ASSERT(kNullValueRootIndex == Internals::kNullValueRootIndex);
     683             :   STATIC_ASSERT(kTrueValueRootIndex == Internals::kTrueValueRootIndex);
     684             :   STATIC_ASSERT(kFalseValueRootIndex == Internals::kFalseValueRootIndex);
     685             :   STATIC_ASSERT(kempty_stringRootIndex == Internals::kEmptyStringRootIndex);
     686             : 
     687             :   // Calculates the maximum amount of filler that could be required by the
     688             :   // given alignment.
     689             :   static int GetMaximumFillToAlign(AllocationAlignment alignment);
     690             :   // Calculates the actual amount of filler required for a given address at the
     691             :   // given alignment.
     692             :   static int GetFillToAlign(Address address, AllocationAlignment alignment);
     693             : 
     694             :   template <typename T>
     695             :   static inline bool IsOneByte(T t, int chars);
     696             : 
     697             :   static void FatalProcessOutOfMemory(const char* location,
     698             :                                       bool is_heap_oom = false);
     699             : 
     700             :   V8_EXPORT_PRIVATE static bool RootIsImmortalImmovable(int root_index);
     701             : 
     702             :   // Checks whether the space is valid.
     703             :   static bool IsValidAllocationSpace(AllocationSpace space);
     704             : 
     705             :   // Generated code can embed direct references to non-writable roots if
     706             :   // they are in new space.
     707             :   static bool RootCanBeWrittenAfterInitialization(RootListIndex root_index);
     708             : 
     709             :   static bool IsUnmodifiedHeapObject(Object** p);
     710             : 
     711             :   // Zapping is needed for verify heap, and always done in debug builds.
     712             :   static inline bool ShouldZapGarbage() {
     713             : #ifdef DEBUG
     714             :     return true;
     715             : #else
     716             : #ifdef VERIFY_HEAP
     717             :     return FLAG_verify_heap;
     718             : #else
     719             :     return false;
     720             : #endif
     721             : #endif
     722             :   }
     723             : 
     724             :   static inline bool IsYoungGenerationCollector(GarbageCollector collector) {
     725      612647 :     return collector == SCAVENGER || collector == MINOR_MARK_COMPACTOR;
     726             :   }
     727             : 
     728             :   static inline GarbageCollector YoungGenerationCollector() {
     729       69189 :     return (FLAG_minor_mc) ? MINOR_MARK_COMPACTOR : SCAVENGER;
     730             :   }
     731             : 
     732             :   static inline const char* CollectorName(GarbageCollector collector) {
     733             :     switch (collector) {
     734             :       case SCAVENGER:
     735             :         return "Scavenger";
     736             :       case MARK_COMPACTOR:
     737             :         return "Mark-Compact";
     738             :       case MINOR_MARK_COMPACTOR:
     739             :         return "Minor Mark-Compact";
     740             :     }
     741             :     return "Unknown collector";
     742             :   }
     743             : 
     744             :   V8_EXPORT_PRIVATE static double HeapGrowingFactor(double gc_speed,
     745             :                                                     double mutator_speed);
     746             : 
     747             :   // Copy block of memory from src to dst. Size of block should be aligned
     748             :   // by pointer size.
     749             :   static inline void CopyBlock(Address dst, Address src, int byte_size);
     750             : 
     751             :   // Determines a static visitor id based on the given {map} that can then be
     752             :   // stored on the map to facilitate fast dispatch for {StaticVisitorBase}.
     753             :   static int GetStaticVisitorIdForMap(Map* map);
     754             : 
     755             :   // Notifies the heap that is ok to start marking or other activities that
     756             :   // should not happen during deserialization.
     757             :   void NotifyDeserializationComplete();
     758             : 
     759             :   inline Address* NewSpaceAllocationTopAddress();
     760             :   inline Address* NewSpaceAllocationLimitAddress();
     761             :   inline Address* OldSpaceAllocationTopAddress();
     762             :   inline Address* OldSpaceAllocationLimitAddress();
     763             : 
     764             :   // Clear the Instanceof cache (used when a prototype changes).
     765             :   inline void ClearInstanceofCache();
     766             : 
     767             :   // FreeSpace objects have a null map after deserialization. Update the map.
     768             :   void RepairFreeListsAfterDeserialization();
     769             : 
     770             :   // Move len elements within a given array from src_index index to dst_index
     771             :   // index.
     772             :   void MoveElements(FixedArray* array, int dst_index, int src_index, int len);
     773             : 
     774             :   // Initialize a filler object to keep the ability to iterate over the heap
     775             :   // when introducing gaps within pages. If slots could have been recorded in
     776             :   // the freed area, then pass ClearRecordedSlots::kYes as the mode. Otherwise,
     777             :   // pass ClearRecordedSlots::kNo.
     778             :   V8_EXPORT_PRIVATE HeapObject* CreateFillerObjectAt(Address addr, int size,
     779             :                                                      ClearRecordedSlots mode);
     780             : 
     781             :   bool CanMoveObjectStart(HeapObject* object);
     782             : 
     783             :   static bool IsImmovable(HeapObject* object);
     784             : 
     785             :   // Maintain consistency of live bytes during incremental marking.
     786             :   void AdjustLiveBytes(HeapObject* object, int by);
     787             : 
     788             :   // Trim the given array from the left. Note that this relocates the object
     789             :   // start and hence is only valid if there is only a single reference to it.
     790             :   FixedArrayBase* LeftTrimFixedArray(FixedArrayBase* obj, int elements_to_trim);
     791             : 
     792             :   // Trim the given array from the right.
     793             :   void RightTrimFixedArray(FixedArrayBase* obj, int elements_to_trim);
     794             : 
     795             :   // Converts the given boolean condition to JavaScript boolean value.
     796             :   inline Oddball* ToBoolean(bool condition);
     797             : 
     798             :   // Notify the heap that a context has been disposed.
     799             :   int NotifyContextDisposed(bool dependant_context);
     800             : 
     801             :   void set_native_contexts_list(Object* object) {
     802      404372 :     native_contexts_list_ = object;
     803             :   }
     804             :   Object* native_contexts_list() const { return native_contexts_list_; }
     805             : 
     806             :   void set_allocation_sites_list(Object* object) {
     807     1821116 :     allocation_sites_list_ = object;
     808             :   }
     809             :   Object* allocation_sites_list() { return allocation_sites_list_; }
     810             : 
     811             :   // Used in CreateAllocationSiteStub and the (de)serializer.
     812             :   Object** allocation_sites_list_address() { return &allocation_sites_list_; }
     813             : 
     814        2215 :   void set_encountered_weak_collections(Object* weak_collection) {
     815      116395 :     encountered_weak_collections_ = weak_collection;
     816        2215 :   }
     817        2215 :   Object* encountered_weak_collections() const {
     818        2215 :     return encountered_weak_collections_;
     819             :   }
     820             :   void IterateEncounteredWeakCollections(RootVisitor* visitor);
     821             : 
     822    54233828 :   void set_encountered_weak_cells(Object* weak_cell) {
     823    54349010 :     encountered_weak_cells_ = weak_cell;
     824    54233828 :   }
     825    54233827 :   Object* encountered_weak_cells() const { return encountered_weak_cells_; }
     826             : 
     827      878783 :   void set_encountered_transition_arrays(Object* transition_array) {
     828      993101 :     encountered_transition_arrays_ = transition_array;
     829      878783 :   }
     830      878783 :   Object* encountered_transition_arrays() const {
     831      878783 :     return encountered_transition_arrays_;
     832             :   }
     833             : 
     834             :   // Number of mark-sweeps.
     835        6181 :   int ms_count() const { return ms_count_; }
     836             : 
     837             :   // Checks whether the given object is allowed to be migrated from it's
     838             :   // current space into the given destination space. Used for debugging.
     839             :   inline bool AllowedToBeMigrated(HeapObject* object, AllocationSpace dest);
     840             : 
     841             :   void CheckHandleCount();
     842             : 
     843             :   // Number of "runtime allocations" done so far.
     844             :   uint32_t allocations_count() { return allocations_count_; }
     845             : 
     846             :   // Print short heap statistics.
     847             :   void PrintShortHeapStatistics();
     848             : 
     849             :   inline HeapState gc_state() { return gc_state_; }
     850             :   void SetGCState(HeapState state);
     851             : 
     852             :   inline bool IsInGCPostProcessing() { return gc_post_processing_depth_ > 0; }
     853             : 
     854             :   // If an object has an AllocationMemento trailing it, return it, otherwise
     855             :   // return NULL;
     856             :   template <FindMementoMode mode>
     857             :   inline AllocationMemento* FindAllocationMemento(HeapObject* object);
     858             : 
     859             :   // Returns false if not able to reserve.
     860             :   bool ReserveSpace(Reservation* reservations, List<Address>* maps);
     861             : 
     862             :   //
     863             :   // Support for the API.
     864             :   //
     865             : 
     866             :   bool CreateApiObjects();
     867             : 
     868             :   // Implements the corresponding V8 API function.
     869             :   bool IdleNotification(double deadline_in_seconds);
     870             :   bool IdleNotification(int idle_time_in_ms);
     871             : 
     872             :   void MemoryPressureNotification(MemoryPressureLevel level,
     873             :                                   bool is_isolate_locked);
     874             :   void CheckMemoryPressure();
     875             : 
     876             :   void SetOutOfMemoryCallback(v8::debug::OutOfMemoryCallback callback,
     877             :                               void* data);
     878             : 
     879             :   double MonotonicallyIncreasingTimeInMs();
     880             : 
     881             :   void RecordStats(HeapStats* stats, bool take_snapshot = false);
     882             : 
     883             :   // Check new space expansion criteria and expand semispaces if it was hit.
     884             :   void CheckNewSpaceExpansionCriteria();
     885             : 
     886             :   void VisitExternalResources(v8::ExternalResourceVisitor* visitor);
     887             : 
     888             :   // An object should be promoted if the object has survived a
     889             :   // scavenge operation.
     890             :   inline bool ShouldBePromoted(Address old_address, int object_size);
     891             : 
     892             :   void ClearNormalizedMapCaches();
     893             : 
     894             :   void IncrementDeferredCount(v8::Isolate::UseCounterFeature feature);
     895             : 
     896             :   // Completely clear the Instanceof cache (to stop it keeping objects alive
     897             :   // around a GC).
     898             :   inline void CompletelyClearInstanceofCache();
     899             : 
     900             :   inline uint32_t HashSeed();
     901             : 
     902             :   inline int NextScriptId();
     903             : 
     904             :   inline void SetArgumentsAdaptorDeoptPCOffset(int pc_offset);
     905             :   inline void SetConstructStubCreateDeoptPCOffset(int pc_offset);
     906             :   inline void SetConstructStubInvokeDeoptPCOffset(int pc_offset);
     907             :   inline void SetGetterStubDeoptPCOffset(int pc_offset);
     908             :   inline void SetSetterStubDeoptPCOffset(int pc_offset);
     909             :   inline void SetInterpreterEntryReturnPCOffset(int pc_offset);
     910             :   inline int GetNextTemplateSerialNumber();
     911             : 
     912             :   inline void SetSerializedTemplates(FixedArray* templates);
     913             :   inline void SetSerializedGlobalProxySizes(FixedArray* sizes);
     914             : 
     915             :   // For post mortem debugging.
     916             :   void RememberUnmappedPage(Address page, bool compacted);
     917             : 
     918             :   // Global inline caching age: it is incremented on some GCs after context
     919             :   // disposal. We use it to flush inline caches.
     920    56411323 :   int global_ic_age() { return global_ic_age_; }
     921             : 
     922             :   void AgeInlineCaches() {
     923        5720 :     global_ic_age_ = (global_ic_age_ + 1) & SharedFunctionInfo::ICAgeBits::kMax;
     924             :   }
     925             : 
     926             :   int64_t external_memory_hard_limit() { return MaxOldGenerationSize() / 2; }
     927             : 
     928             :   int64_t external_memory() { return external_memory_; }
     929        3468 :   void update_external_memory(int64_t delta) { external_memory_ += delta; }
     930             : 
     931             :   void update_external_memory_concurrently_freed(intptr_t freed) {
     932             :     external_memory_concurrently_freed_.Increment(freed);
     933             :   }
     934             : 
     935      122535 :   void account_external_memory_concurrently_freed() {
     936      122535 :     external_memory_ -= external_memory_concurrently_freed_.Value();
     937             :     external_memory_concurrently_freed_.SetValue(0);
     938      122535 :   }
     939             : 
     940             :   void DeoptMarkedAllocationSites();
     941             : 
     942             :   inline bool DeoptMaybeTenuredAllocationSites();
     943             : 
     944             :   void AddWeakNewSpaceObjectToCodeDependency(Handle<HeapObject> obj,
     945             :                                              Handle<WeakCell> code);
     946             : 
     947             :   void AddWeakObjectToCodeDependency(Handle<HeapObject> obj,
     948             :                                      Handle<DependentCode> dep);
     949             : 
     950             :   DependentCode* LookupWeakObjectToCodeDependency(Handle<HeapObject> obj);
     951             : 
     952             :   void CompactWeakFixedArrays();
     953             : 
     954             :   void AddRetainedMap(Handle<Map> map);
     955             : 
     956             :   // This event is triggered after successful allocation of a new object made
     957             :   // by runtime. Allocations of target space for object evacuation do not
     958             :   // trigger the event. In order to track ALL allocations one must turn off
     959             :   // FLAG_inline_new and FLAG_use_allocation_folding.
     960             :   inline void OnAllocationEvent(HeapObject* object, int size_in_bytes);
     961             : 
     962             :   // This event is triggered after object is moved to a new place.
     963             :   inline void OnMoveEvent(HeapObject* target, HeapObject* source,
     964             :                           int size_in_bytes);
     965             : 
     966             :   bool deserialization_complete() const { return deserialization_complete_; }
     967             : 
     968             :   bool HasLowAllocationRate();
     969             :   bool HasHighFragmentation();
     970             :   bool HasHighFragmentation(size_t used, size_t committed);
     971             : 
     972             :   void ActivateMemoryReducerIfNeeded();
     973             : 
     974             :   bool ShouldOptimizeForMemoryUsage();
     975             : 
     976             :   bool IsLowMemoryDevice() {
     977             :     return max_old_generation_size_ <= kMaxOldSpaceSizeLowMemoryDevice;
     978             :   }
     979             : 
     980             :   bool IsMemoryConstrainedDevice() {
     981             :     return max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice;
     982             :   }
     983             : 
     984      400436 :   bool HighMemoryPressure() {
     985      400436 :     return memory_pressure_level_.Value() != MemoryPressureLevel::kNone;
     986             :   }
     987             : 
     988             :   size_t HeapLimitForDebugging() {
     989             :     const size_t kDebugHeapSizeFactor = 4;
     990             :     size_t max_limit = std::numeric_limits<size_t>::max() / 4;
     991             :     return Min(max_limit,
     992          36 :                initial_max_old_generation_size_ * kDebugHeapSizeFactor);
     993             :   }
     994             : 
     995          18 :   void IncreaseHeapLimitForDebugging() {
     996             :     max_old_generation_size_ =
     997          36 :         Max(max_old_generation_size_, HeapLimitForDebugging());
     998             :   }
     999             : 
    1000        4321 :   void RestoreOriginalHeapLimit() {
    1001             :     // Do not set the limit lower than the live size + some slack.
    1002        4321 :     size_t min_limit = SizeOfObjects() + SizeOfObjects() / 4;
    1003             :     max_old_generation_size_ =
    1004             :         Min(max_old_generation_size_,
    1005       12963 :             Max(initial_max_old_generation_size_, min_limit));
    1006        4321 :   }
    1007             : 
    1008          18 :   bool IsHeapLimitIncreasedForDebugging() {
    1009          36 :     return max_old_generation_size_ == HeapLimitForDebugging();
    1010             :   }
    1011             : 
    1012             :   // ===========================================================================
    1013             :   // Initialization. ===========================================================
    1014             :   // ===========================================================================
    1015             : 
    1016             :   // Configure heap size in MB before setup. Return false if the heap has been
    1017             :   // set up already.
    1018             :   bool ConfigureHeap(size_t max_semi_space_size, size_t max_old_space_size,
    1019             :                      size_t max_executable_size, size_t code_range_size);
    1020             :   bool ConfigureHeapDefault();
    1021             : 
    1022             :   // Prepares the heap, setting up memory areas that are needed in the isolate
    1023             :   // without actually creating any objects.
    1024             :   bool SetUp();
    1025             : 
    1026             :   // Bootstraps the object heap with the core set of objects required to run.
    1027             :   // Returns whether it succeeded.
    1028             :   bool CreateHeapObjects();
    1029             : 
    1030             :   // Create ObjectStats if live_object_stats_ or dead_object_stats_ are nullptr.
    1031             :   V8_INLINE void CreateObjectStats();
    1032             : 
    1033             :   // Destroys all memory allocated by the heap.
    1034             :   void TearDown();
    1035             : 
    1036             :   // Returns whether SetUp has been called.
    1037             :   bool HasBeenSetUp();
    1038             : 
    1039             :   // ===========================================================================
    1040             :   // Getters for spaces. =======================================================
    1041             :   // ===========================================================================
    1042             : 
    1043             :   inline Address NewSpaceTop();
    1044             : 
    1045             :   NewSpace* new_space() { return new_space_; }
    1046             :   OldSpace* old_space() { return old_space_; }
    1047             :   OldSpace* code_space() { return code_space_; }
    1048             :   MapSpace* map_space() { return map_space_; }
    1049             :   LargeObjectSpace* lo_space() { return lo_space_; }
    1050             : 
    1051             :   inline PagedSpace* paged_space(int idx);
    1052             :   inline Space* space(int idx);
    1053             : 
    1054             :   // Returns name of the space.
    1055             :   const char* GetSpaceName(int idx);
    1056             : 
    1057             :   // ===========================================================================
    1058             :   // Getters to other components. ==============================================
    1059             :   // ===========================================================================
    1060             : 
    1061             :   GCTracer* tracer() { return tracer_; }
    1062             : 
    1063             :   MemoryAllocator* memory_allocator() { return memory_allocator_; }
    1064             : 
    1065             :   PromotionQueue* promotion_queue() { return &promotion_queue_; }
    1066             : 
    1067             :   inline Isolate* isolate();
    1068             : 
    1069  1603834141 :   MarkCompactCollector* mark_compact_collector() {
    1070  1603834141 :     return mark_compact_collector_;
    1071             :   }
    1072             : 
    1073             :   MinorMarkCompactCollector* minor_mark_compact_collector() {
    1074             :     return minor_mark_compact_collector_;
    1075             :   }
    1076             : 
    1077             :   // ===========================================================================
    1078             :   // Root set access. ==========================================================
    1079             :   // ===========================================================================
    1080             : 
    1081             :   // Heap root getters.
    1082             : #define ROOT_ACCESSOR(type, name, camel_name) inline type* name();
    1083             :   ROOT_LIST(ROOT_ACCESSOR)
    1084             : #undef ROOT_ACCESSOR
    1085             : 
    1086             :   // Utility type maps.
    1087             : #define STRUCT_MAP_ACCESSOR(NAME, Name, name) inline Map* name##_map();
    1088             :   STRUCT_LIST(STRUCT_MAP_ACCESSOR)
    1089             : #undef STRUCT_MAP_ACCESSOR
    1090             : 
    1091             : #define STRING_ACCESSOR(name, str) inline String* name();
    1092             :   INTERNALIZED_STRING_LIST(STRING_ACCESSOR)
    1093             : #undef STRING_ACCESSOR
    1094             : 
    1095             : #define SYMBOL_ACCESSOR(name) inline Symbol* name();
    1096             :   PRIVATE_SYMBOL_LIST(SYMBOL_ACCESSOR)
    1097             : #undef SYMBOL_ACCESSOR
    1098             : 
    1099             : #define SYMBOL_ACCESSOR(name, description) inline Symbol* name();
    1100             :   PUBLIC_SYMBOL_LIST(SYMBOL_ACCESSOR)
    1101             :   WELL_KNOWN_SYMBOL_LIST(SYMBOL_ACCESSOR)
    1102             : #undef SYMBOL_ACCESSOR
    1103             : 
    1104  1803643965 :   Object* root(RootListIndex index) { return roots_[index]; }
    1105             :   Handle<Object> root_handle(RootListIndex index) {
    1106    15925897 :     return Handle<Object>(&roots_[index]);
    1107             :   }
    1108             :   template <typename T>
    1109             :   bool IsRootHandle(Handle<T> handle, RootListIndex* index) const {
    1110             :     Object** const handle_location = bit_cast<Object**>(handle.address());
    1111     6136899 :     if (handle_location >= &roots_[kRootListLength]) return false;
    1112     2002051 :     if (handle_location < &roots_[0]) return false;
    1113     2001895 :     *index = static_cast<RootListIndex>(handle_location - &roots_[0]);
    1114             :     return true;
    1115             :   }
    1116             : 
    1117             :   // Generated code can embed this address to get access to the roots.
    1118             :   Object** roots_array_start() { return roots_; }
    1119             : 
    1120             :   // Sets the stub_cache_ (only used when expanding the dictionary).
    1121             :   void SetRootCodeStubs(UnseededNumberDictionary* value);
    1122             : 
    1123             :   void SetRootMaterializedObjects(FixedArray* objects) {
    1124          44 :     roots_[kMaterializedObjectsRootIndex] = objects;
    1125             :   }
    1126             : 
    1127             :   void SetRootScriptList(Object* value) {
    1128         373 :     roots_[kScriptListRootIndex] = value;
    1129             :   }
    1130             : 
    1131             :   void SetRootStringTable(StringTable* value) {
    1132    13112229 :     roots_[kStringTableRootIndex] = value;
    1133             :   }
    1134             : 
    1135             :   void SetRootNoScriptSharedFunctionInfos(Object* value) {
    1136        8565 :     roots_[kNoScriptSharedFunctionInfosRootIndex] = value;
    1137             :   }
    1138             : 
    1139             :   void SetMessageListeners(TemplateList* value) {
    1140       29556 :     roots_[kMessageListenersRootIndex] = value;
    1141             :   }
    1142             : 
    1143             :   // Set the stack limit in the roots_ array.  Some architectures generate
    1144             :   // code that looks here, because it is faster than loading from the static
    1145             :   // jslimit_/real_jslimit_ variable in the StackGuard.
    1146             :   void SetStackLimits();
    1147             : 
    1148             :   // The stack limit is thread-dependent. To be able to reproduce the same
    1149             :   // snapshot blob, we need to reset it before serializing.
    1150             :   void ClearStackLimits();
    1151             : 
    1152             :   // Generated code can treat direct references to this root as constant.
    1153             :   bool RootCanBeTreatedAsConstant(RootListIndex root_index);
    1154             : 
    1155             :   Map* MapForFixedTypedArray(ExternalArrayType array_type);
    1156             :   RootListIndex RootIndexForFixedTypedArray(ExternalArrayType array_type);
    1157             : 
    1158             :   RootListIndex RootIndexForEmptyFixedTypedArray(ElementsKind kind);
    1159             :   FixedTypedArrayBase* EmptyFixedTypedArrayForMap(Map* map);
    1160             : 
    1161             :   void RegisterStrongRoots(Object** start, Object** end);
    1162             :   void UnregisterStrongRoots(Object** start);
    1163             : 
    1164             :   // ===========================================================================
    1165             :   // Inline allocation. ========================================================
    1166             :   // ===========================================================================
    1167             : 
    1168             :   // Indicates whether inline bump-pointer allocation has been disabled.
    1169             :   bool inline_allocation_disabled() { return inline_allocation_disabled_; }
    1170             : 
    1171             :   // Switch whether inline bump-pointer allocation should be used.
    1172             :   void EnableInlineAllocation();
    1173             :   void DisableInlineAllocation();
    1174             : 
    1175             :   // ===========================================================================
    1176             :   // Methods triggering GCs. ===================================================
    1177             :   // ===========================================================================
    1178             : 
    1179             :   // Performs garbage collection operation.
    1180             :   // Returns whether there is a chance that another major GC could
    1181             :   // collect more garbage.
    1182             :   inline bool CollectGarbage(
    1183             :       AllocationSpace space, GarbageCollectionReason gc_reason,
    1184             :       const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
    1185             : 
    1186             :   // Performs a full garbage collection.  If (flags & kMakeHeapIterableMask) is
    1187             :   // non-zero, then the slower precise sweeper is used, which leaves the heap
    1188             :   // in a state where we can iterate over the heap visiting all objects.
    1189             :   void CollectAllGarbage(
    1190             :       int flags, GarbageCollectionReason gc_reason,
    1191             :       const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
    1192             : 
    1193             :   // Last hope GC, should try to squeeze as much as possible.
    1194             :   void CollectAllAvailableGarbage(GarbageCollectionReason gc_reason);
    1195             : 
    1196             :   // Reports and external memory pressure event, either performs a major GC or
    1197             :   // completes incremental marking in order to free external resources.
    1198             :   void ReportExternalMemoryPressure();
    1199             : 
    1200             :   // Invoked when GC was requested via the stack guard.
    1201             :   void HandleGCRequest();
    1202             : 
    1203             :   // ===========================================================================
    1204             :   // Iterators. ================================================================
    1205             :   // ===========================================================================
    1206             : 
    1207             :   // Iterates over all roots in the heap.
    1208             :   void IterateRoots(RootVisitor* v, VisitMode mode);
    1209             :   // Iterates over all strong roots in the heap.
    1210             :   void IterateStrongRoots(RootVisitor* v, VisitMode mode);
    1211             :   // Iterates over entries in the smi roots list.  Only interesting to the
    1212             :   // serializer/deserializer, since GC does not care about smis.
    1213             :   void IterateSmiRoots(RootVisitor* v);
    1214             :   // Iterates over all the other roots in the heap.
    1215             :   void IterateWeakRoots(RootVisitor* v, VisitMode mode);
    1216             : 
    1217             :   // Iterate pointers of promoted objects.
    1218             :   void IterateAndScavengePromotedObject(HeapObject* target, int size,
    1219             :                                         bool was_marked_black);
    1220             : 
    1221             :   // ===========================================================================
    1222             :   // Store buffer API. =========================================================
    1223             :   // ===========================================================================
    1224             : 
    1225             :   // Write barrier support for object[offset] = o;
    1226             :   inline void RecordWrite(Object* object, int offset, Object* o);
    1227             :   inline void RecordWriteIntoCode(Code* host, RelocInfo* rinfo, Object* target);
    1228             :   void RecordWriteIntoCodeSlow(Code* host, RelocInfo* rinfo, Object* target);
    1229             :   void RecordWritesIntoCode(Code* code);
    1230             :   inline void RecordFixedArrayElements(FixedArray* array, int offset,
    1231             :                                        int length);
    1232             : 
    1233             :   inline Address* store_buffer_top_address();
    1234             : 
    1235             :   void ClearRecordedSlot(HeapObject* object, Object** slot);
    1236             :   void ClearRecordedSlotRange(Address start, Address end);
    1237             : 
    1238             :   bool HasRecordedSlot(HeapObject* object, Object** slot);
    1239             : 
    1240             :   // ===========================================================================
    1241             :   // Incremental marking API. ==================================================
    1242             :   // ===========================================================================
    1243             : 
    1244             :   // Start incremental marking and ensure that idle time handler can perform
    1245             :   // incremental steps.
    1246             :   void StartIdleIncrementalMarking(GarbageCollectionReason gc_reason);
    1247             : 
    1248             :   // Starts incremental marking assuming incremental marking is currently
    1249             :   // stopped.
    1250             :   void StartIncrementalMarking(
    1251             :       int gc_flags, GarbageCollectionReason gc_reason,
    1252             :       GCCallbackFlags gc_callback_flags = GCCallbackFlags::kNoGCCallbackFlags);
    1253             : 
    1254             :   void StartIncrementalMarkingIfAllocationLimitIsReached(
    1255             :       int gc_flags,
    1256             :       GCCallbackFlags gc_callback_flags = GCCallbackFlags::kNoGCCallbackFlags);
    1257             : 
    1258             :   void FinalizeIncrementalMarkingIfComplete(GarbageCollectionReason gc_reason);
    1259             : 
    1260             :   bool TryFinalizeIdleIncrementalMarking(double idle_time_in_ms,
    1261             :                                          GarbageCollectionReason gc_reason);
    1262             : 
    1263             :   void RegisterReservationsForBlackAllocation(Reservation* reservations);
    1264             : 
    1265    16286831 :   IncrementalMarking* incremental_marking() { return incremental_marking_; }
    1266             : 
    1267             :   // ===========================================================================
    1268             :   // Concurrent marking API. ===================================================
    1269             :   // ===========================================================================
    1270             : 
    1271             :   ConcurrentMarking* concurrent_marking() { return concurrent_marking_; }
    1272             : 
    1273             :   // The runtime uses this function to notify potentially unsafe object layout
    1274             :   // changes that require special synchronization with the concurrent marker.
    1275             :   // A layout change is unsafe if
    1276             :   // - it removes a tagged in-object field.
    1277             :   // - it replaces a tagged in-objects field with an untagged in-object field.
    1278             :   void NotifyObjectLayoutChange(HeapObject* object,
    1279             :                                 const DisallowHeapAllocation&);
    1280             : #ifdef VERIFY_HEAP
    1281             :   // This function checks that either
    1282             :   // - the map transition is safe,
    1283             :   // - or it was communicated to GC using NotifyObjectLayoutChange.
    1284             :   void VerifyObjectLayoutChange(HeapObject* object, Map* new_map);
    1285             : #endif
    1286             : 
    1287             :   // ===========================================================================
    1288             :   // Embedder heap tracer support. =============================================
    1289             :   // ===========================================================================
    1290             : 
    1291      395954 :   LocalEmbedderHeapTracer* local_embedder_heap_tracer() {
    1292      395954 :     return local_embedder_heap_tracer_;
    1293             :   }
    1294             :   void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
    1295             :   void TracePossibleWrapper(JSObject* js_object);
    1296             :   void RegisterExternallyReferencedObject(Object** object);
    1297             : 
    1298             :   // ===========================================================================
    1299             :   // External string table API. ================================================
    1300             :   // ===========================================================================
    1301             : 
    1302             :   // Registers an external string.
    1303             :   inline void RegisterExternalString(String* string);
    1304             : 
    1305             :   // Finalizes an external string by deleting the associated external
    1306             :   // data and clearing the resource pointer.
    1307             :   inline void FinalizeExternalString(String* string);
    1308             : 
    1309             :   // ===========================================================================
    1310             :   // Methods checking/returning the space of a given object/address. ===========
    1311             :   // ===========================================================================
    1312             : 
    1313             :   // Returns whether the object resides in new space.
    1314             :   inline bool InNewSpace(Object* object);
    1315             :   inline bool InFromSpace(Object* object);
    1316             :   inline bool InToSpace(Object* object);
    1317             : 
    1318             :   // Returns whether the object resides in old space.
    1319             :   inline bool InOldSpace(Object* object);
    1320             : 
    1321             :   // Checks whether an address/object in the heap (including auxiliary
    1322             :   // area and unused area).
    1323             :   bool Contains(HeapObject* value);
    1324             : 
    1325             :   // Checks whether an address/object in a space.
    1326             :   // Currently used by tests, serialization and heap verification only.
    1327             :   bool InSpace(HeapObject* value, AllocationSpace space);
    1328             : 
    1329             :   // Slow methods that can be used for verification as they can also be used
    1330             :   // with off-heap Addresses.
    1331             :   bool ContainsSlow(Address addr);
    1332             :   bool InSpaceSlow(Address addr, AllocationSpace space);
    1333             :   inline bool InNewSpaceSlow(Address address);
    1334             :   inline bool InOldSpaceSlow(Address address);
    1335             : 
    1336             :   // ===========================================================================
    1337             :   // Object statistics tracking. ===============================================
    1338             :   // ===========================================================================
    1339             : 
    1340             :   // Returns the number of buckets used by object statistics tracking during a
    1341             :   // major GC. Note that the following methods fail gracefully when the bounds
    1342             :   // are exceeded though.
    1343             :   size_t NumberOfTrackedHeapObjectTypes();
    1344             : 
    1345             :   // Returns object statistics about count and size at the last major GC.
    1346             :   // Objects are being grouped into buckets that roughly resemble existing
    1347             :   // instance types.
    1348             :   size_t ObjectCountAtLastGC(size_t index);
    1349             :   size_t ObjectSizeAtLastGC(size_t index);
    1350             : 
    1351             :   // Retrieves names of buckets used by object statistics tracking.
    1352             :   bool GetObjectTypeName(size_t index, const char** object_type,
    1353             :                          const char** object_sub_type);
    1354             : 
    1355             :   // ===========================================================================
    1356             :   // Code statistics. ==========================================================
    1357             :   // ===========================================================================
    1358             : 
    1359             :   // Collect code (Code and BytecodeArray objects) statistics.
    1360             :   void CollectCodeStatistics();
    1361             : 
    1362             :   // ===========================================================================
    1363             :   // GC statistics. ============================================================
    1364             :   // ===========================================================================
    1365             : 
    1366             :   // Returns the maximum amount of memory reserved for the heap.
    1367             :   size_t MaxReserved() {
    1368       60789 :     return 2 * max_semi_space_size_ + max_old_generation_size_;
    1369             :   }
    1370             :   size_t MaxSemiSpaceSize() { return max_semi_space_size_; }
    1371             :   size_t InitialSemiSpaceSize() { return initial_semispace_size_; }
    1372             :   size_t MaxOldGenerationSize() { return max_old_generation_size_; }
    1373             :   size_t MaxExecutableSize() { return max_executable_size_; }
    1374             : 
    1375             :   // Returns the capacity of the heap in bytes w/o growing. Heap grows when
    1376             :   // more spaces are needed until it reaches the limit.
    1377             :   size_t Capacity();
    1378             : 
    1379             :   // Returns the capacity of the old generation.
    1380             :   size_t OldGenerationCapacity();
    1381             : 
    1382             :   // Returns the amount of memory currently committed for the heap.
    1383             :   size_t CommittedMemory();
    1384             : 
    1385             :   // Returns the amount of memory currently committed for the old space.
    1386             :   size_t CommittedOldGenerationMemory();
    1387             : 
    1388             :   // Returns the amount of executable memory currently committed for the heap.
    1389             :   size_t CommittedMemoryExecutable();
    1390             : 
    1391             :   // Returns the amount of phyical memory currently committed for the heap.
    1392             :   size_t CommittedPhysicalMemory();
    1393             : 
    1394             :   // Returns the maximum amount of memory ever committed for the heap.
    1395             :   size_t MaximumCommittedMemory() { return maximum_committed_; }
    1396             : 
    1397             :   // Updates the maximum committed memory for the heap. Should be called
    1398             :   // whenever a space grows.
    1399             :   void UpdateMaximumCommitted();
    1400             : 
    1401             :   // Returns the available bytes in space w/o growing.
    1402             :   // Heap doesn't guarantee that it can allocate an object that requires
    1403             :   // all available bytes. Check MaxHeapObjectSize() instead.
    1404             :   size_t Available();
    1405             : 
    1406             :   // Returns of size of all objects residing in the heap.
    1407             :   size_t SizeOfObjects();
    1408             : 
    1409             :   void UpdateSurvivalStatistics(int start_new_space_size);
    1410             : 
    1411             :   inline void IncrementPromotedObjectsSize(size_t object_size) {
    1412    45910787 :     promoted_objects_size_ += object_size;
    1413             :   }
    1414             :   inline size_t promoted_objects_size() { return promoted_objects_size_; }
    1415             : 
    1416             :   inline void IncrementSemiSpaceCopiedObjectSize(size_t object_size) {
    1417    70563195 :     semi_space_copied_object_size_ += object_size;
    1418             :   }
    1419             :   inline size_t semi_space_copied_object_size() {
    1420             :     return semi_space_copied_object_size_;
    1421             :   }
    1422             : 
    1423             :   inline size_t SurvivedNewSpaceObjectSize() {
    1424      122507 :     return promoted_objects_size_ + semi_space_copied_object_size_;
    1425             :   }
    1426             : 
    1427      140920 :   inline void IncrementNodesDiedInNewSpace() { nodes_died_in_new_space_++; }
    1428             : 
    1429      187650 :   inline void IncrementNodesCopiedInNewSpace() { nodes_copied_in_new_space_++; }
    1430             : 
    1431      192529 :   inline void IncrementNodesPromoted() { nodes_promoted_++; }
    1432             : 
    1433             :   inline void IncrementYoungSurvivorsCounter(size_t survived) {
    1434      128449 :     survived_last_scavenge_ = survived;
    1435      128449 :     survived_since_last_expansion_ += survived;
    1436             :   }
    1437             : 
    1438             :   inline uint64_t PromotedTotalSize() {
    1439     1260066 :     return PromotedSpaceSizeOfObjects() + PromotedExternalMemorySize();
    1440             :   }
    1441             : 
    1442             :   inline void UpdateNewSpaceAllocationCounter();
    1443             : 
    1444             :   inline size_t NewSpaceAllocationCounter();
    1445             : 
    1446             :   // This should be used only for testing.
    1447             :   void set_new_space_allocation_counter(size_t new_value) {
    1448             :     new_space_allocation_counter_ = new_value;
    1449             :   }
    1450             : 
    1451             :   void UpdateOldGenerationAllocationCounter() {
    1452             :     old_generation_allocation_counter_at_last_gc_ =
    1453       53346 :         OldGenerationAllocationCounter();
    1454             :   }
    1455             : 
    1456             :   size_t OldGenerationAllocationCounter() {
    1457      215910 :     return old_generation_allocation_counter_at_last_gc_ +
    1458      215910 :            PromotedSinceLastGC();
    1459             :   }
    1460             : 
    1461             :   // This should be used only for testing.
    1462             :   void set_old_generation_allocation_counter_at_last_gc(size_t new_value) {
    1463             :     old_generation_allocation_counter_at_last_gc_ = new_value;
    1464             :   }
    1465             : 
    1466             :   size_t PromotedSinceLastGC() {
    1467      215910 :     return PromotedSpaceSizeOfObjects() - old_generation_size_at_last_gc_;
    1468             :   }
    1469             : 
    1470    15827509 :   int gc_count() const { return gc_count_; }
    1471             : 
    1472             :   // Returns the size of objects residing in non new spaces.
    1473             :   size_t PromotedSpaceSizeOfObjects();
    1474             : 
    1475             :   // ===========================================================================
    1476             :   // Prologue/epilogue callback methods.========================================
    1477             :   // ===========================================================================
    1478             : 
    1479             :   void AddGCPrologueCallback(v8::Isolate::GCCallback callback,
    1480             :                              GCType gc_type_filter, bool pass_isolate = true);
    1481             :   void RemoveGCPrologueCallback(v8::Isolate::GCCallback callback);
    1482             : 
    1483             :   void AddGCEpilogueCallback(v8::Isolate::GCCallback callback,
    1484             :                              GCType gc_type_filter, bool pass_isolate = true);
    1485             :   void RemoveGCEpilogueCallback(v8::Isolate::GCCallback callback);
    1486             : 
    1487             :   void CallGCPrologueCallbacks(GCType gc_type, GCCallbackFlags flags);
    1488             :   void CallGCEpilogueCallbacks(GCType gc_type, GCCallbackFlags flags);
    1489             : 
    1490             :   // ===========================================================================
    1491             :   // Allocation methods. =======================================================
    1492             :   // ===========================================================================
    1493             : 
    1494             :   // Creates a filler object and returns a heap object immediately after it.
    1495             :   MUST_USE_RESULT HeapObject* PrecedeWithFiller(HeapObject* object,
    1496             :                                                 int filler_size);
    1497             : 
    1498             :   // Creates a filler object if needed for alignment and returns a heap object
    1499             :   // immediately after it. If any space is left after the returned object,
    1500             :   // another filler object is created so the over allocated memory is iterable.
    1501             :   MUST_USE_RESULT HeapObject* AlignWithFiller(HeapObject* object,
    1502             :                                               int object_size,
    1503             :                                               int allocation_size,
    1504             :                                               AllocationAlignment alignment);
    1505             : 
    1506             :   // ===========================================================================
    1507             :   // ArrayBuffer tracking. =====================================================
    1508             :   // ===========================================================================
    1509             : 
    1510             :   // TODO(gc): API usability: encapsulate mutation of JSArrayBuffer::is_external
    1511             :   // in the registration/unregistration APIs. Consider dropping the "New" from
    1512             :   // "RegisterNewArrayBuffer" because one can re-register a previously
    1513             :   // unregistered buffer, too, and the name is confusing.
    1514             :   void RegisterNewArrayBuffer(JSArrayBuffer* buffer);
    1515             :   void UnregisterArrayBuffer(JSArrayBuffer* buffer);
    1516             : 
    1517             :   // ===========================================================================
    1518             :   // Allocation site tracking. =================================================
    1519             :   // ===========================================================================
    1520             : 
    1521             :   // Updates the AllocationSite of a given {object}. If the global prenuring
    1522             :   // storage is passed as {pretenuring_feedback} the memento found count on
    1523             :   // the corresponding allocation site is immediately updated and an entry
    1524             :   // in the hash map is created. Otherwise the entry (including a the count
    1525             :   // value) is cached on the local pretenuring feedback.
    1526             :   template <UpdateAllocationSiteMode mode>
    1527             :   inline void UpdateAllocationSite(HeapObject* object,
    1528             :                                    base::HashMap* pretenuring_feedback);
    1529             : 
    1530             :   // Removes an entry from the global pretenuring storage.
    1531             :   inline void RemoveAllocationSitePretenuringFeedback(AllocationSite* site);
    1532             : 
    1533             :   // Merges local pretenuring feedback into the global one. Note that this
    1534             :   // method needs to be called after evacuation, as allocation sites may be
    1535             :   // evacuated and this method resolves forward pointers accordingly.
    1536             :   void MergeAllocationSitePretenuringFeedback(
    1537             :       const base::HashMap& local_pretenuring_feedback);
    1538             : 
    1539             : // =============================================================================
    1540             : 
    1541             : #ifdef VERIFY_HEAP
    1542             :   // Verify the heap is in its normal state before or after a GC.
    1543             :   void Verify();
    1544             : #endif
    1545             : 
    1546             : #ifdef DEBUG
    1547             :   void set_allocation_timeout(int timeout) { allocation_timeout_ = timeout; }
    1548             : 
    1549             :   void Print();
    1550             :   void PrintHandles();
    1551             : 
    1552             :   // Report heap statistics.
    1553             :   void ReportHeapStatistics(const char* title);
    1554             :   void ReportCodeStatistics(const char* title);
    1555             : #endif
    1556             : 
    1557             :   static const char* GarbageCollectionReasonToString(
    1558             :       GarbageCollectionReason gc_reason);
    1559             : 
    1560             :  private:
    1561             :   class SkipStoreBufferScope;
    1562             :   class PretenuringScope;
    1563             : 
    1564             :   // External strings table is a place where all external strings are
    1565             :   // registered.  We need to keep track of such strings to properly
    1566             :   // finalize them.
    1567             :   class ExternalStringTable {
    1568             :    public:
    1569             :     // Registers an external string.
    1570             :     inline void AddString(String* string);
    1571             : 
    1572             :     inline void IterateAll(RootVisitor* v);
    1573             :     inline void IterateNewSpaceStrings(RootVisitor* v);
    1574             :     inline void PromoteAllNewSpaceStrings();
    1575             : 
    1576             :     // Restores internal invariant and gets rid of collected strings. Must be
    1577             :     // called after each Iterate*() that modified the strings.
    1578             :     void CleanUpAll();
    1579             :     void CleanUpNewSpaceStrings();
    1580             : 
    1581             :     // Destroys all allocated memory.
    1582             :     void TearDown();
    1583             : 
    1584             :    private:
    1585       60782 :     explicit ExternalStringTable(Heap* heap) : heap_(heap) {}
    1586             : 
    1587             :     inline void Verify();
    1588             : 
    1589             :     inline void AddOldString(String* string);
    1590             : 
    1591             :     // Notifies the table that only a prefix of the new list is valid.
    1592             :     inline void ShrinkNewStrings(int position);
    1593             : 
    1594             :     // To speed up scavenge collections new space string are kept
    1595             :     // separate from old space strings.
    1596             :     List<Object*> new_space_strings_;
    1597             :     List<Object*> old_space_strings_;
    1598             : 
    1599             :     Heap* heap_;
    1600             : 
    1601             :     friend class Heap;
    1602             : 
    1603             :     DISALLOW_COPY_AND_ASSIGN(ExternalStringTable);
    1604             :   };
    1605             : 
    1606             :   struct StrongRootsList;
    1607             : 
    1608             :   struct StringTypeTable {
    1609             :     InstanceType type;
    1610             :     int size;
    1611             :     RootListIndex index;
    1612             :   };
    1613             : 
    1614             :   struct ConstantStringTable {
    1615             :     const char* contents;
    1616             :     RootListIndex index;
    1617             :   };
    1618             : 
    1619             :   struct StructTable {
    1620             :     InstanceType type;
    1621             :     int size;
    1622             :     RootListIndex index;
    1623             :   };
    1624             : 
    1625             :   struct GCCallbackPair {
    1626             :     GCCallbackPair(v8::Isolate::GCCallback callback, GCType gc_type,
    1627             :                    bool pass_isolate)
    1628          66 :         : callback(callback), gc_type(gc_type), pass_isolate(pass_isolate) {}
    1629             : 
    1630             :     bool operator==(const GCCallbackPair& other) const {
    1631             :       return other.callback == callback;
    1632             :     }
    1633             : 
    1634             :     v8::Isolate::GCCallback callback;
    1635             :     GCType gc_type;
    1636             :     bool pass_isolate;
    1637             :   };
    1638             : 
    1639             :   typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
    1640             :                                                         Object** pointer);
    1641             : 
    1642             :   static const int kInitialStringTableSize = 2048;
    1643             :   static const int kInitialEvalCacheSize = 64;
    1644             :   static const int kInitialNumberStringCacheSize = 256;
    1645             : 
    1646             :   static const int kRememberedUnmappedPages = 128;
    1647             : 
    1648             :   static const StringTypeTable string_type_table[];
    1649             :   static const ConstantStringTable constant_string_table[];
    1650             :   static const StructTable struct_table[];
    1651             : 
    1652             :   static const int kYoungSurvivalRateHighThreshold = 90;
    1653             :   static const int kYoungSurvivalRateAllowedDeviation = 15;
    1654             :   static const int kOldSurvivalRateLowThreshold = 10;
    1655             : 
    1656             :   static const int kMaxMarkCompactsInIdleRound = 7;
    1657             :   static const int kIdleScavengeThreshold = 5;
    1658             : 
    1659             :   static const int kInitialFeedbackCapacity = 256;
    1660             : 
    1661             :   Heap();
    1662             : 
    1663             :   static String* UpdateNewSpaceReferenceInExternalStringTableEntry(
    1664             :       Heap* heap, Object** pointer);
    1665             : 
    1666             :   // Selects the proper allocation space based on the pretenuring decision.
    1667             :   static AllocationSpace SelectSpace(PretenureFlag pretenure) {
    1668   380974903 :     return (pretenure == TENURED) ? OLD_SPACE : NEW_SPACE;
    1669             :   }
    1670             : 
    1671             : #define ROOT_ACCESSOR(type, name, camel_name) \
    1672             :   inline void set_##name(type* value);
    1673             :   ROOT_LIST(ROOT_ACCESSOR)
    1674             : #undef ROOT_ACCESSOR
    1675             : 
    1676             :   StoreBuffer* store_buffer() { return store_buffer_; }
    1677             : 
    1678             :   void set_current_gc_flags(int flags) {
    1679       87811 :     current_gc_flags_ = flags;
    1680             :     DCHECK(!ShouldFinalizeIncrementalMarking() ||
    1681             :            !ShouldAbortIncrementalMarking());
    1682             :   }
    1683             : 
    1684             :   inline bool ShouldReduceMemory() const {
    1685      562194 :     return (current_gc_flags_ & kReduceMemoryFootprintMask) != 0;
    1686             :   }
    1687             : 
    1688             :   inline bool ShouldAbortIncrementalMarking() const {
    1689       71325 :     return (current_gc_flags_ & kAbortIncrementalMarkingMask) != 0;
    1690             :   }
    1691             : 
    1692             :   inline bool ShouldFinalizeIncrementalMarking() const {
    1693             :     return (current_gc_flags_ & kFinalizeIncrementalMarkingMask) != 0;
    1694             :   }
    1695             : 
    1696             :   void PreprocessStackTraces();
    1697             : 
    1698             :   // Checks whether a global GC is necessary
    1699             :   GarbageCollector SelectGarbageCollector(AllocationSpace space,
    1700             :                                           const char** reason);
    1701             : 
    1702             :   // Make sure there is a filler value behind the top of the new space
    1703             :   // so that the GC does not confuse some unintialized/stale memory
    1704             :   // with the allocation memento of the object at the top
    1705             :   void EnsureFillerObjectAtTop();
    1706             : 
    1707             :   // Ensure that we have swept all spaces in such a way that we can iterate
    1708             :   // over all objects.  May cause a GC.
    1709             :   void MakeHeapIterable();
    1710             : 
    1711             :   // Performs garbage collection operation.
    1712             :   // Returns whether there is a chance that another major GC could
    1713             :   // collect more garbage.
    1714             :   bool CollectGarbage(
    1715             :       GarbageCollector collector, GarbageCollectionReason gc_reason,
    1716             :       const char* collector_reason,
    1717             :       const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
    1718             : 
    1719             :   // Performs garbage collection
    1720             :   // Returns whether there is a chance another major GC could
    1721             :   // collect more garbage.
    1722             :   bool PerformGarbageCollection(
    1723             :       GarbageCollector collector,
    1724             :       const GCCallbackFlags gc_callback_flags = kNoGCCallbackFlags);
    1725             : 
    1726             :   inline void UpdateOldSpaceLimits();
    1727             : 
    1728             :   // Initializes a JSObject based on its map.
    1729             :   void InitializeJSObjectFromMap(JSObject* obj, FixedArray* properties,
    1730             :                                  Map* map);
    1731             : 
    1732             :   // Initializes JSObject body starting at given offset.
    1733             :   void InitializeJSObjectBody(JSObject* obj, Map* map, int start_offset);
    1734             : 
    1735             :   void InitializeAllocationMemento(AllocationMemento* memento,
    1736             :                                    AllocationSite* allocation_site);
    1737             : 
    1738             :   bool CreateInitialMaps();
    1739             :   void CreateInitialObjects();
    1740             : 
    1741             :   // These five Create*EntryStub functions are here and forced to not be inlined
    1742             :   // because of a gcc-4.4 bug that assigns wrong vtable entries.
    1743             :   NO_INLINE(void CreateJSEntryStub());
    1744             :   NO_INLINE(void CreateJSConstructEntryStub());
    1745             : 
    1746             :   void CreateFixedStubs();
    1747             : 
    1748             :   HeapObject* DoubleAlignForDeserialization(HeapObject* object, int size);
    1749             : 
    1750             :   // Commits from space if it is uncommitted.
    1751             :   void EnsureFromSpaceIsCommitted();
    1752             : 
    1753             :   // Uncommit unused semi space.
    1754             :   bool UncommitFromSpace();
    1755             : 
    1756             :   // Fill in bogus values in from space
    1757             :   void ZapFromSpace();
    1758             : 
    1759             :   // Deopts all code that contains allocation instruction which are tenured or
    1760             :   // not tenured. Moreover it clears the pretenuring allocation site statistics.
    1761             :   void ResetAllAllocationSitesDependentCode(PretenureFlag flag);
    1762             : 
    1763             :   // Evaluates local pretenuring for the old space and calls
    1764             :   // ResetAllTenuredAllocationSitesDependentCode if too many objects died in
    1765             :   // the old space.
    1766             :   void EvaluateOldSpaceLocalPretenuring(uint64_t size_of_objects_before_gc);
    1767             : 
    1768             :   // Record statistics before and after garbage collection.
    1769             :   void ReportStatisticsBeforeGC();
    1770             :   void ReportStatisticsAfterGC();
    1771             : 
    1772             :   // Creates and installs the full-sized number string cache.
    1773             :   int FullSizeNumberStringCacheLength();
    1774             :   // Flush the number to string cache.
    1775             :   void FlushNumberStringCache();
    1776             : 
    1777             :   void ConfigureInitialOldGenerationSize();
    1778             : 
    1779             :   bool HasLowYoungGenerationAllocationRate();
    1780             :   bool HasLowOldGenerationAllocationRate();
    1781             :   double YoungGenerationMutatorUtilization();
    1782             :   double OldGenerationMutatorUtilization();
    1783             : 
    1784             :   void ReduceNewSpaceSize();
    1785             : 
    1786             :   GCIdleTimeHeapState ComputeHeapState();
    1787             : 
    1788             :   bool PerformIdleTimeAction(GCIdleTimeAction action,
    1789             :                              GCIdleTimeHeapState heap_state,
    1790             :                              double deadline_in_ms);
    1791             : 
    1792             :   void IdleNotificationEpilogue(GCIdleTimeAction action,
    1793             :                                 GCIdleTimeHeapState heap_state, double start_ms,
    1794             :                                 double deadline_in_ms);
    1795             : 
    1796             :   inline void UpdateAllocationsHash(HeapObject* object);
    1797             :   inline void UpdateAllocationsHash(uint32_t value);
    1798             :   void PrintAlloctionsHash();
    1799             : 
    1800             :   void AddToRingBuffer(const char* string);
    1801             :   void GetFromRingBuffer(char* buffer);
    1802             : 
    1803             :   void CompactRetainedMaps(ArrayList* retained_maps);
    1804             : 
    1805             :   void CollectGarbageOnMemoryPressure();
    1806             : 
    1807             :   void InvokeOutOfMemoryCallback();
    1808             : 
    1809             :   void ComputeFastPromotionMode(double survival_rate);
    1810             : 
    1811             :   // Attempt to over-approximate the weak closure by marking object groups and
    1812             :   // implicit references from global handles, but don't atomically complete
    1813             :   // marking. If we continue to mark incrementally, we might have marked
    1814             :   // objects that die later.
    1815             :   void FinalizeIncrementalMarking(GarbageCollectionReason gc_reason);
    1816             : 
    1817             :   // Returns the timer used for a given GC type.
    1818             :   // - GCScavenger: young generation GC
    1819             :   // - GCCompactor: full GC
    1820             :   // - GCFinalzeMC: finalization of incremental full GC
    1821             :   // - GCFinalizeMCReduceMemory: finalization of incremental full GC with
    1822             :   // memory reduction
    1823             :   HistogramTimer* GCTypeTimer(GarbageCollector collector);
    1824             : 
    1825             :   // ===========================================================================
    1826             :   // Pretenuring. ==============================================================
    1827             :   // ===========================================================================
    1828             : 
    1829             :   // Pretenuring decisions are made based on feedback collected during new space
    1830             :   // evacuation. Note that between feedback collection and calling this method
    1831             :   // object in old space must not move.
    1832             :   void ProcessPretenuringFeedback();
    1833             : 
    1834             :   // ===========================================================================
    1835             :   // Actual GC. ================================================================
    1836             :   // ===========================================================================
    1837             : 
    1838             :   // Code that should be run before and after each GC.  Includes some
    1839             :   // reporting/verification activities when compiled with DEBUG set.
    1840             :   void GarbageCollectionPrologue();
    1841             :   void GarbageCollectionEpilogue();
    1842             : 
    1843             :   // Performs a major collection in the whole heap.
    1844             :   void MarkCompact();
    1845             :   // Performs a minor collection of just the young generation.
    1846             :   void MinorMarkCompact();
    1847             : 
    1848             :   // Code to be run before and after mark-compact.
    1849             :   void MarkCompactPrologue();
    1850             :   void MarkCompactEpilogue();
    1851             : 
    1852             :   // Performs a minor collection in new generation.
    1853             :   void Scavenge();
    1854             :   void EvacuateYoungGeneration();
    1855             : 
    1856             :   Address DoScavenge(Address new_space_front);
    1857             : 
    1858             :   void UpdateNewSpaceReferencesInExternalStringTable(
    1859             :       ExternalStringTableUpdaterCallback updater_func);
    1860             : 
    1861             :   void UpdateReferencesInExternalStringTable(
    1862             :       ExternalStringTableUpdaterCallback updater_func);
    1863             : 
    1864             :   void ProcessAllWeakReferences(WeakObjectRetainer* retainer);
    1865             :   void ProcessYoungWeakReferences(WeakObjectRetainer* retainer);
    1866             :   void ProcessNativeContexts(WeakObjectRetainer* retainer);
    1867             :   void ProcessAllocationSites(WeakObjectRetainer* retainer);
    1868             :   void ProcessWeakListRoots(WeakObjectRetainer* retainer);
    1869             : 
    1870             :   // ===========================================================================
    1871             :   // GC statistics. ============================================================
    1872             :   // ===========================================================================
    1873             : 
    1874      315614 :   inline size_t OldGenerationSpaceAvailable() {
    1875      631228 :     if (old_generation_allocation_limit_ <= PromotedTotalSize()) return 0;
    1876      310439 :     return old_generation_allocation_limit_ -
    1877      310439 :            static_cast<size_t>(PromotedTotalSize());
    1878             :   }
    1879             : 
    1880             :   // We allow incremental marking to overshoot the allocation limit for
    1881             :   // performace reasons. If the overshoot is too large then we are more
    1882             :   // eager to finalize incremental marking.
    1883        2004 :   inline bool AllocationLimitOvershotByLargeMargin() {
    1884             :     // This guards against too eager finalization in small heaps.
    1885             :     // The number is chosen based on v8.browsing_mobile on Nexus 7v2.
    1886             :     size_t kMarginForSmallHeaps = 32u * MB;
    1887        4008 :     if (old_generation_allocation_limit_ >= PromotedTotalSize()) return false;
    1888        1976 :     uint64_t overshoot = PromotedTotalSize() - old_generation_allocation_limit_;
    1889             :     // Overshoot margin is 50% of allocation limit or half-way to the max heap
    1890             :     // with special handling of small heaps.
    1891             :     uint64_t margin =
    1892             :         Min(Max(old_generation_allocation_limit_ / 2, kMarginForSmallHeaps),
    1893        1976 :             (max_old_generation_size_ - old_generation_allocation_limit_) / 2);
    1894        1976 :     return overshoot >= margin;
    1895             :   }
    1896             : 
    1897             :   void UpdateTotalGCTime(double duration);
    1898             : 
    1899      122535 :   bool MaximumSizeScavenge() { return maximum_size_scavenges_ > 0; }
    1900             : 
    1901             :   // ===========================================================================
    1902             :   // Growing strategy. =========================================================
    1903             :   // ===========================================================================
    1904             : 
    1905             :   // For some webpages RAIL mode does not switch from PERFORMANCE_LOAD.
    1906             :   // This constant limits the effect of load RAIL mode on GC.
    1907             :   // The value is arbitrary and chosen as the largest load time observed in
    1908             :   // v8 browsing benchmarks.
    1909             :   static const int kMaxLoadTimeMs = 7000;
    1910             : 
    1911             :   bool ShouldOptimizeForLoadTime();
    1912             : 
    1913             :   // Decrease the allocation limit if the new limit based on the given
    1914             :   // parameters is lower than the current limit.
    1915             :   void DampenOldGenerationAllocationLimit(size_t old_gen_size, double gc_speed,
    1916             :                                           double mutator_speed);
    1917             : 
    1918             :   // Calculates the allocation limit based on a given growing factor and a
    1919             :   // given old generation size.
    1920             :   size_t CalculateOldGenerationAllocationLimit(double factor,
    1921             :                                                size_t old_gen_size);
    1922             : 
    1923             :   // Sets the allocation limit to trigger the next full garbage collection.
    1924             :   void SetOldGenerationAllocationLimit(size_t old_gen_size, double gc_speed,
    1925             :                                        double mutator_speed);
    1926             : 
    1927             :   size_t MinimumAllocationLimitGrowingStep();
    1928             : 
    1929             :   size_t old_generation_allocation_limit() const {
    1930             :     return old_generation_allocation_limit_;
    1931             :   }
    1932             : 
    1933             :   bool always_allocate() { return always_allocate_scope_count_.Value() != 0; }
    1934             : 
    1935      527542 :   bool CanExpandOldGeneration(size_t size) {
    1936      531363 :     if (force_oom_) return false;
    1937     1055084 :     return (OldGenerationCapacity() + size) < MaxOldGenerationSize();
    1938             :   }
    1939             : 
    1940       33368 :   bool IsCloseToOutOfMemory(size_t slack) {
    1941       33368 :     return OldGenerationCapacity() + slack >= MaxOldGenerationSize();
    1942             :   }
    1943             : 
    1944             :   bool ShouldExpandOldGenerationOnSlowAllocation();
    1945             : 
    1946             :   enum class IncrementalMarkingLimit { kNoLimit, kSoftLimit, kHardLimit };
    1947             :   IncrementalMarkingLimit IncrementalMarkingLimitReached();
    1948             : 
    1949             :   // ===========================================================================
    1950             :   // Idle notification. ========================================================
    1951             :   // ===========================================================================
    1952             : 
    1953             :   bool RecentIdleNotificationHappened();
    1954             :   void ScheduleIdleScavengeIfNeeded(int bytes_allocated);
    1955             : 
    1956             :   // ===========================================================================
    1957             :   // HeapIterator helpers. =====================================================
    1958             :   // ===========================================================================
    1959             : 
    1960       24569 :   void heap_iterator_start() { heap_iterator_depth_++; }
    1961             : 
    1962       24569 :   void heap_iterator_end() { heap_iterator_depth_--; }
    1963             : 
    1964             :   bool in_heap_iterator() { return heap_iterator_depth_ > 0; }
    1965             : 
    1966             :   // ===========================================================================
    1967             :   // Allocation methods. =======================================================
    1968             :   // ===========================================================================
    1969             : 
    1970             :   // Returns a deep copy of the JavaScript object.
    1971             :   // Properties and elements are copied too.
    1972             :   // Optionally takes an AllocationSite to be appended in an AllocationMemento.
    1973             :   MUST_USE_RESULT AllocationResult CopyJSObject(JSObject* source,
    1974             :                                                 AllocationSite* site = NULL);
    1975             : 
    1976             :   // Allocates a JS Map in the heap.
    1977             :   MUST_USE_RESULT AllocationResult
    1978             :   AllocateMap(InstanceType instance_type, int instance_size,
    1979             :               ElementsKind elements_kind = TERMINAL_FAST_ELEMENTS_KIND);
    1980             : 
    1981             :   // Allocates and initializes a new JavaScript object based on a
    1982             :   // constructor.
    1983             :   // If allocation_site is non-null, then a memento is emitted after the object
    1984             :   // that points to the site.
    1985             :   MUST_USE_RESULT AllocationResult AllocateJSObject(
    1986             :       JSFunction* constructor, PretenureFlag pretenure = NOT_TENURED,
    1987             :       AllocationSite* allocation_site = NULL);
    1988             : 
    1989             :   // Allocates and initializes a new JavaScript object based on a map.
    1990             :   // Passing an allocation site means that a memento will be created that
    1991             :   // points to the site.
    1992             :   MUST_USE_RESULT AllocationResult
    1993             :   AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure = NOT_TENURED,
    1994             :                           AllocationSite* allocation_site = NULL);
    1995             : 
    1996             :   // Allocates a HeapNumber from value.
    1997             :   MUST_USE_RESULT AllocationResult AllocateHeapNumber(
    1998             :       MutableMode mode = IMMUTABLE, PretenureFlag pretenure = NOT_TENURED);
    1999             : 
    2000             :   // Allocates a byte array of the specified length
    2001             :   MUST_USE_RESULT AllocationResult
    2002             :   AllocateByteArray(int length, PretenureFlag pretenure = NOT_TENURED);
    2003             : 
    2004             :   // Allocates a bytecode array with given contents.
    2005             :   MUST_USE_RESULT AllocationResult
    2006             :   AllocateBytecodeArray(int length, const byte* raw_bytecodes, int frame_size,
    2007             :                         int parameter_count, FixedArray* constant_pool);
    2008             : 
    2009             :   MUST_USE_RESULT AllocationResult CopyCode(Code* code);
    2010             : 
    2011             :   MUST_USE_RESULT AllocationResult
    2012             :   CopyBytecodeArray(BytecodeArray* bytecode_array);
    2013             : 
    2014             :   // Allocates a fixed array initialized with undefined values
    2015             :   MUST_USE_RESULT AllocationResult
    2016             :   AllocateFixedArray(int length, PretenureFlag pretenure = NOT_TENURED);
    2017             : 
    2018             :   // Allocate an uninitialized object.  The memory is non-executable if the
    2019             :   // hardware and OS allow.  This is the single choke-point for allocations
    2020             :   // performed by the runtime and should not be bypassed (to extend this to
    2021             :   // inlined allocations, use the Heap::DisableInlineAllocation() support).
    2022             :   MUST_USE_RESULT inline AllocationResult AllocateRaw(
    2023             :       int size_in_bytes, AllocationSpace space,
    2024             :       AllocationAlignment aligment = kWordAligned);
    2025             : 
    2026             :   // Allocates a heap object based on the map.
    2027             :   MUST_USE_RESULT AllocationResult
    2028             :       Allocate(Map* map, AllocationSpace space,
    2029             :                AllocationSite* allocation_site = NULL);
    2030             : 
    2031             :   // Allocates a partial map for bootstrapping.
    2032             :   MUST_USE_RESULT AllocationResult
    2033             :       AllocatePartialMap(InstanceType instance_type, int instance_size);
    2034             : 
    2035             :   // Allocate a block of memory in the given space (filled with a filler).
    2036             :   // Used as a fall-back for generated code when the space is full.
    2037             :   MUST_USE_RESULT AllocationResult
    2038             :       AllocateFillerObject(int size, bool double_align, AllocationSpace space);
    2039             : 
    2040             :   // Allocate an uninitialized fixed array.
    2041             :   MUST_USE_RESULT AllocationResult
    2042             :       AllocateRawFixedArray(int length, PretenureFlag pretenure);
    2043             : 
    2044             :   // Allocate an uninitialized fixed double array.
    2045             :   MUST_USE_RESULT AllocationResult
    2046             :       AllocateRawFixedDoubleArray(int length, PretenureFlag pretenure);
    2047             : 
    2048             :   // Allocate an initialized fixed array with the given filler value.
    2049             :   MUST_USE_RESULT AllocationResult
    2050             :       AllocateFixedArrayWithFiller(int length, PretenureFlag pretenure,
    2051             :                                    Object* filler);
    2052             : 
    2053             :   // Allocate and partially initializes a String.  There are two String
    2054             :   // encodings: one-byte and two-byte.  These functions allocate a string of
    2055             :   // the given length and set its map and length fields.  The characters of
    2056             :   // the string are uninitialized.
    2057             :   MUST_USE_RESULT AllocationResult
    2058             :       AllocateRawOneByteString(int length, PretenureFlag pretenure);
    2059             :   MUST_USE_RESULT AllocationResult
    2060             :       AllocateRawTwoByteString(int length, PretenureFlag pretenure);
    2061             : 
    2062             :   // Allocates an internalized string in old space based on the character
    2063             :   // stream.
    2064             :   MUST_USE_RESULT inline AllocationResult AllocateInternalizedStringFromUtf8(
    2065             :       Vector<const char> str, int chars, uint32_t hash_field);
    2066             : 
    2067             :   MUST_USE_RESULT inline AllocationResult AllocateOneByteInternalizedString(
    2068             :       Vector<const uint8_t> str, uint32_t hash_field);
    2069             : 
    2070             :   MUST_USE_RESULT inline AllocationResult AllocateTwoByteInternalizedString(
    2071             :       Vector<const uc16> str, uint32_t hash_field);
    2072             : 
    2073             :   template <bool is_one_byte, typename T>
    2074             :   MUST_USE_RESULT AllocationResult
    2075        1202 :       AllocateInternalizedStringImpl(T t, int chars, uint32_t hash_field);
    2076             : 
    2077             :   template <typename T>
    2078             :   MUST_USE_RESULT inline AllocationResult AllocateInternalizedStringImpl(
    2079             :       T t, int chars, uint32_t hash_field);
    2080             : 
    2081             :   // Allocates an uninitialized fixed array. It must be filled by the caller.
    2082             :   MUST_USE_RESULT AllocationResult AllocateUninitializedFixedArray(int length);
    2083             : 
    2084             :   // Make a copy of src and return it.
    2085             :   MUST_USE_RESULT inline AllocationResult CopyFixedArray(FixedArray* src);
    2086             : 
    2087             :   // Make a copy of src, also grow the copy, and return the copy.
    2088             :   MUST_USE_RESULT AllocationResult
    2089             :   CopyFixedArrayAndGrow(FixedArray* src, int grow_by, PretenureFlag pretenure);
    2090             : 
    2091             :   // Make a copy of src, also grow the copy, and return the copy.
    2092             :   MUST_USE_RESULT AllocationResult CopyFixedArrayUpTo(FixedArray* src,
    2093             :                                                       int new_len,
    2094             :                                                       PretenureFlag pretenure);
    2095             : 
    2096             :   // Make a copy of src, set the map, and return the copy.
    2097             :   MUST_USE_RESULT AllocationResult
    2098             :       CopyFixedArrayWithMap(FixedArray* src, Map* map);
    2099             : 
    2100             :   // Make a copy of src and return it.
    2101             :   MUST_USE_RESULT inline AllocationResult CopyFixedDoubleArray(
    2102             :       FixedDoubleArray* src);
    2103             : 
    2104             :   // Computes a single character string where the character has code.
    2105             :   // A cache is used for one-byte (Latin1) codes.
    2106             :   MUST_USE_RESULT AllocationResult
    2107             :       LookupSingleCharacterStringFromCode(uint16_t code);
    2108             : 
    2109             :   // Allocate a symbol in old space.
    2110             :   MUST_USE_RESULT AllocationResult AllocateSymbol();
    2111             : 
    2112             :   // Allocates an external array of the specified length and type.
    2113             :   MUST_USE_RESULT AllocationResult AllocateFixedTypedArrayWithExternalPointer(
    2114             :       int length, ExternalArrayType array_type, void* external_pointer,
    2115             :       PretenureFlag pretenure);
    2116             : 
    2117             :   // Allocates a fixed typed array of the specified length and type.
    2118             :   MUST_USE_RESULT AllocationResult
    2119             :   AllocateFixedTypedArray(int length, ExternalArrayType array_type,
    2120             :                           bool initialize, PretenureFlag pretenure);
    2121             : 
    2122             :   // Make a copy of src and return it.
    2123             :   MUST_USE_RESULT AllocationResult CopyAndTenureFixedCOWArray(FixedArray* src);
    2124             : 
    2125             :   // Make a copy of src, set the map, and return the copy.
    2126             :   MUST_USE_RESULT AllocationResult
    2127             :       CopyFixedDoubleArrayWithMap(FixedDoubleArray* src, Map* map);
    2128             : 
    2129             :   // Allocates a fixed double array with uninitialized values. Returns
    2130             :   MUST_USE_RESULT AllocationResult AllocateUninitializedFixedDoubleArray(
    2131             :       int length, PretenureFlag pretenure = NOT_TENURED);
    2132             : 
    2133             :   // Allocate empty fixed array.
    2134             :   MUST_USE_RESULT AllocationResult AllocateEmptyFixedArray();
    2135             : 
    2136             :   // Allocate empty scope info.
    2137             :   MUST_USE_RESULT AllocationResult AllocateEmptyScopeInfo();
    2138             : 
    2139             :   // Allocate empty fixed typed array of given type.
    2140             :   MUST_USE_RESULT AllocationResult
    2141             :       AllocateEmptyFixedTypedArray(ExternalArrayType array_type);
    2142             : 
    2143             :   // Allocate a tenured simple cell.
    2144             :   MUST_USE_RESULT AllocationResult AllocateCell(Object* value);
    2145             : 
    2146             :   // Allocate a tenured JS global property cell initialized with the hole.
    2147             :   MUST_USE_RESULT AllocationResult AllocatePropertyCell();
    2148             : 
    2149             :   MUST_USE_RESULT AllocationResult AllocateWeakCell(HeapObject* value);
    2150             : 
    2151             :   MUST_USE_RESULT AllocationResult AllocateTransitionArray(int capacity);
    2152             : 
    2153             :   // Allocates a new utility object in the old generation.
    2154             :   MUST_USE_RESULT AllocationResult AllocateStruct(InstanceType type);
    2155             : 
    2156             :   // Allocates a new foreign object.
    2157             :   MUST_USE_RESULT AllocationResult
    2158             :       AllocateForeign(Address address, PretenureFlag pretenure = NOT_TENURED);
    2159             : 
    2160             :   MUST_USE_RESULT AllocationResult
    2161             :       AllocateCode(int object_size, bool immovable);
    2162             : 
    2163             :   // ===========================================================================
    2164             : 
    2165             :   void set_force_oom(bool value) { force_oom_ = value; }
    2166             : 
    2167             :   // The amount of external memory registered through the API.
    2168             :   int64_t external_memory_;
    2169             : 
    2170             :   // The limit when to trigger memory pressure from the API.
    2171             :   int64_t external_memory_limit_;
    2172             : 
    2173             :   // Caches the amount of external memory registered at the last MC.
    2174             :   int64_t external_memory_at_last_mark_compact_;
    2175             : 
    2176             :   // The amount of memory that has been freed concurrently.
    2177             :   base::AtomicNumber<intptr_t> external_memory_concurrently_freed_;
    2178             : 
    2179             :   // This can be calculated directly from a pointer to the heap; however, it is
    2180             :   // more expedient to get at the isolate directly from within Heap methods.
    2181             :   Isolate* isolate_;
    2182             : 
    2183             :   Object* roots_[kRootListLength];
    2184             : 
    2185             :   size_t code_range_size_;
    2186             :   size_t max_semi_space_size_;
    2187             :   size_t initial_semispace_size_;
    2188             :   size_t max_old_generation_size_;
    2189             :   size_t initial_max_old_generation_size_;
    2190             :   size_t initial_old_generation_size_;
    2191             :   bool old_generation_size_configured_;
    2192             :   size_t max_executable_size_;
    2193             :   size_t maximum_committed_;
    2194             : 
    2195             :   // For keeping track of how much data has survived
    2196             :   // scavenge since last new space expansion.
    2197             :   size_t survived_since_last_expansion_;
    2198             : 
    2199             :   // ... and since the last scavenge.
    2200             :   size_t survived_last_scavenge_;
    2201             : 
    2202             :   // This is not the depth of nested AlwaysAllocateScope's but rather a single
    2203             :   // count, as scopes can be acquired from multiple tasks (read: threads).
    2204             :   base::AtomicNumber<size_t> always_allocate_scope_count_;
    2205             : 
    2206             :   // Stores the memory pressure level that set by MemoryPressureNotification
    2207             :   // and reset by a mark-compact garbage collection.
    2208             :   base::AtomicValue<MemoryPressureLevel> memory_pressure_level_;
    2209             : 
    2210             :   v8::debug::OutOfMemoryCallback out_of_memory_callback_;
    2211             :   void* out_of_memory_callback_data_;
    2212             : 
    2213             :   // For keeping track of context disposals.
    2214             :   int contexts_disposed_;
    2215             : 
    2216             :   // The length of the retained_maps array at the time of context disposal.
    2217             :   // This separates maps in the retained_maps array that were created before
    2218             :   // and after context disposal.
    2219             :   int number_of_disposed_maps_;
    2220             : 
    2221             :   int global_ic_age_;
    2222             : 
    2223             :   NewSpace* new_space_;
    2224             :   OldSpace* old_space_;
    2225             :   OldSpace* code_space_;
    2226             :   MapSpace* map_space_;
    2227             :   LargeObjectSpace* lo_space_;
    2228             :   // Map from the space id to the space.
    2229             :   Space* space_[LAST_SPACE + 1];
    2230             :   HeapState gc_state_;
    2231             :   int gc_post_processing_depth_;
    2232             :   Address new_space_top_after_last_gc_;
    2233             : 
    2234             :   // Returns the amount of external memory registered since last global gc.
    2235             :   uint64_t PromotedExternalMemorySize();
    2236             : 
    2237             :   // How many "runtime allocations" happened.
    2238             :   uint32_t allocations_count_;
    2239             : 
    2240             :   // Running hash over allocations performed.
    2241             :   uint32_t raw_allocations_hash_;
    2242             : 
    2243             :   // How many mark-sweep collections happened.
    2244             :   unsigned int ms_count_;
    2245             : 
    2246             :   // How many gc happened.
    2247             :   unsigned int gc_count_;
    2248             : 
    2249             :   // For post mortem debugging.
    2250             :   int remembered_unmapped_pages_index_;
    2251             :   Address remembered_unmapped_pages_[kRememberedUnmappedPages];
    2252             : 
    2253             : #ifdef DEBUG
    2254             :   // If the --gc-interval flag is set to a positive value, this
    2255             :   // variable holds the value indicating the number of allocations
    2256             :   // remain until the next failure and garbage collection.
    2257             :   int allocation_timeout_;
    2258             : #endif  // DEBUG
    2259             : 
    2260             :   // Limit that triggers a global GC on the next (normally caused) GC.  This
    2261             :   // is checked when we have already decided to do a GC to help determine
    2262             :   // which collector to invoke, before expanding a paged space in the old
    2263             :   // generation and on every allocation in large object space.
    2264             :   size_t old_generation_allocation_limit_;
    2265             : 
    2266             :   // Indicates that inline bump-pointer allocation has been globally disabled
    2267             :   // for all spaces. This is used to disable allocations in generated code.
    2268             :   bool inline_allocation_disabled_;
    2269             : 
    2270             :   // Weak list heads, threaded through the objects.
    2271             :   // List heads are initialized lazily and contain the undefined_value at start.
    2272             :   Object* native_contexts_list_;
    2273             :   Object* allocation_sites_list_;
    2274             : 
    2275             :   // List of encountered weak collections (JSWeakMap and JSWeakSet) during
    2276             :   // marking. It is initialized during marking, destroyed after marking and
    2277             :   // contains Smi(0) while marking is not active.
    2278             :   Object* encountered_weak_collections_;
    2279             : 
    2280             :   Object* encountered_weak_cells_;
    2281             : 
    2282             :   Object* encountered_transition_arrays_;
    2283             : 
    2284             :   List<GCCallbackPair> gc_epilogue_callbacks_;
    2285             :   List<GCCallbackPair> gc_prologue_callbacks_;
    2286             : 
    2287             :   int deferred_counters_[v8::Isolate::kUseCounterFeatureCount];
    2288             : 
    2289             :   GCTracer* tracer_;
    2290             : 
    2291             :   size_t promoted_objects_size_;
    2292             :   double promotion_ratio_;
    2293             :   double promotion_rate_;
    2294             :   size_t semi_space_copied_object_size_;
    2295             :   size_t previous_semi_space_copied_object_size_;
    2296             :   double semi_space_copied_rate_;
    2297             :   int nodes_died_in_new_space_;
    2298             :   int nodes_copied_in_new_space_;
    2299             :   int nodes_promoted_;
    2300             : 
    2301             :   // This is the pretenuring trigger for allocation sites that are in maybe
    2302             :   // tenure state. When we switched to the maximum new space size we deoptimize
    2303             :   // the code that belongs to the allocation site and derive the lifetime
    2304             :   // of the allocation site.
    2305             :   unsigned int maximum_size_scavenges_;
    2306             : 
    2307             :   // Total time spent in GC.
    2308             :   double total_gc_time_ms_;
    2309             : 
    2310             :   // Last time an idle notification happened.
    2311             :   double last_idle_notification_time_;
    2312             : 
    2313             :   // Last time a garbage collection happened.
    2314             :   double last_gc_time_;
    2315             : 
    2316             :   Scavenger* scavenge_collector_;
    2317             : 
    2318             :   MarkCompactCollector* mark_compact_collector_;
    2319             :   MinorMarkCompactCollector* minor_mark_compact_collector_;
    2320             : 
    2321             :   MemoryAllocator* memory_allocator_;
    2322             : 
    2323             :   StoreBuffer* store_buffer_;
    2324             : 
    2325             :   IncrementalMarking* incremental_marking_;
    2326             :   ConcurrentMarking* concurrent_marking_;
    2327             : 
    2328             :   GCIdleTimeHandler* gc_idle_time_handler_;
    2329             : 
    2330             :   MemoryReducer* memory_reducer_;
    2331             : 
    2332             :   ObjectStats* live_object_stats_;
    2333             :   ObjectStats* dead_object_stats_;
    2334             : 
    2335             :   ScavengeJob* scavenge_job_;
    2336             : 
    2337             :   AllocationObserver* idle_scavenge_observer_;
    2338             : 
    2339             :   // This counter is increased before each GC and never reset.
    2340             :   // To account for the bytes allocated since the last GC, use the
    2341             :   // NewSpaceAllocationCounter() function.
    2342             :   size_t new_space_allocation_counter_;
    2343             : 
    2344             :   // This counter is increased before each GC and never reset. To
    2345             :   // account for the bytes allocated since the last GC, use the
    2346             :   // OldGenerationAllocationCounter() function.
    2347             :   size_t old_generation_allocation_counter_at_last_gc_;
    2348             : 
    2349             :   // The size of objects in old generation after the last MarkCompact GC.
    2350             :   size_t old_generation_size_at_last_gc_;
    2351             : 
    2352             :   // If the --deopt_every_n_garbage_collections flag is set to a positive value,
    2353             :   // this variable holds the number of garbage collections since the last
    2354             :   // deoptimization triggered by garbage collection.
    2355             :   int gcs_since_last_deopt_;
    2356             : 
    2357             :   // The feedback storage is used to store allocation sites (keys) and how often
    2358             :   // they have been visited (values) by finding a memento behind an object. The
    2359             :   // storage is only alive temporary during a GC. The invariant is that all
    2360             :   // pointers in this map are already fixed, i.e., they do not point to
    2361             :   // forwarding pointers.
    2362             :   base::HashMap* global_pretenuring_feedback_;
    2363             : 
    2364             :   char trace_ring_buffer_[kTraceRingBufferSize];
    2365             :   // If it's not full then the data is from 0 to ring_buffer_end_.  If it's
    2366             :   // full then the data is from ring_buffer_end_ to the end of the buffer and
    2367             :   // from 0 to ring_buffer_end_.
    2368             :   bool ring_buffer_full_;
    2369             :   size_t ring_buffer_end_;
    2370             : 
    2371             :   // Shared state read by the scavenge collector and set by ScavengeObject.
    2372             :   PromotionQueue promotion_queue_;
    2373             : 
    2374             :   // Flag is set when the heap has been configured.  The heap can be repeatedly
    2375             :   // configured through the API until it is set up.
    2376             :   bool configured_;
    2377             : 
    2378             :   // Currently set GC flags that are respected by all GC components.
    2379             :   int current_gc_flags_;
    2380             : 
    2381             :   // Currently set GC callback flags that are used to pass information between
    2382             :   // the embedder and V8's GC.
    2383             :   GCCallbackFlags current_gc_callback_flags_;
    2384             : 
    2385             :   ExternalStringTable external_string_table_;
    2386             : 
    2387             :   base::Mutex relocation_mutex_;
    2388             : 
    2389             :   int gc_callbacks_depth_;
    2390             : 
    2391             :   bool deserialization_complete_;
    2392             : 
    2393             :   StrongRootsList* strong_roots_list_;
    2394             : 
    2395             :   // The depth of HeapIterator nestings.
    2396             :   int heap_iterator_depth_;
    2397             : 
    2398             :   LocalEmbedderHeapTracer* local_embedder_heap_tracer_;
    2399             : 
    2400             :   bool fast_promotion_mode_;
    2401             : 
    2402             :   // Used for testing purposes.
    2403             :   bool force_oom_;
    2404             :   bool delay_sweeper_tasks_for_testing_;
    2405             : 
    2406             :   HeapObject* pending_layout_change_object_;
    2407             : 
    2408             :   // Classes in "heap" can be friends.
    2409             :   friend class AlwaysAllocateScope;
    2410             :   friend class ConcurrentMarking;
    2411             :   friend class GCCallbacksScope;
    2412             :   friend class GCTracer;
    2413             :   friend class HeapIterator;
    2414             :   friend class IdleScavengeObserver;
    2415             :   friend class IncrementalMarking;
    2416             :   friend class IncrementalMarkingJob;
    2417             :   friend class LargeObjectSpace;
    2418             :   friend class MarkCompactCollector;
    2419             :   friend class MinorMarkCompactCollector;
    2420             :   friend class MarkCompactMarkingVisitor;
    2421             :   friend class NewSpace;
    2422             :   friend class ObjectStatsCollector;
    2423             :   friend class Page;
    2424             :   friend class PagedSpace;
    2425             :   friend class Scavenger;
    2426             :   friend class StoreBuffer;
    2427             :   friend class TestMemoryAllocatorScope;
    2428             : 
    2429             :   // The allocator interface.
    2430             :   friend class Factory;
    2431             : 
    2432             :   // The Isolate constructs us.
    2433             :   friend class Isolate;
    2434             : 
    2435             :   // Used in cctest.
    2436             :   friend class HeapTester;
    2437             : 
    2438             :   DISALLOW_COPY_AND_ASSIGN(Heap);
    2439             : };
    2440             : 
    2441             : 
    2442             : class HeapStats {
    2443             :  public:
    2444             :   static const int kStartMarker = 0xDECADE00;
    2445             :   static const int kEndMarker = 0xDECADE01;
    2446             : 
    2447             :   intptr_t* start_marker;                  //  0
    2448             :   size_t* new_space_size;                  //  1
    2449             :   size_t* new_space_capacity;              //  2
    2450             :   size_t* old_space_size;                  //  3
    2451             :   size_t* old_space_capacity;              //  4
    2452             :   size_t* code_space_size;                 //  5
    2453             :   size_t* code_space_capacity;             //  6
    2454             :   size_t* map_space_size;                  //  7
    2455             :   size_t* map_space_capacity;              //  8
    2456             :   size_t* lo_space_size;                   //  9
    2457             :   size_t* global_handle_count;             // 10
    2458             :   size_t* weak_global_handle_count;        // 11
    2459             :   size_t* pending_global_handle_count;     // 12
    2460             :   size_t* near_death_global_handle_count;  // 13
    2461             :   size_t* free_global_handle_count;        // 14
    2462             :   size_t* memory_allocator_size;           // 15
    2463             :   size_t* memory_allocator_capacity;       // 16
    2464             :   size_t* malloced_memory;                 // 17
    2465             :   size_t* malloced_peak_memory;            // 18
    2466             :   size_t* objects_per_type;                // 19
    2467             :   size_t* size_per_type;                   // 20
    2468             :   int* os_error;                           // 21
    2469             :   char* last_few_messages;                 // 22
    2470             :   char* js_stacktrace;                     // 23
    2471             :   intptr_t* end_marker;                    // 24
    2472             : };
    2473             : 
    2474             : 
    2475             : class AlwaysAllocateScope {
    2476             :  public:
    2477             :   explicit inline AlwaysAllocateScope(Isolate* isolate);
    2478             :   inline ~AlwaysAllocateScope();
    2479             : 
    2480             :  private:
    2481             :   Heap* heap_;
    2482             : };
    2483             : 
    2484             : 
    2485             : // Visitor class to verify interior pointers in spaces that do not contain
    2486             : // or care about intergenerational references. All heap object pointers have to
    2487             : // point into the heap to a location that has a map pointer at its first word.
    2488             : // Caveat: Heap::Contains is an approximation because it can return true for
    2489             : // objects in a heap space but above the allocation pointer.
    2490             : class VerifyPointersVisitor : public ObjectVisitor, public RootVisitor {
    2491             :  public:
    2492             :   inline void VisitPointers(HeapObject* host, Object** start,
    2493             :                             Object** end) override;
    2494             :   inline void VisitRootPointers(Root root, Object** start,
    2495             :                                 Object** end) override;
    2496             : 
    2497             :  private:
    2498             :   inline void VerifyPointers(Object** start, Object** end);
    2499             : };
    2500             : 
    2501             : 
    2502             : // Verify that all objects are Smis.
    2503             : class VerifySmisVisitor : public RootVisitor {
    2504             :  public:
    2505             :   inline void VisitRootPointers(Root root, Object** start,
    2506             :                                 Object** end) override;
    2507             : };
    2508             : 
    2509             : 
    2510             : // Space iterator for iterating over all spaces of the heap.  Returns each space
    2511             : // in turn, and null when it is done.
    2512             : class AllSpaces BASE_EMBEDDED {
    2513             :  public:
    2514      979397 :   explicit AllSpaces(Heap* heap) : heap_(heap), counter_(FIRST_SPACE) {}
    2515             :   Space* next();
    2516             : 
    2517             :  private:
    2518             :   Heap* heap_;
    2519             :   int counter_;
    2520             : };
    2521             : 
    2522             : 
    2523             : // Space iterator for iterating over all old spaces of the heap: Old space
    2524             : // and code space.  Returns each space in turn, and null when it is done.
    2525             : class V8_EXPORT_PRIVATE OldSpaces BASE_EMBEDDED {
    2526             :  public:
    2527      245014 :   explicit OldSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
    2528             :   OldSpace* next();
    2529             : 
    2530             :  private:
    2531             :   Heap* heap_;
    2532             :   int counter_;
    2533             : };
    2534             : 
    2535             : 
    2536             : // Space iterator for iterating over all the paged spaces of the heap: Map
    2537             : // space, old space, code space and cell space.  Returns
    2538             : // each space in turn, and null when it is done.
    2539             : class PagedSpaces BASE_EMBEDDED {
    2540             :  public:
    2541      174941 :   explicit PagedSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
    2542             :   PagedSpace* next();
    2543             : 
    2544             :  private:
    2545             :   Heap* heap_;
    2546             :   int counter_;
    2547             : };
    2548             : 
    2549             : 
    2550             : class SpaceIterator : public Malloced {
    2551             :  public:
    2552             :   explicit SpaceIterator(Heap* heap);
    2553             :   virtual ~SpaceIterator();
    2554             : 
    2555             :   bool has_next();
    2556             :   Space* next();
    2557             : 
    2558             :  private:
    2559             :   Heap* heap_;
    2560             :   int current_space_;         // from enum AllocationSpace.
    2561             : };
    2562             : 
    2563             : 
    2564             : // A HeapIterator provides iteration over the whole heap. It
    2565             : // aggregates the specific iterators for the different spaces as
    2566             : // these can only iterate over one space only.
    2567             : //
    2568             : // HeapIterator ensures there is no allocation during its lifetime
    2569             : // (using an embedded DisallowHeapAllocation instance).
    2570             : //
    2571             : // HeapIterator can skip free list nodes (that is, de-allocated heap
    2572             : // objects that still remain in the heap). As implementation of free
    2573             : // nodes filtering uses GC marks, it can't be used during MS/MC GC
    2574             : // phases. Also, it is forbidden to interrupt iteration in this mode,
    2575             : // as this will leave heap objects marked (and thus, unusable).
    2576             : class HeapIterator BASE_EMBEDDED {
    2577             :  public:
    2578             :   enum HeapObjectsFiltering { kNoFiltering, kFilterUnreachable };
    2579             : 
    2580             :   explicit HeapIterator(Heap* heap,
    2581             :                         HeapObjectsFiltering filtering = kNoFiltering);
    2582             :   ~HeapIterator();
    2583             : 
    2584             :   HeapObject* next();
    2585             : 
    2586             :  private:
    2587             :   HeapObject* NextObject();
    2588             : 
    2589             :   DisallowHeapAllocation no_heap_allocation_;
    2590             : 
    2591             :   Heap* heap_;
    2592             :   HeapObjectsFiltering filtering_;
    2593             :   HeapObjectsFilter* filter_;
    2594             :   // Space iterator for iterating all the spaces.
    2595             :   SpaceIterator* space_iterator_;
    2596             :   // Object iterator for the space currently being iterated.
    2597             :   std::unique_ptr<ObjectIterator> object_iterator_;
    2598             : };
    2599             : 
    2600             : // Abstract base class for checking whether a weak object should be retained.
    2601       69189 : class WeakObjectRetainer {
    2602             :  public:
    2603      175881 :   virtual ~WeakObjectRetainer() {}
    2604             : 
    2605             :   // Return whether this object should be retained. If NULL is returned the
    2606             :   // object has no references. Otherwise the address of the retained object
    2607             :   // should be returned as in some GC situations the object has been moved.
    2608             :   virtual Object* RetainAs(Object* object) = 0;
    2609             : };
    2610             : 
    2611             : // -----------------------------------------------------------------------------
    2612             : // Allows observation of allocations.
    2613             : class AllocationObserver {
    2614             :  public:
    2615             :   explicit AllocationObserver(intptr_t step_size)
    2616      182418 :       : step_size_(step_size), bytes_to_next_step_(step_size) {
    2617             :     DCHECK(step_size >= kPointerSize);
    2618             :   }
    2619      177927 :   virtual ~AllocationObserver() {}
    2620             : 
    2621             :   // Called each time the observed space does an allocation step. This may be
    2622             :   // more frequently than the step_size we are monitoring (e.g. when there are
    2623             :   // multiple observers, or when page or space boundary is encountered.)
    2624     8911196 :   void AllocationStep(int bytes_allocated, Address soon_object, size_t size) {
    2625     8911196 :     bytes_to_next_step_ -= bytes_allocated;
    2626     8911196 :     if (bytes_to_next_step_ <= 0) {
    2627             :       Step(static_cast<int>(step_size_ - bytes_to_next_step_), soon_object,
    2628      174948 :            size);
    2629      174948 :       step_size_ = GetNextStepSize();
    2630      174948 :       bytes_to_next_step_ = step_size_;
    2631             :     }
    2632     8911196 :   }
    2633             : 
    2634             :  protected:
    2635             :   intptr_t step_size() const { return step_size_; }
    2636             :   intptr_t bytes_to_next_step() const { return bytes_to_next_step_; }
    2637             : 
    2638             :   // Pure virtual method provided by the subclasses that gets called when at
    2639             :   // least step_size bytes have been allocated. soon_object is the address just
    2640             :   // allocated (but not yet initialized.) size is the size of the object as
    2641             :   // requested (i.e. w/o the alignment fillers). Some complexities to be aware
    2642             :   // of:
    2643             :   // 1) soon_object will be nullptr in cases where we end up observing an
    2644             :   //    allocation that happens to be a filler space (e.g. page boundaries.)
    2645             :   // 2) size is the requested size at the time of allocation. Right-trimming
    2646             :   //    may change the object size dynamically.
    2647             :   // 3) soon_object may actually be the first object in an allocation-folding
    2648             :   //    group. In such a case size is the size of the group rather than the
    2649             :   //    first object.
    2650             :   virtual void Step(int bytes_allocated, Address soon_object, size_t size) = 0;
    2651             : 
    2652             :   // Subclasses can override this method to make step size dynamic.
    2653      125903 :   virtual intptr_t GetNextStepSize() { return step_size_; }
    2654             : 
    2655             :   intptr_t step_size_;
    2656             :   intptr_t bytes_to_next_step_;
    2657             : 
    2658             :  private:
    2659             :   friend class LargeObjectSpace;
    2660             :   friend class NewSpace;
    2661             :   friend class PagedSpace;
    2662             :   DISALLOW_COPY_AND_ASSIGN(AllocationObserver);
    2663             : };
    2664             : 
    2665             : V8_EXPORT_PRIVATE const char* AllocationSpaceName(AllocationSpace space);
    2666             : 
    2667             : }  // namespace internal
    2668             : }  // namespace v8
    2669             : 
    2670             : #endif  // V8_HEAP_HEAP_H_

Generated by: LCOV version 1.10