In-object double fields unboxing (for 64-bit only).

src/objects-visiting.h

 // Copyright 2012 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.
 
 #ifndef V8_OBJECTS_VISITING_H_
 #define V8_OBJECTS_VISITING_H_
 
 #include "src/allocation.h"
 
 // This file provides base classes and auxiliary methods for defining
@@ skipping 86 matching lines @@
     kVisitJSObject = kVisitJSObject2,
     kVisitStruct = kVisitStruct2,
     kMinObjectSizeInWords = 2
   };
 
   // Visitor ID should fit in one byte.
   STATIC_ASSERT(kVisitorIdCount <= 256);
 
   // Determine which specialized visitor should be used for given instance type
   // and instance type.
-  static VisitorId GetVisitorId(int instance_type, int instance_size);
+  static VisitorId GetVisitorId(int instance_type, int instance_size,
+                                bool has_non_tagged_fields);
 
   static VisitorId GetVisitorId(Map* map) {
-    return GetVisitorId(map->instance_type(), map->instance_size());
+    return GetVisitorId(map->instance_type(), map->instance_size(),
+                        FLAG_unbox_double_fields &&
+                            !map->layout_descriptor()->IsFastPointerLayout());
   }
 
   // For visitors that allow specialization by size calculate VisitorId based
   // on size, base visitor id and generic visitor id.
-  static VisitorId GetVisitorIdForSize(VisitorId base,
-                                       VisitorId generic,
-                                       int object_size) {
+  static VisitorId GetVisitorIdForSize(VisitorId base, VisitorId generic,
+                                       int object_size,
+                                       bool has_non_tagged_fields) {
     ASSERT((base == kVisitDataObject) ||
            (base == kVisitStruct) ||
            (base == kVisitJSObject));
     ASSERT(IsAligned(object_size, kPointerSize));
     ASSERT(kMinObjectSizeInWords * kPointerSize <= object_size);
     ASSERT(object_size <= Page::kMaxRegularHeapObjectSize);
+    ASSERT(!has_non_tagged_fields || (base == kVisitJSObject));
+
+    if (has_non_tagged_fields) return generic;
 
     const VisitorId specialization = static_cast<VisitorId>(
         base + (object_size >> kPointerSizeLog2) - kMinObjectSizeInWords);
 
     return Min(specialization, generic);
   }
 };
 
 
 template<typename Callback>
