Avoid manual object's body traversal in GC.

src/heap/store-buffer.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/heap/store-buffer.h"
 
 #include <algorithm>
 
 #include "src/counters.h"
 #include "src/heap/incremental-marking.h"
@@ skipping 394 matching lines @@
     Object** slot = reinterpret_cast<Object**>(*current);
     Object* object = *slot;
     CHECK(object->IsHeapObject());
     CHECK(heap_->InNewSpace(object));
     heap_->mark_compact_collector()->VerifyIsSlotInLiveObject(
         reinterpret_cast<Address>(slot), HeapObject::cast(object));
   }
 }
 
 
+class FindPointersToNewSpaceVisitor final : public ObjectVisitor {
+ public:
+  FindPointersToNewSpaceVisitor(StoreBuffer* store_buffer,
+                                ObjectSlotCallback callback)
+      : store_buffer_(store_buffer), callback_(callback) {}
+
+  V8_INLINE void VisitPointers(Object** start, Object** end) override {
+    store_buffer_->FindPointersToNewSpaceInRegion(
+        reinterpret_cast<Address>(start), reinterpret_cast<Address>(end),
+        callback_);
+  }
+
+  V8_INLINE void VisitCodeEntry(Address code_entry_slot) override {}
+
+ private:
+  StoreBuffer* store_buffer_;
+  ObjectSlotCallback callback_;
+};
+
+
 void StoreBuffer::IteratePointersToNewSpace(ObjectSlotCallback slot_callback) {
   // We do not sort or remove duplicated entries from the store buffer because
   // we expect that callback will rebuild the store buffer thus removing
   // all duplicates and pointers to old space.
   bool some_pages_to_scan = PrepareForIteration();
 
   // TODO(gc): we want to skip slots on evacuation candidates
   // but we can't simply figure that out from slot address
   // because slot can belong to a large object.
   IteratePointersInStoreBuffer(slot_callback);
 
   // We are done scanning all the pointers that were in the store buffer, but
   // there may be some pages marked scan_on_scavenge that have pointers to new
   // space that are not in the store buffer.  We must scan them now.  As we
   // scan, the surviving pointers to new space will be added to the store
   // buffer.  If there are still a lot of pointers to new space then we will
   // keep the scan_on_scavenge flag on the page and discard the pointers that
   // were added to the store buffer.  If there are not many pointers to new
   // space left on the page we will keep the pointers in the store buffer and
   // remove the flag from the page.
   if (some_pages_to_scan) {
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferStartScanningPagesEvent);
     }
     PointerChunkIterator it(heap_);
     MemoryChunk* chunk;
+    FindPointersToNewSpaceVisitor visitor(this, slot_callback);
     while ((chunk = it.next()) != NULL) {
       if (chunk->scan_on_scavenge()) {
         chunk->set_scan_on_scavenge(false);
         if (callback_ != NULL) {
           (*callback_)(heap_, chunk, kStoreBufferScanningPageEvent);
         }
         if (chunk->owner() == heap_->lo_space()) {
           LargePage* large_page = reinterpret_cast<LargePage*>(chunk);
           HeapObject* array = large_page->GetObject();
           DCHECK(array->IsFixedArray());
@@ skipping 17 matching lines @@
                     slot_callback);
               }
             }
           } else {
             heap_->mark_compact_collector()->SweepOrWaitUntilSweepingCompleted(
                 page);
             HeapObjectIterator iterator(page);
             for (HeapObject* heap_object = iterator.Next(); heap_object != NULL;
                  heap_object = iterator.Next()) {
               // We iterate over objects that contain new space pointers only.
-              Address obj_address = heap_object->address();
-              const int start_offset = HeapObject::kHeaderSize;
-              const int end_offset = heap_object->Size();
-
-              switch (heap_object->ContentType()) {
-                case HeapObjectContents::kTaggedValues: {
-                  Address start_address = obj_address + start_offset;
-                  Address end_address = obj_address + end_offset;
-                  // Object has only tagged fields.
-                  FindPointersToNewSpaceInRegion(start_address, end_address,
-                                                 slot_callback);
-                  break;
-                }
-
-                case HeapObjectContents::kMixedValues: {
-                  if (heap_object->IsFixedTypedArrayBase()) {
-                    FindPointersToNewSpaceInRegion(
-                        obj_address + FixedTypedArrayBase::kBasePointerOffset,
-                        obj_address + FixedTypedArrayBase::kHeaderSize,
-                        slot_callback);
-                  } else if (heap_object->IsBytecodeArray()) {
-                    FindPointersToNewSpaceInRegion(
-                        obj_address + BytecodeArray::kConstantPoolOffset,
-                        obj_address + BytecodeArray::kHeaderSize,
-                        slot_callback);
-                  } else if (heap_object->IsJSArrayBuffer()) {
-                    FindPointersToNewSpaceInRegion(
-                        obj_address + JSArrayBuffer::kPropertiesOffset,
-                        obj_address + JSArrayBuffer::kByteLengthOffset +
-                            kPointerSize,
-                        slot_callback);
-                    FindPointersToNewSpaceInRegion(
-                        obj_address + JSArrayBuffer::kSize,
-                        obj_address + JSArrayBuffer::kSizeWithInternalFields,
-                        slot_callback);
-                  } else if (FLAG_unbox_double_fields) {
-                    LayoutDescriptorHelper helper(heap_object->map());
-                    DCHECK(!helper.all_fields_tagged());
-                    for (int offset = start_offset; offset < end_offset;) {
-                      int end_of_region_offset;
-                      if (helper.IsTagged(offset, end_offset,
-                                          &end_of_region_offset)) {
-                        FindPointersToNewSpaceInRegion(
-                            obj_address + offset,
-                            obj_address + end_of_region_offset, slot_callback);
-                      }
-                      offset = end_of_region_offset;
-                    }
-                  } else {
-                    UNREACHABLE();
-                  }
-                  break;
-                }
-
-                case HeapObjectContents::kRawValues:
-                  break;
-              }
+              heap_object->IterateBody(&visitor);
             }
           }
         }
       }
     }
     if (callback_ != NULL) {
       (*callback_)(heap_, NULL, kStoreBufferScanningPageEvent);
     }
   }
 }
@@ skipping 95 matching lines @@
       DCHECK(start_of_current_page_ != store_buffer_->Top());
       store_buffer_->SetTop(start_of_current_page_);
     }
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace internal
 }  // namespace v8