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>
Initialize()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>
VisitJSArrayBuffer(Map * map,HeapObject * object)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>
VisitJSTypedArray(Map * map,HeapObject * object)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>
VisitJSDataView(Map * map,HeapObject * object)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>
Initialize()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>
VisitCodeEntry(Heap * heap,Address entry_address)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>
VisitEmbeddedPointer(Heap * heap,RelocInfo * rinfo)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>
VisitCell(Heap * heap,RelocInfo * rinfo)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>
VisitDebugTarget(Heap * heap,RelocInfo * rinfo)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>
VisitCodeTarget(Heap * heap,RelocInfo * rinfo)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>
VisitCodeAgeSequence(Heap * heap,RelocInfo * rinfo)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>
VisitNativeContext(Map * map,HeapObject * object)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>
VisitMap(Map * map,HeapObject * object)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>
VisitPropertyCell(Map * map,HeapObject * object)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>
VisitAllocationSite(Map * map,HeapObject * object)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>
VisitWeakCollection(Map * map,HeapObject * object)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>
VisitCode(Map * map,HeapObject * object)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>
VisitSharedFunctionInfo(Map * map,HeapObject * object)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>
VisitConstantPoolArray(Map * map,HeapObject * object)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>
VisitJSFunction(Map * map,HeapObject * object)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>
VisitJSRegExp(Map * map,HeapObject * object)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>
VisitJSArrayBuffer(Map * map,HeapObject * object)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>
VisitJSTypedArray(Map * map,HeapObject * object)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>
VisitJSDataView(Map * map,HeapObject * object)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>
MarkMapContents(Heap * heap,Map * map)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>
MarkTransitionArray(Heap * heap,TransitionArray * transitions)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>
MarkInlinedFunctionsCode(Heap * heap,Code * code)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
IsValidNonBuiltinContext(Object * context)697 inline static bool IsValidNonBuiltinContext(Object* context) {
698 return context->IsContext() &&
699 !Context::cast(context)->global_object()->IsJSBuiltinsObject();
700 }
701
702
HasSourceCode(Heap * heap,SharedFunctionInfo * info)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>
IsFlushable(Heap * heap,JSFunction * function)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>
IsFlushable(Heap * heap,SharedFunctionInfo * shared_info)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>
VisitSharedFunctionInfoStrongCode(Heap * heap,HeapObject * object)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>
VisitSharedFunctionInfoWeakCode(Heap * heap,HeapObject * object)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>
VisitJSFunctionStrongCode(Heap * heap,HeapObject * object)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>
VisitJSFunctionWeakCode(Heap * heap,HeapObject * object)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
CodeIterateBody(ObjectVisitor * v)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>
CodeIterateBody(Heap * heap)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