@@ skipping 20 matching lines @@
     ASSERT(id < StaticVisitorBase::kVisitorIdCount);  // id is unsigned.
     callbacks_[id] = reinterpret_cast<base::AtomicWord>(callback);
   }
 
   template<typename Visitor,
            StaticVisitorBase::VisitorId base,
            StaticVisitorBase::VisitorId generic,
            int object_size_in_words>
   void RegisterSpecialization() {
     static const int size = object_size_in_words * kPointerSize;
-    Register(StaticVisitorBase::GetVisitorIdForSize(base, generic, size),
+    Register(StaticVisitorBase::GetVisitorIdForSize(base, generic, size, false),
              &Visitor::template VisitSpecialized<size>);
   }
 
 
   template<typename Visitor,
            StaticVisitorBase::VisitorId base,
            StaticVisitorBase::VisitorId generic>
   void RegisterSpecializations() {
     STATIC_ASSERT(
         (generic - base + StaticVisitorBase::kMinObjectSizeInWords) == 10);
@@ skipping 13 matching lines @@
 };
 
 
 template<typename StaticVisitor>
 class BodyVisitorBase : public AllStatic {
  public:
   INLINE(static void IteratePointers(Heap* heap,
                                      HeapObject* object,
                                      int start_offset,
                                      int end_offset)) {
-    Object** start_slot = reinterpret_cast<Object**>(object->address() +
-                                                     start_offset);
-    Object** end_slot = reinterpret_cast<Object**>(object->address() +
-                                                   end_offset);
-    StaticVisitor::VisitPointers(heap, start_slot, end_slot);
+    ASSERT(!FLAG_unbox_double_fields ||
+           object->map()->layout_descriptor()->IsFastPointerLayout());
+    IterateRawPointers(heap, object, start_offset, end_offset);
+  }
+
+  INLINE(static void IterateBody(Heap* heap, HeapObject* object,
+                                 int start_offset, int end_offset)) {
+    if (!FLAG_unbox_double_fields ||
+        object->map()->layout_descriptor()->IsFastPointerLayout()) {
+      IterateRawPointers(heap, object, start_offset, end_offset);
+    } else {
+      IterateBodyUsingLayoutDescriptor(heap, object, start_offset, end_offset);
+    }
+  }
+
+ private:
+  INLINE(static void IterateRawPointers(Heap* heap, HeapObject* object,
+                                        int start_offset, int end_offset)) {
+    StaticVisitor::VisitPointers(heap,
+                                 HeapObject::RawField(object, start_offset),
+                                 HeapObject::RawField(object, end_offset));
+  }
+
+  static void IterateBodyUsingLayoutDescriptor(Heap* heap, HeapObject* object,
+                                               int start_offset,
+                                               int end_offset) {
+    ASSERT(FLAG_unbox_double_fields);
+    ASSERT(IsAligned(start_offset, kPointerSize) &&
+           IsAligned(end_offset, kPointerSize));
+
+    InobjectPropertiesHelper helper(object->map());
+    ASSERT(!helper.all_fields_tagged());
+
+    for (int offset = start_offset; offset < end_offset;
+         offset += kPointerSize) {
+      // Visit tagged fields only.
+      if (helper.IsTagged(offset)) {
+        IterateRawPointers(heap, object, offset, offset + kPointerSize);
+      }
+    }
   }
 };
 
 
 template<typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FlexibleBodyVisitor : public BodyVisitorBase<StaticVisitor> {
  public:
   INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
     int object_size = BodyDescriptor::SizeOf(map, object);
-    BodyVisitorBase<StaticVisitor>::IteratePointers(
-        map->GetHeap(),
-        object,
-        BodyDescriptor::kStartOffset,
-        object_size);
+    BodyVisitorBase<StaticVisitor>::IterateBody(
+        map->GetHeap(), object, BodyDescriptor::kStartOffset, object_size);
     return static_cast<ReturnType>(object_size);
   }
 
   template<int object_size>
   static inline ReturnType VisitSpecialized(Map* map, HeapObject* object) {
     ASSERT(BodyDescriptor::SizeOf(map, object) == object_size);
     BodyVisitorBase<StaticVisitor>::IteratePointers(
         map->GetHeap(),
         object,
         BodyDescriptor::kStartOffset,
         object_size);
     return static_cast<ReturnType>(object_size);
   }
 };
 
 
 template<typename StaticVisitor, typename BodyDescriptor, typename ReturnType>
 class FixedBodyVisitor : public BodyVisitorBase<StaticVisitor> {
  public:
   INLINE(static ReturnType Visit(Map* map, HeapObject* object)) {
-    BodyVisitorBase<StaticVisitor>::IteratePointers(
-        map->GetHeap(),
-        object,
-        BodyDescriptor::kStartOffset,
-        BodyDescriptor::kEndOffset);
+    BodyVisitorBase<StaticVisitor>::IterateBody(map->GetHeap(), object,
+                                                BodyDescriptor::kStartOffset,
+                                                BodyDescriptor::kEndOffset);
     return static_cast<ReturnType>(BodyDescriptor::kSize);
   }
 };
 
 
 // Base class for visitors used for a linear new space iteration.
 // IterateBody returns size of visited object.
 // Certain types of objects (i.e. Code objects) are not handled
 // by dispatch table of this visitor because they cannot appear
 // in the new space.
@@ skipping 215 matching lines @@
 // the next element. Given the head of the list, this function removes dead
 // elements from the list and if requested records slots for next-element
 // pointers. The template parameter T is a WeakListVisitor that defines how to
 // access the next-element pointers.
 template <class T>
 Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_VISITING_H_