Home | History | Annotate | Download | only in heap 
      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_OBJECTS_VISITING_INL_H_
      6 #define V8_OBJECTS_VISITING_INL_H_
      7 
      8 
      9 namespace v8 {
     10 namespace internal {
     11 
     12 template <typename StaticVisitor>
     13 void StaticNewSpaceVisitor<StaticVisitor>::Initialize() {
     14   table_.Register(
     15       kVisitShortcutCandidate,
     16       &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor, int>::Visit);
     17 
     18   table_.Register(
     19       kVisitConsString,
     20       &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor, int>::Visit);
     21 
     22   table_.Register(kVisitSlicedString,
     23                   &FixedBodyVisitor<StaticVisitor, SlicedString::BodyDescriptor,
     24                                     int>::Visit);
     25 
     26   table_.Register(
     27       kVisitSymbol,
     28       &FixedBodyVisitor<StaticVisitor, Symbol::BodyDescriptor, int>::Visit);
     29 
     30   table_.Register(kVisitFixedArray,
     31                   &FlexibleBodyVisitor<StaticVisitor,
     32                                        FixedArray::BodyDescriptor, int>::Visit);
     33 
     34   table_.Register(kVisitFixedDoubleArray, &VisitFixedDoubleArray);
     35   table_.Register(kVisitFixedTypedArray, &VisitFixedTypedArray);
     36   table_.Register(kVisitFixedFloat64Array, &VisitFixedTypedArray);
     37 
     38   table_.Register(
     39       kVisitNativeContext,
     40       &FixedBodyVisitor<StaticVisitor, Context::ScavengeBodyDescriptor,
     41                         int>::Visit);
     42 
     43   table_.Register(kVisitByteArray, &VisitByteArray);
     44 
     45   table_.Register(
     46       kVisitSharedFunctionInfo,
     47       &FixedBodyVisitor<StaticVisitor, SharedFunctionInfo::BodyDescriptor,
     48                         int>::Visit);
     49 
     50   table_.Register(kVisitSeqOneByteString, &VisitSeqOneByteString);
     51 
     52   table_.Register(kVisitSeqTwoByteString, &VisitSeqTwoByteString);
     53 
     54   table_.Register(kVisitJSFunction, &VisitJSFunction);
     55 
     56   table_.Register(kVisitJSArrayBuffer, &VisitJSArrayBuffer);
     57 
     58   table_.Register(kVisitJSTypedArray, &VisitJSTypedArray);
     59 
     60   table_.Register(kVisitJSDataView, &VisitJSDataView);
     61 
     62   table_.Register(kVisitFreeSpace, &VisitFreeSpace);
     63 
     64   table_.Register(kVisitJSWeakCollection, &JSObjectVisitor::Visit);
     65 
     66   table_.Register(kVisitJSRegExp, &JSObjectVisitor::Visit);
     67 
     68   table_.template RegisterSpecializations<DataObjectVisitor, kVisitDataObject,
     69                                           kVisitDataObjectGeneric>();
     70 
     71   table_.template RegisterSpecializations<JSObjectVisitor, kVisitJSObject,
     72                                           kVisitJSObjectGeneric>();
     73   table_.template RegisterSpecializations<StructVisitor, kVisitStruct,
     74                                           kVisitStructGeneric>();
     75 }
     76 
     77 
     78 template <typename StaticVisitor>
     79 int StaticNewSpaceVisitor<StaticVisitor>::VisitJSArrayBuffer(
     80     Map* map, HeapObject* object) {
     81   Heap* heap = map->GetHeap();
     82 
     83   STATIC_ASSERT(JSArrayBuffer::kWeakFirstViewOffset ==
     84                 JSArrayBuffer::kWeakNextOffset + kPointerSize);
     85   VisitPointers(heap, HeapObject::RawField(
     86                           object, JSArrayBuffer::BodyDescriptor::kStartOffset),
     87                 HeapObject::RawField(object, JSArrayBuffer::kWeakNextOffset));
     88   VisitPointers(
     89       heap, HeapObject::RawField(
     90                 object, JSArrayBuffer::kWeakNextOffset + 2 * kPointerSize),
     91       HeapObject::RawField(object, JSArrayBuffer::kSizeWithInternalFields));
     92   return JSArrayBuffer::kSizeWithInternalFields;
     93 }
     94 
     95 
     96 template <typename StaticVisitor>
     97 int StaticNewSpaceVisitor<StaticVisitor>::VisitJSTypedArray(
     98     Map* map, HeapObject* object) {
     99   VisitPointers(
    100       map->GetHeap(),
    101       HeapObject::RawField(object, JSTypedArray::BodyDescriptor::kStartOffset),
    102       HeapObject::RawField(object, JSTypedArray::kWeakNextOffset));
    103   VisitPointers(
    104       map->GetHeap(), HeapObject::RawField(
    105                           object, JSTypedArray::kWeakNextOffset + kPointerSize),
    106       HeapObject::RawField(object, JSTypedArray::kSizeWithInternalFields));
    107   return JSTypedArray::kSizeWithInternalFields;
    108 }
    109 
    110 
    111 template <typename StaticVisitor>
    112 int StaticNewSpaceVisitor<StaticVisitor>::VisitJSDataView(Map* map,
    113                                                           HeapObject* object) {
    114   VisitPointers(
    115       map->GetHeap(),
    116       HeapObject::RawField(object, JSDataView::BodyDescriptor::kStartOffset),
    117       HeapObject::RawField(object, JSDataView::kWeakNextOffset));
    118   VisitPointers(
    119       map->GetHeap(),
    120       HeapObject::RawField(object, JSDataView::kWeakNextOffset + kPointerSize),
    121       HeapObject::RawField(object, JSDataView::kSizeWithInternalFields));
    122   return JSDataView::kSizeWithInternalFields;
    123 }
    124 
    125 
    126 template <typename StaticVisitor>
    127 void StaticMarkingVisitor<StaticVisitor>::Initialize() {
    128   table_.Register(kVisitShortcutCandidate,
    129                   &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor,
    130                                     void>::Visit);
    131 
    132   table_.Register(kVisitConsString,
    133                   &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor,
    134                                     void>::Visit);
    135 
    136   table_.Register(kVisitSlicedString,
    137                   &FixedBodyVisitor<StaticVisitor, SlicedString::BodyDescriptor,
    138                                     void>::Visit);
    139 
    140   table_.Register(
    141       kVisitSymbol,
    142       &FixedBodyVisitor<StaticVisitor, Symbol::BodyDescriptor, void>::Visit);
    143 
    144   table_.Register(kVisitFixedArray, &FixedArrayVisitor::Visit);
    145 
    146   table_.Register(kVisitFixedDoubleArray, &DataObjectVisitor::Visit);
    147 
    148   table_.Register(kVisitFixedTypedArray, &DataObjectVisitor::Visit);
    149 
    150   table_.Register(kVisitFixedFloat64Array, &DataObjectVisitor::Visit);
    151 
    152   table_.Register(kVisitConstantPoolArray, &VisitConstantPoolArray);
    153 
    154   table_.Register(kVisitNativeContext, &VisitNativeContext);
    155 
    156   table_.Register(kVisitAllocationSite, &VisitAllocationSite);
    157 
    158   table_.Register(kVisitByteArray, &DataObjectVisitor::Visit);
    159 
    160   table_.Register(kVisitFreeSpace, &DataObjectVisitor::Visit);
    161 
    162   table_.Register(kVisitSeqOneByteString, &DataObjectVisitor::Visit);
    163 
    164   table_.Register(kVisitSeqTwoByteString, &DataObjectVisitor::Visit);
    165 
    166   table_.Register(kVisitJSWeakCollection, &VisitWeakCollection);
    167 
    168   table_.Register(
    169       kVisitOddball,
    170       &FixedBodyVisitor<StaticVisitor, Oddball::BodyDescriptor, void>::Visit);
    171 
    172   table_.Register(kVisitMap, &VisitMap);
    173 
    174   table_.Register(kVisitCode, &VisitCode);
    175 
    176   table_.Register(kVisitSharedFunctionInfo, &VisitSharedFunctionInfo);
    177 
    178   table_.Register(kVisitJSFunction, &VisitJSFunction);
    179 
    180   table_.Register(kVisitJSArrayBuffer, &VisitJSArrayBuffer);
    181 
    182   table_.Register(kVisitJSTypedArray, &VisitJSTypedArray);
    183 
    184   table_.Register(kVisitJSDataView, &VisitJSDataView);
    185 
    186   // Registration for kVisitJSRegExp is done by StaticVisitor.
    187 
    188   table_.Register(
    189       kVisitCell,
    190       &FixedBodyVisitor<StaticVisitor, Cell::BodyDescriptor, void>::Visit);
    191 
    192   table_.Register(kVisitPropertyCell, &VisitPropertyCell);
    193 
    194   table_.template RegisterSpecializations<DataObjectVisitor, kVisitDataObject,
    195                                           kVisitDataObjectGeneric>();
    196 
    197   table_.template RegisterSpecializations<JSObjectVisitor, kVisitJSObject,
    198                                           kVisitJSObjectGeneric>();
    199 
    200   table_.template RegisterSpecializations<StructObjectVisitor, kVisitStruct,
    201                                           kVisitStructGeneric>();
    202 }
    203 
    204 
    205 template <typename StaticVisitor>
    206 void StaticMarkingVisitor<StaticVisitor>::VisitCodeEntry(
    207     Heap* heap, Address entry_address) {
    208   Code* code = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
    209   heap->mark_compact_collector()->RecordCodeEntrySlot(entry_address, code);
    210   StaticVisitor::MarkObject(heap, code);
    211 }
    212 
    213 
    214 template <typename StaticVisitor>
    215 void StaticMarkingVisitor<StaticVisitor>::VisitEmbeddedPointer(
    216     Heap* heap, RelocInfo* rinfo) {
    217   DCHECK(rinfo->rmode() == RelocInfo::EMBEDDED_OBJECT);
    218   HeapObject* object = HeapObject::cast(rinfo->target_object());
    219   heap->mark_compact_collector()->RecordRelocSlot(rinfo, object);
    220   // TODO(ulan): It could be better to record slots only for strongly embedded
    221   // objects here and record slots for weakly embedded object during clearing
    222   // of non-live references in mark-compact.
    223   if (!rinfo->host()->IsWeakObject(object)) {
    224     StaticVisitor::MarkObject(heap, object);
    225   }
    226 }
    227 
    228 
    229 template <typename StaticVisitor>
    230 void StaticMarkingVisitor<StaticVisitor>::VisitCell(Heap* heap,
    231                                                     RelocInfo* rinfo) {
    232   DCHECK(rinfo->rmode() == RelocInfo::CELL);
    233   Cell* cell = rinfo->target_cell();
    234   // No need to record slots because the cell space is not compacted during GC.
    235   if (!rinfo->host()->IsWeakObject(cell)) {
    236     StaticVisitor::MarkObject(heap, cell);
    237   }
    238 }
    239 
    240 
    241 template <typename StaticVisitor>
    242 void StaticMarkingVisitor<StaticVisitor>::VisitDebugTarget(Heap* heap,
    243                                                            RelocInfo* rinfo) {
    244   DCHECK((RelocInfo::IsJSReturn(rinfo->rmode()) &&
    245           rinfo->IsPatchedReturnSequence()) ||
    246          (RelocInfo::IsDebugBreakSlot(rinfo->rmode()) &&
    247           rinfo->IsPatchedDebugBreakSlotSequence()));
    248   Code* target = Code::GetCodeFromTargetAddress(rinfo->call_address());
    249   heap->mark_compact_collector()->RecordRelocSlot(rinfo, target);
    250   StaticVisitor::MarkObject(heap, target);
    251 }
    252 
    253 
    254 template <typename StaticVisitor>
    255 void StaticMarkingVisitor<StaticVisitor>::VisitCodeTarget(Heap* heap,
    256                                                           RelocInfo* rinfo) {
    257   DCHECK(RelocInfo::IsCodeTarget(rinfo->rmode()));
    258   Code* target = Code::GetCodeFromTargetAddress(rinfo->target_address());
    259   // Monomorphic ICs are preserved when possible, but need to be flushed
    260   // when they might be keeping a Context alive, or when the heap is about
    261   // to be serialized.
    262   if (FLAG_cleanup_code_caches_at_gc && target->is_inline_cache_stub() &&
    263       (target->ic_state() == MEGAMORPHIC || target->ic_state() == GENERIC ||
    264        target->ic_state() == POLYMORPHIC ||
    265        (heap->flush_monomorphic_ics() && !target->is_weak_stub()) ||
    266        heap->isolate()->serializer_enabled() ||
    267        target->ic_age() != heap->global_ic_age() ||
    268        target->is_invalidated_weak_stub())) {
    269     ICUtility::Clear(heap->isolate(), rinfo->pc(),
    270                      rinfo->host()->constant_pool());
    271     target = Code::GetCodeFromTargetAddress(rinfo->target_address());
    272   }
    273   heap->mark_compact_collector()->RecordRelocSlot(rinfo, target);
    274   StaticVisitor::MarkObject(heap, target);
    275 }
    276 
    277 
    278 template <typename StaticVisitor>
    279 void StaticMarkingVisitor<StaticVisitor>::VisitCodeAgeSequence(
    280     Heap* heap, RelocInfo* rinfo) {
    281   DCHECK(RelocInfo::IsCodeAgeSequence(rinfo->rmode()));
    282   Code* target = rinfo->code_age_stub();
    283   DCHECK(target != NULL);
    284   heap->mark_compact_collector()->RecordRelocSlot(rinfo, target);
    285   StaticVisitor::MarkObject(heap, target);
    286 }
    287 
    288 
    289 template <typename StaticVisitor>
    290 void StaticMarkingVisitor<StaticVisitor>::VisitNativeContext(
    291     Map* map, HeapObject* object) {
    292   FixedBodyVisitor<StaticVisitor, Context::MarkCompactBodyDescriptor,
    293                    void>::Visit(map, object);
    294 
    295   MarkCompactCollector* collector = map->GetHeap()->mark_compact_collector();
    296   for (int idx = Context::FIRST_WEAK_SLOT; idx < Context::NATIVE_CONTEXT_SLOTS;
    297        ++idx) {
    298     Object** slot = Context::cast(object)->RawFieldOfElementAt(idx);
    299     collector->RecordSlot(slot, slot, *slot);
    300   }
    301 }
    302 
    303 
    304 template <typename StaticVisitor>
    305 void StaticMarkingVisitor<StaticVisitor>::VisitMap(Map* map,
    306                                                    HeapObject* object) {
    307   Heap* heap = map->GetHeap();
    308   Map* map_object = Map::cast(object);
    309 
    310   // Clears the cache of ICs related to this map.
    311   if (FLAG_cleanup_code_caches_at_gc) {
    312     map_object->ClearCodeCache(heap);
    313   }
    314 
    315   // When map collection is enabled we have to mark through map's transitions
    316   // and back pointers in a special way to make these links weak.
    317   if (FLAG_collect_maps && map_object->CanTransition()) {
    318     MarkMapContents(heap, map_object);
    319   } else {
    320     StaticVisitor::VisitPointers(
    321         heap, HeapObject::RawField(object, Map::kPointerFieldsBeginOffset),
    322         HeapObject::RawField(object, Map::kPointerFieldsEndOffset));
    323   }
    324 }
    325 
    326 
    327 template <typename StaticVisitor>
    328 void StaticMarkingVisitor<StaticVisitor>::VisitPropertyCell(
    329     Map* map, HeapObject* object) {
    330   Heap* heap = map->GetHeap();
    331 
    332   Object** slot =
    333       HeapObject::RawField(object, PropertyCell::kDependentCodeOffset);
    334   if (FLAG_collect_maps) {
    335     // Mark property cell dependent codes array but do not push it onto marking
    336     // stack, this will make references from it weak. We will clean dead
    337     // codes when we iterate over property cells in ClearNonLiveReferences.
    338     HeapObject* obj = HeapObject::cast(*slot);
    339     heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    340     StaticVisitor::MarkObjectWithoutPush(heap, obj);
    341   } else {
    342     StaticVisitor::VisitPointer(heap, slot);
    343   }
    344 
    345   StaticVisitor::VisitPointers(
    346       heap,
    347       HeapObject::RawField(object, PropertyCell::kPointerFieldsBeginOffset),
    348       HeapObject::RawField(object, PropertyCell::kPointerFieldsEndOffset));
    349 }
    350 
    351 
    352 template <typename StaticVisitor>
    353 void StaticMarkingVisitor<StaticVisitor>::VisitAllocationSite(
    354     Map* map, HeapObject* object) {
    355   Heap* heap = map->GetHeap();
    356 
    357   Object** slot =
    358       HeapObject::RawField(object, AllocationSite::kDependentCodeOffset);
    359   if (FLAG_collect_maps) {
    360     // Mark allocation site dependent codes array but do not push it onto
    361     // marking stack, this will make references from it weak. We will clean
    362     // dead codes when we iterate over allocation sites in
    363     // ClearNonLiveReferences.
    364     HeapObject* obj = HeapObject::cast(*slot);
    365     heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    366     StaticVisitor::MarkObjectWithoutPush(heap, obj);
    367   } else {
    368     StaticVisitor::VisitPointer(heap, slot);
    369   }
    370 
    371   StaticVisitor::VisitPointers(
    372       heap,
    373       HeapObject::RawField(object, AllocationSite::kPointerFieldsBeginOffset),
    374       HeapObject::RawField(object, AllocationSite::kPointerFieldsEndOffset));
    375 }
    376 
    377 
    378 template <typename StaticVisitor>
    379 void StaticMarkingVisitor<StaticVisitor>::VisitWeakCollection(
    380     Map* map, HeapObject* object) {
    381   Heap* heap = map->GetHeap();
    382   JSWeakCollection* weak_collection =
    383       reinterpret_cast<JSWeakCollection*>(object);
    384 
    385   // Enqueue weak collection in linked list of encountered weak collections.
    386   if (weak_collection->next() == heap->undefined_value()) {
    387     weak_collection->set_next(heap->encountered_weak_collections());
    388     heap->set_encountered_weak_collections(weak_collection);
    389   }
    390 
    391   // Skip visiting the backing hash table containing the mappings and the
    392   // pointer to the other enqueued weak collections, both are post-processed.
    393   StaticVisitor::VisitPointers(
    394       heap, HeapObject::RawField(object, JSWeakCollection::kPropertiesOffset),
    395       HeapObject::RawField(object, JSWeakCollection::kTableOffset));
    396   STATIC_ASSERT(JSWeakCollection::kTableOffset + kPointerSize ==
    397                 JSWeakCollection::kNextOffset);
    398   STATIC_ASSERT(JSWeakCollection::kNextOffset + kPointerSize ==
    399                 JSWeakCollection::kSize);
    400 
    401   // Partially initialized weak collection is enqueued, but table is ignored.
    402   if (!weak_collection->table()->IsHashTable()) return;
    403 
    404   // Mark the backing hash table without pushing it on the marking stack.
    405   Object** slot = HeapObject::RawField(object, JSWeakCollection::kTableOffset);
    406   HeapObject* obj = HeapObject::cast(*slot);
    407   heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    408   StaticVisitor::MarkObjectWithoutPush(heap, obj);
    409 }
    410 
    411 
    412 template <typename StaticVisitor>
    413 void StaticMarkingVisitor<StaticVisitor>::VisitCode(Map* map,
    414                                                     HeapObject* object) {
    415   Heap* heap = map->GetHeap();
    416   Code* code = Code::cast(object);
    417   if (FLAG_age_code && !heap->isolate()->serializer_enabled()) {
    418     code->MakeOlder(heap->mark_compact_collector()->marking_parity());
    419   }
    420   code->CodeIterateBody<StaticVisitor>(heap);
    421 }
    422 
    423 
    424 template <typename StaticVisitor>
    425 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfo(
    426     Map* map, HeapObject* object) {
    427   Heap* heap = map->GetHeap();
    428   SharedFunctionInfo* shared = SharedFunctionInfo::cast(object);
    429   if (shared->ic_age() != heap->global_ic_age()) {
    430     shared->ResetForNewContext(heap->global_ic_age());
    431   }
    432   if (FLAG_cleanup_code_caches_at_gc) {
    433     shared->ClearTypeFeedbackInfo();
    434   }
    435   if (FLAG_cache_optimized_code && FLAG_flush_optimized_code_cache &&
    436       !shared->optimized_code_map()->IsSmi()) {
    437     // Always flush the optimized code map if requested by flag.
    438     shared->ClearOptimizedCodeMap();
    439   }
    440   MarkCompactCollector* collector = heap->mark_compact_collector();
    441   if (collector->is_code_flushing_enabled()) {
    442     if (FLAG_cache_optimized_code && !shared->optimized_code_map()->IsSmi()) {
    443       // Add the shared function info holding an optimized code map to
    444       // the code flusher for processing of code maps after marking.
    445       collector->code_flusher()->AddOptimizedCodeMap(shared);
    446       // Treat all references within the code map weakly by marking the
    447       // code map itself but not pushing it onto the marking deque.
    448       FixedArray* code_map = FixedArray::cast(shared->optimized_code_map());
    449       StaticVisitor::MarkObjectWithoutPush(heap, code_map);
    450     }
    451     if (IsFlushable(heap, shared)) {
    452       // This function's code looks flushable. But we have to postpone
    453       // the decision until we see all functions that point to the same
    454       // SharedFunctionInfo because some of them might be optimized.
    455       // That would also make the non-optimized version of the code
    456       // non-flushable, because it is required for bailing out from
    457       // optimized code.
    458       collector->code_flusher()->AddCandidate(shared);
    459       // Treat the reference to the code object weakly.
    460       VisitSharedFunctionInfoWeakCode(heap, object);
    461       return;
    462     }
    463   } else {
    464     if (FLAG_cache_optimized_code && !shared->optimized_code_map()->IsSmi()) {
    465       // Flush optimized code map on major GCs without code flushing,
    466       // needed because cached code doesn't contain breakpoints.
    467       shared->ClearOptimizedCodeMap();
    468     }
    469   }
    470   VisitSharedFunctionInfoStrongCode(heap, object);
    471 }
    472 
    473 
    474 template <typename StaticVisitor>
    475 void StaticMarkingVisitor<StaticVisitor>::VisitConstantPoolArray(
    476     Map* map, HeapObject* object) {
    477   Heap* heap = map->GetHeap();
    478   ConstantPoolArray* array = ConstantPoolArray::cast(object);
    479   ConstantPoolArray::Iterator code_iter(array, ConstantPoolArray::CODE_PTR);
    480   while (!code_iter.is_finished()) {
    481     Address code_entry = reinterpret_cast<Address>(
    482         array->RawFieldOfElementAt(code_iter.next_index()));
    483     StaticVisitor::VisitCodeEntry(heap, code_entry);
    484   }
    485 
    486   ConstantPoolArray::Iterator heap_iter(array, ConstantPoolArray::HEAP_PTR);
    487   while (!heap_iter.is_finished()) {
    488     Object** slot = array->RawFieldOfElementAt(heap_iter.next_index());
    489     HeapObject* object = HeapObject::cast(*slot);
    490     heap->mark_compact_collector()->RecordSlot(slot, slot, object);
    491     bool is_weak_object =
    492         (array->get_weak_object_state() ==
    493              ConstantPoolArray::WEAK_OBJECTS_IN_OPTIMIZED_CODE &&
    494          Code::IsWeakObjectInOptimizedCode(object)) ||
    495         (array->get_weak_object_state() ==
    496              ConstantPoolArray::WEAK_OBJECTS_IN_IC &&
    497          Code::IsWeakObjectInIC(object));
    498     if (!is_weak_object) {
    499       StaticVisitor::MarkObject(heap, object);
    500     }
    501   }
    502 }
    503 
    504 
    505 template <typename StaticVisitor>
    506 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunction(Map* map,
    507                                                           HeapObject* object) {
    508   Heap* heap = map->GetHeap();
    509   JSFunction* function = JSFunction::cast(object);
    510   MarkCompactCollector* collector = heap->mark_compact_collector();
    511   if (collector->is_code_flushing_enabled()) {
    512     if (IsFlushable(heap, function)) {
    513       // This function's code looks flushable. But we have to postpone
    514       // the decision until we see all functions that point to the same
    515       // SharedFunctionInfo because some of them might be optimized.
    516       // That would also make the non-optimized version of the code
    517       // non-flushable, because it is required for bailing out from
    518       // optimized code.
    519       collector->code_flusher()->AddCandidate(function);
    520       // Visit shared function info immediately to avoid double checking
    521       // of its flushability later. This is just an optimization because
    522       // the shared function info would eventually be visited.
    523       SharedFunctionInfo* shared = function->shared();
    524       if (StaticVisitor::MarkObjectWithoutPush(heap, shared)) {
    525         StaticVisitor::MarkObject(heap, shared->map());
    526         VisitSharedFunctionInfoWeakCode(heap, shared);
    527       }
    528       // Treat the reference to the code object weakly.
    529       VisitJSFunctionWeakCode(heap, object);
    530       return;
    531     } else {
    532       // Visit all unoptimized code objects to prevent flushing them.
    533       StaticVisitor::MarkObject(heap, function->shared()->code());
    534       if (function->code()->kind() == Code::OPTIMIZED_FUNCTION) {
    535         MarkInlinedFunctionsCode(heap, function->code());
    536       }
    537     }
    538   }
    539   VisitJSFunctionStrongCode(heap, object);
    540 }
    541 
    542 
    543 template <typename StaticVisitor>
    544 void StaticMarkingVisitor<StaticVisitor>::VisitJSRegExp(Map* map,
    545                                                         HeapObject* object) {
    546   int last_property_offset =
    547       JSRegExp::kSize + kPointerSize * map->inobject_properties();
    548   StaticVisitor::VisitPointers(
    549       map->GetHeap(), HeapObject::RawField(object, JSRegExp::kPropertiesOffset),
    550       HeapObject::RawField(object, last_property_offset));
    551 }
    552 
    553 
    554 template <typename StaticVisitor>
    555 void StaticMarkingVisitor<StaticVisitor>::VisitJSArrayBuffer(
    556     Map* map, HeapObject* object) {
    557   Heap* heap = map->GetHeap();
    558 
    559   STATIC_ASSERT(JSArrayBuffer::kWeakFirstViewOffset ==
    560                 JSArrayBuffer::kWeakNextOffset + kPointerSize);
    561   StaticVisitor::VisitPointers(
    562       heap,
    563       HeapObject::RawField(object, JSArrayBuffer::BodyDescriptor::kStartOffset),
    564       HeapObject::RawField(object, JSArrayBuffer::kWeakNextOffset));
    565   StaticVisitor::VisitPointers(
    566       heap, HeapObject::RawField(
    567                 object, JSArrayBuffer::kWeakNextOffset + 2 * kPointerSize),
    568       HeapObject::RawField(object, JSArrayBuffer::kSizeWithInternalFields));
    569 }
    570 
    571 
    572 template <typename StaticVisitor>
    573 void StaticMarkingVisitor<StaticVisitor>::VisitJSTypedArray(
    574     Map* map, HeapObject* object) {
    575   StaticVisitor::VisitPointers(
    576       map->GetHeap(),
    577       HeapObject::RawField(object, JSTypedArray::BodyDescriptor::kStartOffset),
    578       HeapObject::RawField(object, JSTypedArray::kWeakNextOffset));
    579   StaticVisitor::VisitPointers(
    580       map->GetHeap(), HeapObject::RawField(
    581                           object, JSTypedArray::kWeakNextOffset + kPointerSize),
    582       HeapObject::RawField(object, JSTypedArray::kSizeWithInternalFields));
    583 }
    584 
    585 
    586 template <typename StaticVisitor>
    587 void StaticMarkingVisitor<StaticVisitor>::VisitJSDataView(Map* map,
    588                                                           HeapObject* object) {
    589   StaticVisitor::VisitPointers(
    590       map->GetHeap(),
    591       HeapObject::RawField(object, JSDataView::BodyDescriptor::kStartOffset),
    592       HeapObject::RawField(object, JSDataView::kWeakNextOffset));
    593   StaticVisitor::VisitPointers(
    594       map->GetHeap(),
    595       HeapObject::RawField(object, JSDataView::kWeakNextOffset + kPointerSize),
    596       HeapObject::RawField(object, JSDataView::kSizeWithInternalFields));
    597 }
    598 
    599 
    600 template <typename StaticVisitor>
    601 void StaticMarkingVisitor<StaticVisitor>::MarkMapContents(Heap* heap,
    602                                                           Map* map) {
    603   // Make sure that the back pointer stored either in the map itself or
    604   // inside its transitions array is marked. Skip recording the back
    605   // pointer slot since map space is not compacted.
    606   StaticVisitor::MarkObject(heap, HeapObject::cast(map->GetBackPointer()));
    607 
    608   // Treat pointers in the transitions array as weak and also mark that
    609   // array to prevent visiting it later. Skip recording the transition
    610   // array slot, since it will be implicitly recorded when the pointer
    611   // fields of this map are visited.
    612   if (map->HasTransitionArray()) {
    613     TransitionArray* transitions = map->transitions();
    614     MarkTransitionArray(heap, transitions);
    615   }
    616 
    617   // Since descriptor arrays are potentially shared, ensure that only the
    618   // descriptors that belong to this map are marked. The first time a
    619   // non-empty descriptor array is marked, its header is also visited. The slot
    620   // holding the descriptor array will be implicitly recorded when the pointer
    621   // fields of this map are visited.
    622   DescriptorArray* descriptors = map->instance_descriptors();
    623   if (StaticVisitor::MarkObjectWithoutPush(heap, descriptors) &&
    624       descriptors->length() > 0) {
    625     StaticVisitor::VisitPointers(heap, descriptors->GetFirstElementAddress(),
    626                                  descriptors->GetDescriptorEndSlot(0));
    627   }
    628   int start = 0;
    629   int end = map->NumberOfOwnDescriptors();
    630   if (start < end) {
    631     StaticVisitor::VisitPointers(heap,
    632                                  descriptors->GetDescriptorStartSlot(start),
    633                                  descriptors->GetDescriptorEndSlot(end));
    634   }
    635 
    636   // Mark prototype dependent codes array but do not push it onto marking
    637   // stack, this will make references from it weak. We will clean dead
    638   // codes when we iterate over maps in ClearNonLiveTransitions.
    639   Object** slot = HeapObject::RawField(map, Map::kDependentCodeOffset);
    640   HeapObject* obj = HeapObject::cast(*slot);
    641   heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    642   StaticVisitor::MarkObjectWithoutPush(heap, obj);
    643 
    644   // Mark the pointer fields of the Map. Since the transitions array has
    645   // been marked already, it is fine that one of these fields contains a
    646   // pointer to it.
    647   StaticVisitor::VisitPointers(
    648       heap, HeapObject::RawField(map, Map::kPointerFieldsBeginOffset),
    649       HeapObject::RawField(map, Map::kPointerFieldsEndOffset));
    650 }
    651 
    652 
    653 template <typename StaticVisitor>
    654 void StaticMarkingVisitor<StaticVisitor>::MarkTransitionArray(
    655     Heap* heap, TransitionArray* transitions) {
    656   if (!StaticVisitor::MarkObjectWithoutPush(heap, transitions)) return;
    657 
    658   // Simple transitions do not have keys nor prototype transitions.
    659   if (transitions->IsSimpleTransition()) return;
    660 
    661   if (transitions->HasPrototypeTransitions()) {
    662     // Mark prototype transitions array but do not push it onto marking
    663     // stack, this will make references from it weak. We will clean dead
    664     // prototype transitions in ClearNonLiveTransitions.
    665     Object** slot = transitions->GetPrototypeTransitionsSlot();
    666     HeapObject* obj = HeapObject::cast(*slot);
    667     heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    668     StaticVisitor::MarkObjectWithoutPush(heap, obj);
    669   }
    670 
    671   for (int i = 0; i < transitions->number_of_transitions(); ++i) {
    672     StaticVisitor::VisitPointer(heap, transitions->GetKeySlot(i));
    673   }
    674 }
    675 
    676 
    677 template <typename StaticVisitor>
    678 void StaticMarkingVisitor<StaticVisitor>::MarkInlinedFunctionsCode(Heap* heap,
    679                                                                    Code* code) {
    680   // Skip in absence of inlining.
    681   // TODO(turbofan): Revisit once we support inlining.
    682   if (code->is_turbofanned()) return;
    683   // For optimized functions we should retain both non-optimized version
    684   // of its code and non-optimized version of all inlined functions.
    685   // This is required to support bailing out from inlined code.
    686   DeoptimizationInputData* data =
    687       DeoptimizationInputData::cast(code->deoptimization_data());
    688   FixedArray* literals = data->LiteralArray();
    689   for (int i = 0, count = data->InlinedFunctionCount()->value(); i < count;
    690        i++) {
    691     JSFunction* inlined = JSFunction::cast(literals->get(i));
    692     StaticVisitor::MarkObject(heap, inlined->shared()->code());
    693   }
    694 }
    695 
    696 
    697 inline static bool IsValidNonBuiltinContext(Object* context) {
    698   return context->IsContext() &&
    699          !Context::cast(context)->global_object()->IsJSBuiltinsObject();
    700 }
    701 
    702 
    703 inline static bool HasSourceCode(Heap* heap, SharedFunctionInfo* info) {
    704   Object* undefined = heap->undefined_value();
    705   return (info->script() != undefined) &&
    706          (reinterpret_cast<Script*>(info->script())->source() != undefined);
    707 }
    708 
    709 
    710 template <typename StaticVisitor>
    711 bool StaticMarkingVisitor<StaticVisitor>::IsFlushable(Heap* heap,
    712                                                       JSFunction* function) {
    713   SharedFunctionInfo* shared_info = function->shared();
    714 
    715   // Code is either on stack, in compilation cache or referenced
    716   // by optimized version of function.
    717   MarkBit code_mark = Marking::MarkBitFrom(function->code());
    718   if (code_mark.Get()) {
    719     return false;
    720   }
    721 
    722   // The function must have a valid context and not be a builtin.
    723   if (!IsValidNonBuiltinContext(function->context())) {
    724     return false;
    725   }
    726 
    727   // We do not (yet) flush code for optimized functions.
    728   if (function->code() != shared_info->code()) {
    729     return false;
    730   }
    731 
    732   // Check age of optimized code.
    733   if (FLAG_age_code && !function->code()->IsOld()) {
    734     return false;
    735   }
    736 
    737   return IsFlushable(heap, shared_info);
    738 }
    739 
    740 
    741 template <typename StaticVisitor>
    742 bool StaticMarkingVisitor<StaticVisitor>::IsFlushable(
    743     Heap* heap, SharedFunctionInfo* shared_info) {
    744   // Code is either on stack, in compilation cache or referenced
    745   // by optimized version of function.
    746   MarkBit code_mark = Marking::MarkBitFrom(shared_info->code());
    747   if (code_mark.Get()) {
    748     return false;
    749   }
    750 
    751   // The function must be compiled and have the source code available,
    752   // to be able to recompile it in case we need the function again.
    753   if (!(shared_info->is_compiled() && HasSourceCode(heap, shared_info))) {
    754     return false;
    755   }
    756 
    757   // We never flush code for API functions.
    758   Object* function_data = shared_info->function_data();
    759   if (function_data->IsFunctionTemplateInfo()) {
    760     return false;
    761   }
    762 
    763   // Only flush code for functions.
    764   if (shared_info->code()->kind() != Code::FUNCTION) {
    765     return false;
    766   }
    767 
    768   // Function must be lazy compilable.
    769   if (!shared_info->allows_lazy_compilation()) {
    770     return false;
    771   }
    772 
    773   // We do not (yet?) flush code for generator functions, because we don't know
    774   // if there are still live activations (generator objects) on the heap.
    775   if (shared_info->is_generator()) {
    776     return false;
    777   }
    778 
    779   // If this is a full script wrapped in a function we do not flush the code.
    780   if (shared_info->is_toplevel()) {
    781     return false;
    782   }
    783 
    784   // If this is a function initialized with %SetCode then the one-to-one
    785   // relation between SharedFunctionInfo and Code is broken.
    786   if (shared_info->dont_flush()) {
    787     return false;
    788   }
    789 
    790   // Check age of code. If code aging is disabled we never flush.
    791   if (!FLAG_age_code || !shared_info->code()->IsOld()) {
    792     return false;
    793   }
    794 
    795   return true;
    796 }
    797 
    798 
    799 template <typename StaticVisitor>
    800 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfoStrongCode(
    801     Heap* heap, HeapObject* object) {
    802   Object** start_slot = HeapObject::RawField(
    803       object, SharedFunctionInfo::BodyDescriptor::kStartOffset);
    804   Object** end_slot = HeapObject::RawField(
    805       object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
    806   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    807 }
    808 
    809 
    810 template <typename StaticVisitor>
    811 void StaticMarkingVisitor<StaticVisitor>::VisitSharedFunctionInfoWeakCode(
    812     Heap* heap, HeapObject* object) {
    813   Object** name_slot =
    814       HeapObject::RawField(object, SharedFunctionInfo::kNameOffset);
    815   StaticVisitor::VisitPointer(heap, name_slot);
    816 
    817   // Skip visiting kCodeOffset as it is treated weakly here.
    818   STATIC_ASSERT(SharedFunctionInfo::kNameOffset + kPointerSize ==
    819                 SharedFunctionInfo::kCodeOffset);
    820   STATIC_ASSERT(SharedFunctionInfo::kCodeOffset + kPointerSize ==
    821                 SharedFunctionInfo::kOptimizedCodeMapOffset);
    822 
    823   Object** start_slot =
    824       HeapObject::RawField(object, SharedFunctionInfo::kOptimizedCodeMapOffset);
    825   Object** end_slot = HeapObject::RawField(
    826       object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
    827   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    828 }
    829 
    830 
    831 template <typename StaticVisitor>
    832 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionStrongCode(
    833     Heap* heap, HeapObject* object) {
    834   Object** start_slot =
    835       HeapObject::RawField(object, JSFunction::kPropertiesOffset);
    836   Object** end_slot =
    837       HeapObject::RawField(object, JSFunction::kCodeEntryOffset);
    838   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    839 
    840   VisitCodeEntry(heap, object->address() + JSFunction::kCodeEntryOffset);
    841   STATIC_ASSERT(JSFunction::kCodeEntryOffset + kPointerSize ==
    842                 JSFunction::kPrototypeOrInitialMapOffset);
    843 
    844   start_slot =
    845       HeapObject::RawField(object, JSFunction::kPrototypeOrInitialMapOffset);
    846   end_slot = HeapObject::RawField(object, JSFunction::kNonWeakFieldsEndOffset);
    847   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    848 }
    849 
    850 
    851 template <typename StaticVisitor>
    852 void StaticMarkingVisitor<StaticVisitor>::VisitJSFunctionWeakCode(
    853     Heap* heap, HeapObject* object) {
    854   Object** start_slot =
    855       HeapObject::RawField(object, JSFunction::kPropertiesOffset);
    856   Object** end_slot =
    857       HeapObject::RawField(object, JSFunction::kCodeEntryOffset);
    858   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    859 
    860   // Skip visiting kCodeEntryOffset as it is treated weakly here.
    861   STATIC_ASSERT(JSFunction::kCodeEntryOffset + kPointerSize ==
    862                 JSFunction::kPrototypeOrInitialMapOffset);
    863 
    864   start_slot =
    865       HeapObject::RawField(object, JSFunction::kPrototypeOrInitialMapOffset);
    866   end_slot = HeapObject::RawField(object, JSFunction::kNonWeakFieldsEndOffset);
    867   StaticVisitor::VisitPointers(heap, start_slot, end_slot);
    868 }
    869 
    870 
    871 void Code::CodeIterateBody(ObjectVisitor* v) {
    872   int mode_mask = RelocInfo::kCodeTargetMask |
    873                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
    874                   RelocInfo::ModeMask(RelocInfo::CELL) |
    875                   RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
    876                   RelocInfo::ModeMask(RelocInfo::JS_RETURN) |
    877                   RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT) |
    878                   RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
    879 
    880   // There are two places where we iterate code bodies: here and the
    881   // templated CodeIterateBody (below). They should be kept in sync.
    882   IteratePointer(v, kRelocationInfoOffset);
    883   IteratePointer(v, kHandlerTableOffset);
    884   IteratePointer(v, kDeoptimizationDataOffset);
    885   IteratePointer(v, kTypeFeedbackInfoOffset);
    886   IterateNextCodeLink(v, kNextCodeLinkOffset);
    887   IteratePointer(v, kConstantPoolOffset);
    888 
    889   RelocIterator it(this, mode_mask);
    890   Isolate* isolate = this->GetIsolate();
    891   for (; !it.done(); it.next()) {
    892     it.rinfo()->Visit(isolate, v);
    893   }
    894 }
    895 
    896 
    897 template <typename StaticVisitor>
    898 void Code::CodeIterateBody(Heap* heap) {
    899   int mode_mask = RelocInfo::kCodeTargetMask |
    900                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
    901                   RelocInfo::ModeMask(RelocInfo::CELL) |
    902                   RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
    903                   RelocInfo::ModeMask(RelocInfo::JS_RETURN) |
    904                   RelocInfo::ModeMask(RelocInfo::DEBUG_BREAK_SLOT) |
    905                   RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);
    906 
    907   // There are two places where we iterate code bodies: here and the non-
    908   // templated CodeIterateBody (above). They should be kept in sync.
    909   StaticVisitor::VisitPointer(
    910       heap,
    911       reinterpret_cast<Object**>(this->address() + kRelocationInfoOffset));
    912   StaticVisitor::VisitPointer(
    913       heap, reinterpret_cast<Object**>(this->address() + kHandlerTableOffset));
    914   StaticVisitor::VisitPointer(
    915       heap,
    916       reinterpret_cast<Object**>(this->address() + kDeoptimizationDataOffset));
    917   StaticVisitor::VisitPointer(
    918       heap,
    919       reinterpret_cast<Object**>(this->address() + kTypeFeedbackInfoOffset));
    920   StaticVisitor::VisitNextCodeLink(
    921       heap, reinterpret_cast<Object**>(this->address() + kNextCodeLinkOffset));
    922   StaticVisitor::VisitPointer(
    923       heap, reinterpret_cast<Object**>(this->address() + kConstantPoolOffset));
    924 
    925 
    926   RelocIterator it(this, mode_mask);
    927   for (; !it.done(); it.next()) {
    928     it.rinfo()->template Visit<StaticVisitor>(heap);
    929   }
    930 }
    931 }
    932 }  // namespace v8::internal
    933 
    934 #endif  // V8_OBJECTS_VISITING_INL_H_
    935