Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(25)

Side by Side Diff: src/heap/mark-compact.cc

Issue 1010363005: Filter invalid slots out from the SlotsBuffer after marking. (Closed) Base URL: https://chromium.googlesource.com/v8/v8.git@master
Patch Set: Rebasing (argh!) Created 5 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/heap/mark-compact.h ('k') | src/heap/spaces.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 the V8 project authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "src/v8.h" 5 #include "src/v8.h"
6 6
7 #include "src/base/atomicops.h" 7 #include "src/base/atomicops.h"
8 #include "src/base/bits.h" 8 #include "src/base/bits.h"
9 #include "src/code-stubs.h" 9 #include "src/code-stubs.h"
10 #include "src/compilation-cache.h" 10 #include "src/compilation-cache.h"
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after
280 heap()->old_data_space()->EvictEvacuationCandidatesFromFreeLists(); 280 heap()->old_data_space()->EvictEvacuationCandidatesFromFreeLists();
281 heap()->code_space()->EvictEvacuationCandidatesFromFreeLists(); 281 heap()->code_space()->EvictEvacuationCandidatesFromFreeLists();
282 282
283 compacting_ = evacuation_candidates_.length() > 0; 283 compacting_ = evacuation_candidates_.length() > 0;
284 } 284 }
285 285
286 return compacting_; 286 return compacting_;
287 } 287 }
288 288
289 289
290 void MarkCompactCollector::ClearInvalidSlotsBufferEntries(PagedSpace* space) {
291 PageIterator it(space);
292 while (it.has_next()) {
293 Page* p = it.next();
294 SlotsBuffer::RemoveInvalidSlots(heap_, p->slots_buffer());
295 }
296 }
297
298
299 void MarkCompactCollector::ClearInvalidStoreAndSlotsBufferEntries() {
300 heap_->store_buffer()->ClearInvalidStoreBufferEntries();
301
302 ClearInvalidSlotsBufferEntries(heap_->old_pointer_space());
303 ClearInvalidSlotsBufferEntries(heap_->old_data_space());
304 ClearInvalidSlotsBufferEntries(heap_->code_space());
305 ClearInvalidSlotsBufferEntries(heap_->cell_space());
306 ClearInvalidSlotsBufferEntries(heap_->map_space());
307
308 LargeObjectIterator it(heap_->lo_space());
309 for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
310 MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
311 SlotsBuffer::RemoveInvalidSlots(heap_, chunk->slots_buffer());
312 }
313 }
314
315
316 #ifdef VERIFY_HEAP
317 static void VerifyValidSlotsBufferEntries(Heap* heap, PagedSpace* space) {
318 PageIterator it(space);
319 while (it.has_next()) {
320 Page* p = it.next();
321 SlotsBuffer::VerifySlots(heap, p->slots_buffer());
322 }
323 }
324
325
326 static void VerifyValidStoreAndSlotsBufferEntries(Heap* heap) {
327 heap->store_buffer()->VerifyValidStoreBufferEntries();
328
329 VerifyValidSlotsBufferEntries(heap, heap->old_pointer_space());
330 VerifyValidSlotsBufferEntries(heap, heap->old_data_space());
331 VerifyValidSlotsBufferEntries(heap, heap->code_space());
332 VerifyValidSlotsBufferEntries(heap, heap->cell_space());
333 VerifyValidSlotsBufferEntries(heap, heap->map_space());
334
335 LargeObjectIterator it(heap->lo_space());
336 for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
337 MemoryChunk* chunk = MemoryChunk::FromAddress(object->address());
338 SlotsBuffer::VerifySlots(heap, chunk->slots_buffer());
339 }
340 }
341 #endif
342
343
290 void MarkCompactCollector::CollectGarbage() { 344 void MarkCompactCollector::CollectGarbage() {
291 // Make sure that Prepare() has been called. The individual steps below will 345 // Make sure that Prepare() has been called. The individual steps below will
292 // update the state as they proceed. 346 // update the state as they proceed.
293 DCHECK(state_ == PREPARE_GC); 347 DCHECK(state_ == PREPARE_GC);
294 348
295 MarkLiveObjects(); 349 MarkLiveObjects();
296 DCHECK(heap_->incremental_marking()->IsStopped()); 350 DCHECK(heap_->incremental_marking()->IsStopped());
297 351
298 // ClearNonLiveReferences can deoptimize code in dependent code arrays. 352 // ClearNonLiveReferences can deoptimize code in dependent code arrays.
299 // Process weak cells before so that weak cells in dependent code 353 // Process weak cells before so that weak cells in dependent code
300 // arrays are cleared or contain only live code objects. 354 // arrays are cleared or contain only live code objects.
301 ProcessAndClearWeakCells(); 355 ProcessAndClearWeakCells();
302 356
303 if (FLAG_collect_maps) ClearNonLiveReferences(); 357 if (FLAG_collect_maps) ClearNonLiveReferences();
304 358
305 ClearWeakCollections(); 359 ClearWeakCollections();
306 360
307 heap_->set_encountered_weak_cells(Smi::FromInt(0)); 361 heap_->set_encountered_weak_cells(Smi::FromInt(0));
308 362
309 #ifdef VERIFY_HEAP 363 #ifdef VERIFY_HEAP
310 if (FLAG_verify_heap) { 364 if (FLAG_verify_heap) {
311 VerifyMarking(heap_); 365 VerifyMarking(heap_);
312 } 366 }
313 #endif 367 #endif
314 368
315 heap_->store_buffer()->ClearInvalidStoreBufferEntries(); 369 ClearInvalidStoreAndSlotsBufferEntries();
316 370
317 #ifdef VERIFY_HEAP 371 #ifdef VERIFY_HEAP
318 if (FLAG_verify_heap) { 372 if (FLAG_verify_heap) {
319 heap_->store_buffer()->VerifyValidStoreBufferEntries(); 373 VerifyValidStoreAndSlotsBufferEntries(heap_);
320 } 374 }
321 #endif 375 #endif
322 376
323 SweepSpaces(); 377 SweepSpaces();
324 378
325 #ifdef VERIFY_HEAP 379 #ifdef VERIFY_HEAP
326 VerifyWeakEmbeddedObjectsInCode(); 380 VerifyWeakEmbeddedObjectsInCode();
327 if (FLAG_collect_maps && FLAG_omit_map_checks_for_leaf_maps) { 381 if (FLAG_collect_maps && FLAG_omit_map_checks_for_leaf_maps) {
328 VerifyOmittedMapChecks(); 382 VerifyOmittedMapChecks();
329 } 383 }
(...skipping 386 matching lines...) Expand 10 before | Expand all | Expand 10 after
716 if (FLAG_trace_fragmentation && 770 if (FLAG_trace_fragmentation &&
717 max_evacuation_candidates >= kMaxMaxEvacuationCandidates) { 771 max_evacuation_candidates >= kMaxMaxEvacuationCandidates) {
718 PrintF("Hit max page compaction limit of %d pages\n", 772 PrintF("Hit max page compaction limit of %d pages\n",
719 kMaxMaxEvacuationCandidates); 773 kMaxMaxEvacuationCandidates);
720 } 774 }
721 max_evacuation_candidates = 775 max_evacuation_candidates =
722 Min(kMaxMaxEvacuationCandidates, max_evacuation_candidates); 776 Min(kMaxMaxEvacuationCandidates, max_evacuation_candidates);
723 777
724 int count = 0; 778 int count = 0;
725 int fragmentation = 0; 779 int fragmentation = 0;
780 int page_number = 0;
726 Candidate* least = NULL; 781 Candidate* least = NULL;
727 782
728 PageIterator it(space); 783 PageIterator it(space);
729 while (it.has_next()) { 784 while (it.has_next()) {
730 Page* p = it.next(); 785 Page* p = it.next();
731 if (p->NeverEvacuate()) continue; 786 if (p->NeverEvacuate()) continue;
732 787
733 // Invariant: Evacuation candidates are just created when marking is 788 // Invariant: Evacuation candidates are just created when marking is
734 // started. At the end of a GC all evacuation candidates are cleared and 789 // started. At the end of a GC all evacuation candidates are cleared and
735 // their slot buffers are released. 790 // their slot buffers are released.
736 CHECK(!p->IsEvacuationCandidate()); 791 CHECK(!p->IsEvacuationCandidate());
737 CHECK(p->slots_buffer() == NULL); 792 CHECK(p->slots_buffer() == NULL);
738 793
739 if (FLAG_stress_compaction) { 794 if (FLAG_stress_compaction) {
740 unsigned int counter = space->heap()->ms_count(); 795 if (FLAG_manual_evacuation_candidates_selection) {
741 uintptr_t page_number = reinterpret_cast<uintptr_t>(p) >> kPageSizeBits; 796 if (p->IsFlagSet(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING)) {
742 if ((counter & 1) == (page_number & 1)) fragmentation = 1; 797 p->ClearFlag(MemoryChunk::FORCE_EVACUATION_CANDIDATE_FOR_TESTING);
798 fragmentation = 1;
799 }
800 } else {
801 unsigned int counter = space->heap()->ms_count();
802 if ((counter & 1) == (page_number & 1)) fragmentation = 1;
803 page_number++;
804 }
743 } else if (mode == REDUCE_MEMORY_FOOTPRINT && !FLAG_always_compact) { 805 } else if (mode == REDUCE_MEMORY_FOOTPRINT && !FLAG_always_compact) {
744 // Don't try to release too many pages. 806 // Don't try to release too many pages.
745 if (estimated_release >= over_reserved) { 807 if (estimated_release >= over_reserved) {
746 continue; 808 continue;
747 } 809 }
748 810
749 intptr_t free_bytes = 0; 811 intptr_t free_bytes = 0;
750 812
751 if (!p->WasSwept()) { 813 if (!p->WasSwept()) {
752 free_bytes = (p->area_size() - p->LiveBytes()); 814 free_bytes = (p->area_size() - p->LiveBytes());
(...skipping 2276 matching lines...) Expand 10 before | Expand all | Expand 10 after
3029 if (allocation.To(&target)) { 3091 if (allocation.To(&target)) {
3030 MigrateObject(target, object, object_size, target_space->identity()); 3092 MigrateObject(target, object, object_size, target_space->identity());
3031 heap()->IncrementPromotedObjectsSize(object_size); 3093 heap()->IncrementPromotedObjectsSize(object_size);
3032 return true; 3094 return true;
3033 } 3095 }
3034 3096
3035 return false; 3097 return false;
3036 } 3098 }
3037 3099
3038 3100
3039 bool MarkCompactCollector::IsSlotInBlackObject(Page* p, Address slot) { 3101 bool MarkCompactCollector::IsSlotInBlackObject(Page* p, Address slot,
3102 HeapObject** out_object) {
3040 // This function does not support large objects right now. 3103 // This function does not support large objects right now.
3041 Space* owner = p->owner(); 3104 Space* owner = p->owner();
3042 if (owner == heap_->lo_space() || owner == NULL) return true; 3105 if (owner == heap_->lo_space() || owner == NULL) {
3106 *out_object = NULL;
3107 return true;
3108 }
3043 3109
3044 uint32_t mark_bit_index = p->AddressToMarkbitIndex(slot); 3110 uint32_t mark_bit_index = p->AddressToMarkbitIndex(slot);
3045 unsigned int start_index = mark_bit_index >> Bitmap::kBitsPerCellLog2; 3111 unsigned int start_index = mark_bit_index >> Bitmap::kBitsPerCellLog2;
3046 MarkBit::CellType index_in_cell = 1U 3112 MarkBit::CellType index_in_cell = 1U
3047 << (mark_bit_index & Bitmap::kBitIndexMask); 3113 << (mark_bit_index & Bitmap::kBitIndexMask);
3048 MarkBit::CellType* cells = p->markbits()->cells(); 3114 MarkBit::CellType* cells = p->markbits()->cells();
3049 Address cell_base = p->area_start(); 3115 Address cell_base = p->area_start();
3050 unsigned int cell_base_start_index = Bitmap::IndexToCell( 3116 unsigned int cell_base_start_index = Bitmap::IndexToCell(
3051 Bitmap::CellAlignIndex(p->AddressToMarkbitIndex(cell_base))); 3117 Bitmap::CellAlignIndex(p->AddressToMarkbitIndex(cell_base)));
3052 3118
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
3086 unsigned int offset = Bitmap::kBitIndexMask - leading_zeros; 3152 unsigned int offset = Bitmap::kBitIndexMask - leading_zeros;
3087 3153
3088 cell_base += (start_index - cell_base_start_index) * 32 * kPointerSize; 3154 cell_base += (start_index - cell_base_start_index) * 32 * kPointerSize;
3089 Address address = cell_base + offset * kPointerSize; 3155 Address address = cell_base + offset * kPointerSize;
3090 HeapObject* object = HeapObject::FromAddress(address); 3156 HeapObject* object = HeapObject::FromAddress(address);
3091 DCHECK(object->address() < reinterpret_cast<Address>(slot)); 3157 DCHECK(object->address() < reinterpret_cast<Address>(slot));
3092 if (object->address() <= slot && 3158 if (object->address() <= slot &&
3093 (object->address() + object->Size()) > slot) { 3159 (object->address() + object->Size()) > slot) {
3094 // If the slot is within the last found object in the cell, the slot is 3160 // If the slot is within the last found object in the cell, the slot is
3095 // in a live object. 3161 // in a live object.
3162 *out_object = object;
3096 return true; 3163 return true;
3097 } 3164 }
3098 return false; 3165 return false;
3099 } 3166 }
3100 3167
3101 3168
3102 bool MarkCompactCollector::IsSlotInBlackObjectSlow(Page* p, Address slot) { 3169 bool MarkCompactCollector::IsSlotInBlackObjectSlow(Page* p, Address slot) {
3103 // This function does not support large objects right now. 3170 // This function does not support large objects right now.
3104 Space* owner = p->owner(); 3171 Space* owner = p->owner();
3105 if (owner == heap_->lo_space() || owner == NULL) return true; 3172 if (owner == heap_->lo_space() || owner == NULL) return true;
(...skipping 21 matching lines...) Expand all
3127 } 3194 }
3128 3195
3129 offset++; 3196 offset++;
3130 current_cell >>= 1; 3197 current_cell >>= 1;
3131 } 3198 }
3132 } 3199 }
3133 return false; 3200 return false;
3134 } 3201 }
3135 3202
3136 3203
3137 bool MarkCompactCollector::IsSlotInLiveObject(HeapObject** address, 3204 bool MarkCompactCollector::IsSlotInLiveObject(Address slot) {
3138 HeapObject* object) { 3205 HeapObject* object = NULL;
3139 // If the target object is not black, the source slot must be part 3206 // The target object is black but we don't know if the source slot is black.
3140 // of a non-black (dead) object. 3207 // The source object could have died and the slot could be part of a free
3141 if (!Marking::IsBlack(Marking::MarkBitFrom(object))) { 3208 // space. Find out based on mark bits if the slot is part of a live object.
3209 if (!IsSlotInBlackObject(Page::FromAddress(slot), slot, &object)) {
3142 return false; 3210 return false;
3143 } 3211 }
3144 3212
3145 // The target object is black but we don't know if the source slot is black. 3213 #if V8_DOUBLE_FIELDS_UNBOXING
3146 // The source object could have died and the slot could be part of a free 3214 // |object| is NULL only when the slot belongs to large object space.
3147 // space. Find out based on mark bits if the slot is part of a live object. 3215 DCHECK(object != NULL ||
3148 if (!IsSlotInBlackObject( 3216 Page::FromAnyPointerAddress(heap_, slot)->owner() ==
3149 Page::FromAddress(reinterpret_cast<Address>(address)), 3217 heap_->lo_space());
3150 reinterpret_cast<Address>(address))) { 3218 // We don't need to check large objects' layout descriptor since it can't
3151 return false; 3219 // contain in-object fields anyway.
3220 if (object != NULL) {
3221 // Filter out slots that happens to point to unboxed double fields.
3222 LayoutDescriptorHelper helper(object->map());
3223 bool has_only_tagged_fields = helper.all_fields_tagged();
3224 if (!has_only_tagged_fields &&
3225 !helper.IsTagged(static_cast<int>(slot - object->address()))) {
3226 return false;
3227 }
3152 } 3228 }
3229 #endif
3153 3230
3154 return true; 3231 return true;
3155 } 3232 }
3156 3233
3157 3234
3158 void MarkCompactCollector::VerifyIsSlotInLiveObject(HeapObject** address, 3235 void MarkCompactCollector::VerifyIsSlotInLiveObject(Address slot,
3159 HeapObject* object) { 3236 HeapObject* object) {
3160 // The target object has to be black. 3237 // The target object has to be black.
3161 CHECK(Marking::IsBlack(Marking::MarkBitFrom(object))); 3238 CHECK(Marking::IsBlack(Marking::MarkBitFrom(object)));
3162 3239
3163 // The target object is black but we don't know if the source slot is black. 3240 // The target object is black but we don't know if the source slot is black.
3164 // The source object could have died and the slot could be part of a free 3241 // The source object could have died and the slot could be part of a free
3165 // space. Use the mark bit iterator to find out about liveness of the slot. 3242 // space. Use the mark bit iterator to find out about liveness of the slot.
3166 CHECK(IsSlotInBlackObjectSlow( 3243 CHECK(IsSlotInBlackObjectSlow(Page::FromAddress(slot), slot));
3167 Page::FromAddress(reinterpret_cast<Address>(address)),
3168 reinterpret_cast<Address>(address)));
3169 } 3244 }
3170 3245
3171 3246
3172 void MarkCompactCollector::EvacuateNewSpace() { 3247 void MarkCompactCollector::EvacuateNewSpace() {
3173 // There are soft limits in the allocation code, designed trigger a mark 3248 // There are soft limits in the allocation code, designed trigger a mark
3174 // sweep collection by failing allocations. But since we are already in 3249 // sweep collection by failing allocations. But since we are already in
3175 // a mark-sweep allocation, there is no sense in trying to trigger one. 3250 // a mark-sweep allocation, there is no sense in trying to trigger one.
3176 AlwaysAllocateScope scope(isolate()); 3251 AlwaysAllocateScope scope(isolate());
3177 3252
3178 NewSpace* new_space = heap()->new_space(); 3253 NewSpace* new_space = heap()->new_space();
(...skipping 1298 matching lines...) Expand 10 before | Expand all | Expand 10 after
4477 buffer = allocator->AllocateBuffer(buffer); 4552 buffer = allocator->AllocateBuffer(buffer);
4478 *buffer_address = buffer; 4553 *buffer_address = buffer;
4479 } 4554 }
4480 DCHECK(buffer->HasSpaceForTypedSlot()); 4555 DCHECK(buffer->HasSpaceForTypedSlot());
4481 buffer->Add(reinterpret_cast<ObjectSlot>(type)); 4556 buffer->Add(reinterpret_cast<ObjectSlot>(type));
4482 buffer->Add(reinterpret_cast<ObjectSlot>(addr)); 4557 buffer->Add(reinterpret_cast<ObjectSlot>(addr));
4483 return true; 4558 return true;
4484 } 4559 }
4485 4560
4486 4561
4562 static Object* g_smi_slot = NULL;
4563
4564
4565 void SlotsBuffer::RemoveInvalidSlots(Heap* heap, SlotsBuffer* buffer) {
4566 DCHECK_EQ(Smi::FromInt(0), g_smi_slot);
4567
4568 // Remove entries by replacing them with a dummy slot containing a smi.
4569 const ObjectSlot kRemovedEntry = &g_smi_slot;
4570
4571 while (buffer != NULL) {
4572 SlotsBuffer::ObjectSlot* slots = buffer->slots_;
4573 intptr_t slots_count = buffer->idx_;
4574
4575 for (int slot_idx = 0; slot_idx < slots_count; ++slot_idx) {
4576 ObjectSlot slot = slots[slot_idx];
4577 if (!IsTypedSlot(slot)) {
4578 Object* object = *slot;
4579 if (object->IsHeapObject()) {
4580 if (heap->InNewSpace(object) ||
4581 !heap->mark_compact_collector()->IsSlotInLiveObject(
4582 reinterpret_cast<Address>(slot))) {
4583 slots[slot_idx] = kRemovedEntry;
4584 }
4585 }
4586 } else {
4587 ++slot_idx;
4588 DCHECK(slot_idx < slots_count);
4589 }
4590 }
4591 buffer = buffer->next();
4592 }
4593 }
4594
4595
4596 void SlotsBuffer::VerifySlots(Heap* heap, SlotsBuffer* buffer) {
4597 DCHECK_EQ(Smi::FromInt(0), g_smi_slot);
4598
4599 while (buffer != NULL) {
4600 SlotsBuffer::ObjectSlot* slots = buffer->slots_;
4601 intptr_t slots_count = buffer->idx_;
4602
4603 for (int slot_idx = 0; slot_idx < slots_count; ++slot_idx) {
4604 ObjectSlot slot = slots[slot_idx];
4605 if (!IsTypedSlot(slot)) {
4606 Object* object = *slot;
4607 if (object->IsHeapObject()) {
4608 CHECK(!heap->InNewSpace(object));
4609 CHECK(heap->mark_compact_collector()->IsSlotInLiveObject(
4610 reinterpret_cast<Address>(slot)));
4611 }
4612 } else {
4613 ++slot_idx;
4614 DCHECK(slot_idx < slots_count);
4615 }
4616 }
4617 buffer = buffer->next();
4618 }
4619 }
4620
4621
4487 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) { 4622 static inline SlotsBuffer::SlotType SlotTypeForRMode(RelocInfo::Mode rmode) {
4488 if (RelocInfo::IsCodeTarget(rmode)) { 4623 if (RelocInfo::IsCodeTarget(rmode)) {
4489 return SlotsBuffer::CODE_TARGET_SLOT; 4624 return SlotsBuffer::CODE_TARGET_SLOT;
4490 } else if (RelocInfo::IsEmbeddedObject(rmode)) { 4625 } else if (RelocInfo::IsEmbeddedObject(rmode)) {
4491 return SlotsBuffer::EMBEDDED_OBJECT_SLOT; 4626 return SlotsBuffer::EMBEDDED_OBJECT_SLOT;
4492 } else if (RelocInfo::IsDebugBreakSlot(rmode)) { 4627 } else if (RelocInfo::IsDebugBreakSlot(rmode)) {
4493 return SlotsBuffer::DEBUG_TARGET_SLOT; 4628 return SlotsBuffer::DEBUG_TARGET_SLOT;
4494 } else if (RelocInfo::IsJSReturn(rmode)) { 4629 } else if (RelocInfo::IsJSReturn(rmode)) {
4495 return SlotsBuffer::JS_RETURN_SLOT; 4630 return SlotsBuffer::JS_RETURN_SLOT;
4496 } 4631 }
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after
4642 SlotsBuffer* buffer = *buffer_address; 4777 SlotsBuffer* buffer = *buffer_address;
4643 while (buffer != NULL) { 4778 while (buffer != NULL) {
4644 SlotsBuffer* next_buffer = buffer->next(); 4779 SlotsBuffer* next_buffer = buffer->next();
4645 DeallocateBuffer(buffer); 4780 DeallocateBuffer(buffer);
4646 buffer = next_buffer; 4781 buffer = next_buffer;
4647 } 4782 }
4648 *buffer_address = NULL; 4783 *buffer_address = NULL;
4649 } 4784 }
4650 } 4785 }
4651 } // namespace v8::internal 4786 } // namespace v8::internal
OLDNEW
« no previous file with comments | « src/heap/mark-compact.h ('k') | src/heap/spaces.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698