Reland of "Enable inobject double fields unboxing for 64-bit archs."

src/heap/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"
 #include "src/layout-descriptor.h"
 
@@ skipping 93 matching lines @@
   // 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,
                                 bool has_unboxed_fields);
 
   // Determine which specialized visitor should be used for given map.
   static VisitorId GetVisitorId(Map* map) {
-    return GetVisitorId(map->instance_type(), map->instance_size(),
-                        FLAG_unbox_double_fields &&
-                            !map->layout_descriptor()->IsFastPointerLayout());
+    return GetVisitorId(
+        map->instance_type(), map->instance_size(),
+        FLAG_unbox_double_fields && !map->HasFastPointerLayout());
   }
 
   // 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,
                                        bool has_unboxed_fields) {
     DCHECK((base == kVisitDataObject) || (base == kVisitStruct) ||
            (base == kVisitJSObject));
     DCHECK(IsAligned(object_size, kPointerSize));
@@ skipping 64 matching lines @@
  private:
   base::AtomicWord callbacks_[StaticVisitorBase::kVisitorIdCount];
 };
 
 
 template <typename StaticVisitor>
 class BodyVisitorBase : public AllStatic {
  public:
   INLINE(static void IteratePointers(Heap* heap, HeapObject* object,
                                      int start_offset, int end_offset)) {
-    DCHECK(!FLAG_unbox_double_fields ||
-           object->map()->layout_descriptor()->IsFastPointerLayout());
+    DCHECK(!FLAG_unbox_double_fields || object->map()->HasFastPointerLayout());
     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()) {
+    if (!FLAG_unbox_double_fields || object->map()->HasFastPointerLayout()) {
       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,
@@ skipping 270 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_