LCOV - code coverage report
Current view: top level - src - objects-body-descriptors-inl.h (source / functions) Hit Total Coverage
Test: app.info Lines: 112 152 73.7 %
Date: 2017-04-26 Functions: 74 85 87.1 %

          Line data    Source code
       1             : // Copyright 2015 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_BODY_DESCRIPTORS_INL_H_
       6             : #define V8_OBJECTS_BODY_DESCRIPTORS_INL_H_
       7             : 
       8             : #include "src/assembler-inl.h"
       9             : #include "src/objects-body-descriptors.h"
      10             : #include "src/transitions.h"
      11             : 
      12             : namespace v8 {
      13             : namespace internal {
      14             : 
      15             : template <int start_offset>
      16    84173849 : int FlexibleBodyDescriptor<start_offset>::SizeOf(Map* map, HeapObject* object) {
      17    84217483 :   return object->SizeFromMap(map);
      18             : }
      19             : 
      20           0 : bool BodyDescriptorBase::IsValidSlotImpl(HeapObject* obj, int offset) {
      21           0 :   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
      22             :     return true;
      23             :   } else {
      24             :     DCHECK(FLAG_unbox_double_fields);
      25             :     DCHECK(IsAligned(offset, kPointerSize));
      26             : 
      27           0 :     LayoutDescriptorHelper helper(obj->map());
      28             :     DCHECK(!helper.all_fields_tagged());
      29           0 :     return helper.IsTagged(offset);
      30             :   }
      31             : }
      32             : 
      33             : template <typename ObjectVisitor>
      34    20078890 : void BodyDescriptorBase::IterateBodyImpl(HeapObject* obj, int start_offset,
      35             :                                          int end_offset, ObjectVisitor* v) {
      36    20078890 :   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
      37     2982180 :     IteratePointers(obj, start_offset, end_offset, v);
      38             :   } else {
      39             :     DCHECK(FLAG_unbox_double_fields);
      40             :     DCHECK(IsAligned(start_offset, kPointerSize) &&
      41             :            IsAligned(end_offset, kPointerSize));
      42             : 
      43       96409 :     LayoutDescriptorHelper helper(obj->map());
      44             :     DCHECK(!helper.all_fields_tagged());
      45      404544 :     for (int offset = start_offset; offset < end_offset;) {
      46             :       int end_of_region_offset;
      47      211726 :       if (helper.IsTagged(offset, end_offset, &end_of_region_offset)) {
      48      115288 :         IteratePointers(obj, offset, end_of_region_offset, v);
      49             :       }
      50      211726 :       offset = end_of_region_offset;
      51             :     }
      52             :   }
      53    19989454 : }
      54             : 
      55             : template <typename StaticVisitor>
      56    64349865 : void BodyDescriptorBase::IterateBodyImpl(Heap* heap, HeapObject* obj,
      57             :                                          int start_offset, int end_offset) {
      58    64349865 :   if (!FLAG_unbox_double_fields || obj->map()->HasFastPointerLayout()) {
      59    62204741 :     IteratePointers<StaticVisitor>(heap, obj, start_offset, end_offset);
      60             :   } else {
      61             :     DCHECK(FLAG_unbox_double_fields);
      62             :     DCHECK(IsAligned(start_offset, kPointerSize) &&
      63             :            IsAligned(end_offset, kPointerSize));
      64             : 
      65      143052 :     LayoutDescriptorHelper helper(obj->map());
      66             :     DCHECK(!helper.all_fields_tagged());
      67      597738 :     for (int offset = start_offset; offset < end_offset;) {
      68             :       int end_of_region_offset;
      69      311634 :       if (helper.IsTagged(offset, end_offset, &end_of_region_offset)) {
      70      168523 :         IteratePointers<StaticVisitor>(heap, obj, offset, end_of_region_offset);
      71             :       }
      72      311634 :       offset = end_of_region_offset;
      73             :     }
      74             :   }
      75    64349865 : }
      76             : 
      77             : template <typename ObjectVisitor>
      78    10590028 : DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(HeapObject* obj,
      79             :                                                           int start_offset,
      80             :                                                           int end_offset,
      81             :                                                           ObjectVisitor* v) {
      82   158285759 :   v->VisitPointers(obj, HeapObject::RawField(obj, start_offset),
      83             :                    HeapObject::RawField(obj, end_offset));
      84    10611503 : }
      85             : 
      86             : template <typename StaticVisitor>
      87   418224535 : DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(Heap* heap,
      88             :                                                           HeapObject* obj,
      89             :                                                           int start_offset,
      90             :                                                           int end_offset) {
      91             :   StaticVisitor::VisitPointers(heap, obj,
      92             :                                HeapObject::RawField(obj, start_offset),
      93             :                                HeapObject::RawField(obj, end_offset));
      94   418224311 : }
      95             : 
      96             : template <typename ObjectVisitor>
      97             : void BodyDescriptorBase::IteratePointer(HeapObject* obj, int offset,
      98             :                                         ObjectVisitor* v) {
      99    67335396 :   v->VisitPointer(obj, HeapObject::RawField(obj, offset));
     100             : }
     101             : 
     102             : template <typename StaticVisitor>
     103      494809 : void BodyDescriptorBase::IteratePointer(Heap* heap, HeapObject* obj,
     104             :                                         int offset) {
     105      142030 :   StaticVisitor::VisitPointer(heap, obj, HeapObject::RawField(obj, offset));
     106      494809 : }
     107             : 
     108             : class JSObject::BodyDescriptor final : public BodyDescriptorBase {
     109             :  public:
     110             :   static const int kStartOffset = JSReceiver::kPropertiesOffset;
     111             : 
     112             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     113           0 :     if (offset < kStartOffset) return false;
     114           0 :     return IsValidSlotImpl(obj, offset);
     115             :   }
     116             : 
     117             :   template <typename ObjectVisitor>
     118             :   static inline void IterateBody(HeapObject* obj, int object_size,
     119             :                                  ObjectVisitor* v) {
     120    13310697 :     IterateBodyImpl(obj, kStartOffset, object_size, v);
     121             :   }
     122             : 
     123             :   template <typename StaticVisitor>
     124     1128808 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     125             :     Heap* heap = obj->GetHeap();
     126     1128808 :     IterateBodyImpl<StaticVisitor>(heap, obj, kStartOffset, object_size);
     127     1128808 :   }
     128             : 
     129     1128808 :   static inline int SizeOf(Map* map, HeapObject* object) {
     130     1128808 :     return map->instance_size();
     131             :   }
     132             : };
     133             : 
     134             : class JSObject::FastBodyDescriptor final : public BodyDescriptorBase {
     135             :  public:
     136             :   static const int kStartOffset = JSReceiver::kPropertiesOffset;
     137             : 
     138             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     139             :     return offset >= kStartOffset;
     140             :   }
     141             : 
     142             :   template <typename ObjectVisitor>
     143             :   static inline void IterateBody(HeapObject* obj, int object_size,
     144             :                                  ObjectVisitor* v) {
     145             :     IteratePointers(obj, kStartOffset, object_size, v);
     146             :   }
     147             : 
     148             :   template <typename StaticVisitor>
     149    26589993 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     150             :     Heap* heap = obj->GetHeap();
     151    16652080 :     IteratePointers<StaticVisitor>(heap, obj, kStartOffset, object_size);
     152    26589993 :   }
     153             : 
     154    26589993 :   static inline int SizeOf(Map* map, HeapObject* object) {
     155    26589993 :     return map->instance_size();
     156             :   }
     157             : };
     158             : 
     159             : // Iterates the function object according to the visiting policy.
     160             : template <JSFunction::BodyVisitingPolicy body_visiting_policy>
     161             : class JSFunction::BodyDescriptorImpl final : public BodyDescriptorBase {
     162             :  public:
     163             :   STATIC_ASSERT(kNonWeakFieldsEndOffset == kCodeEntryOffset);
     164             :   STATIC_ASSERT(kCodeEntryOffset + kPointerSize == kNextFunctionLinkOffset);
     165             :   STATIC_ASSERT(kNextFunctionLinkOffset + kPointerSize == kSize);
     166             : 
     167             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     168           0 :     if (offset < kSize) return true;
     169           0 :     return IsValidSlotImpl(obj, offset);
     170             :   }
     171             : 
     172             :   template <typename ObjectVisitor>
     173     6735576 :   static inline void IterateBody(HeapObject* obj, int object_size,
     174             :                                  ObjectVisitor* v) {
     175     1096874 :     IteratePointers(obj, kPropertiesOffset, kNonWeakFieldsEndOffset, v);
     176             : 
     177             :     if (body_visiting_policy & kVisitCodeEntry) {
     178     5697379 :       v->VisitCodeEntry(JSFunction::cast(obj),
     179             :                         obj->address() + kCodeEntryOffset);
     180             :     }
     181             : 
     182             :     if (body_visiting_policy & kVisitNextFunction) {
     183     1097014 :       IteratePointers(obj, kNextFunctionLinkOffset, kSize, v);
     184             :     }
     185     6735568 :     IterateBodyImpl(obj, kSize, object_size, v);
     186     6735744 :   }
     187             : 
     188             :   template <typename StaticVisitor>
     189    63190511 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     190             :     Heap* heap = obj->GetHeap();
     191    61690375 :     IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset,
     192             :                                    kNonWeakFieldsEndOffset);
     193             : 
     194             :     if (body_visiting_policy & kVisitCodeEntry) {
     195             :       StaticVisitor::VisitCodeEntry(heap, obj,
     196    61686674 :                                     obj->address() + kCodeEntryOffset);
     197             :     }
     198             : 
     199             :     if (body_visiting_policy & kVisitNextFunction) {
     200             :       IteratePointers<StaticVisitor>(heap, obj, kNextFunctionLinkOffset, kSize);
     201             :     }
     202    63190511 :     IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
     203    63190511 :   }
     204             : 
     205    63190511 :   static inline int SizeOf(Map* map, HeapObject* object) {
     206    63190511 :     return map->instance_size();
     207             :   }
     208             : };
     209             : 
     210             : class JSArrayBuffer::BodyDescriptor final : public BodyDescriptorBase {
     211             :  public:
     212             :   STATIC_ASSERT(kByteLengthOffset + kPointerSize == kBackingStoreOffset);
     213             :   STATIC_ASSERT(kBackingStoreOffset + kPointerSize == kBitFieldSlot);
     214             :   STATIC_ASSERT(kBitFieldSlot + kPointerSize == kSize);
     215             : 
     216             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     217           0 :     if (offset < kBackingStoreOffset) return true;
     218           0 :     if (offset < kSize) return false;
     219           0 :     return IsValidSlotImpl(obj, offset);
     220             :   }
     221             : 
     222             :   template <typename ObjectVisitor>
     223       15434 :   static inline void IterateBody(HeapObject* obj, int object_size,
     224             :                                  ObjectVisitor* v) {
     225        1631 :     IteratePointers(obj, kPropertiesOffset, kBackingStoreOffset, v);
     226       15434 :     IterateBodyImpl(obj, kSize, object_size, v);
     227       15434 :   }
     228             : 
     229             :   template <typename StaticVisitor>
     230       23383 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     231             :     Heap* heap = obj->GetHeap();
     232       12592 :     IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset,
     233             :                                    kBackingStoreOffset);
     234       23383 :     IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
     235       23383 :   }
     236             : 
     237       23383 :   static inline int SizeOf(Map* map, HeapObject* object) {
     238       23383 :     return map->instance_size();
     239             :   }
     240             : };
     241             : 
     242             : class BytecodeArray::BodyDescriptor final : public BodyDescriptorBase {
     243             :  public:
     244             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     245           0 :     return offset >= kConstantPoolOffset &&
     246           0 :            offset <= kSourcePositionTableOffset;
     247             :   }
     248             : 
     249             :   template <typename ObjectVisitor>
     250      118090 :   static inline void IterateBody(HeapObject* obj, int object_size,
     251             :                                  ObjectVisitor* v) {
     252             :     IteratePointer(obj, kConstantPoolOffset, v);
     253             :     IteratePointer(obj, kHandlerTableOffset, v);
     254             :     IteratePointer(obj, kSourcePositionTableOffset, v);
     255      118090 :   }
     256             : 
     257             :   template <typename StaticVisitor>
     258             :   static inline void IterateBody(HeapObject* obj, int object_size) {
     259             :     Heap* heap = obj->GetHeap();
     260             :     IteratePointer<StaticVisitor>(heap, obj, kConstantPoolOffset);
     261             :     IteratePointer<StaticVisitor>(heap, obj, kHandlerTableOffset);
     262             :     IteratePointer<StaticVisitor>(heap, obj, kSourcePositionTableOffset);
     263             :   }
     264             : 
     265             :   static inline int SizeOf(Map* map, HeapObject* obj) {
     266             :     return reinterpret_cast<BytecodeArray*>(obj)->BytecodeArraySize();
     267             :   }
     268             : };
     269             : 
     270             : class FixedTypedArrayBase::BodyDescriptor final : public BodyDescriptorBase {
     271             :  public:
     272             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     273           0 :     return offset == kBasePointerOffset;
     274             :   }
     275             : 
     276             :   template <typename ObjectVisitor>
     277             :   static inline void IterateBody(HeapObject* obj, int object_size,
     278             :                                  ObjectVisitor* v) {
     279             :     IteratePointer(obj, kBasePointerOffset, v);
     280             :   }
     281             : 
     282             :   template <typename StaticVisitor>
     283      636839 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     284             :     Heap* heap = obj->GetHeap();
     285      494809 :     IteratePointer<StaticVisitor>(heap, obj, kBasePointerOffset);
     286      636839 :   }
     287             : 
     288      636839 :   static inline int SizeOf(Map* map, HeapObject* object) {
     289      636839 :     return reinterpret_cast<FixedTypedArrayBase*>(object)->size();
     290             :   }
     291             : };
     292             : 
     293             : template <JSWeakCollection::BodyVisitingPolicy body_visiting_policy>
     294             : class JSWeakCollection::BodyDescriptorImpl final : public BodyDescriptorBase {
     295             :  public:
     296             :   STATIC_ASSERT(kTableOffset + kPointerSize == kNextOffset);
     297             :   STATIC_ASSERT(kNextOffset + kPointerSize == kSize);
     298             : 
     299             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     300           0 :     return IsValidSlotImpl(obj, offset);
     301             :   }
     302             : 
     303             :   template <typename ObjectVisitor>
     304             :   static inline void IterateBody(HeapObject* obj, int object_size,
     305             :                                  ObjectVisitor* v) {
     306             :     if (body_visiting_policy == kVisitStrong) {
     307        4566 :       IterateBodyImpl(obj, kPropertiesOffset, object_size, v);
     308             :     } else {
     309             :       IteratePointers(obj, kPropertiesOffset, kTableOffset, v);
     310             :       IterateBodyImpl(obj, kSize, object_size, v);
     311             :     }
     312             :   }
     313             : 
     314             :   template <typename StaticVisitor>
     315        7163 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     316             :     Heap* heap = obj->GetHeap();
     317             :     if (body_visiting_policy == kVisitStrong) {
     318        4948 :       IterateBodyImpl<StaticVisitor>(heap, obj, kPropertiesOffset, object_size);
     319             :     } else {
     320        2215 :       IteratePointers<StaticVisitor>(heap, obj, kPropertiesOffset,
     321             :                                      kTableOffset);
     322        2215 :       IterateBodyImpl<StaticVisitor>(heap, obj, kSize, object_size);
     323             :     }
     324        7163 :   }
     325             : 
     326        7163 :   static inline int SizeOf(Map* map, HeapObject* object) {
     327        7163 :     return map->instance_size();
     328             :   }
     329             : };
     330             : 
     331             : class Foreign::BodyDescriptor final : public BodyDescriptorBase {
     332             :  public:
     333             :   static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
     334             : 
     335             :   template <typename ObjectVisitor>
     336             :   static inline void IterateBody(HeapObject* obj, int object_size,
     337             :                                  ObjectVisitor* v) {
     338     2073076 :     v->VisitExternalReference(Foreign::cast(obj),
     339             :                               reinterpret_cast<Address*>(HeapObject::RawField(
     340     1036538 :                                   obj, kForeignAddressOffset)));
     341             :   }
     342             : 
     343             :   template <typename StaticVisitor>
     344             :   static inline void IterateBody(HeapObject* obj, int object_size) {
     345             :     StaticVisitor::VisitExternalReference(reinterpret_cast<Address*>(
     346             :         HeapObject::RawField(obj, kForeignAddressOffset)));
     347             :   }
     348             : 
     349             :   static inline int SizeOf(Map* map, HeapObject* object) { return kSize; }
     350             : };
     351             : 
     352             : class ExternalOneByteString::BodyDescriptor final : public BodyDescriptorBase {
     353             :  public:
     354             :   static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
     355             : 
     356             :   template <typename ObjectVisitor>
     357             :   static inline void IterateBody(HeapObject* obj, int object_size,
     358             :                                  ObjectVisitor* v) {
     359             :   }
     360             : 
     361             :   template <typename StaticVisitor>
     362             :   static inline void IterateBody(HeapObject* obj, int object_size) {
     363             :   }
     364             : 
     365             :   static inline int SizeOf(Map* map, HeapObject* object) { return kSize; }
     366             : };
     367             : 
     368             : class ExternalTwoByteString::BodyDescriptor final : public BodyDescriptorBase {
     369             :  public:
     370             :   static bool IsValidSlot(HeapObject* obj, int offset) { return false; }
     371             : 
     372             :   template <typename ObjectVisitor>
     373             :   static inline void IterateBody(HeapObject* obj, int object_size,
     374             :                                  ObjectVisitor* v) {
     375             :   }
     376             : 
     377             :   template <typename StaticVisitor>
     378             :   static inline void IterateBody(HeapObject* obj, int object_size) {
     379             :   }
     380             : 
     381             :   static inline int SizeOf(Map* map, HeapObject* object) { return kSize; }
     382             : };
     383             : 
     384             : class Code::BodyDescriptor final : public BodyDescriptorBase {
     385             :  public:
     386             :   STATIC_ASSERT(kRelocationInfoOffset + kPointerSize == kHandlerTableOffset);
     387             :   STATIC_ASSERT(kHandlerTableOffset + kPointerSize ==
     388             :                 kDeoptimizationDataOffset);
     389             :   STATIC_ASSERT(kDeoptimizationDataOffset + kPointerSize ==
     390             :                 kSourcePositionTableOffset);
     391             :   STATIC_ASSERT(kSourcePositionTableOffset + kPointerSize ==
     392             :                 kTypeFeedbackInfoOffset);
     393             :   STATIC_ASSERT(kTypeFeedbackInfoOffset + kPointerSize ==
     394             :                 kNextCodeLinkOffset);
     395             : 
     396             :   static bool IsValidSlot(HeapObject* obj, int offset) {
     397             :     // Slots in code can't be invalid because we never trim code objects.
     398             :     return true;
     399             :   }
     400             : 
     401             :   template <typename ObjectVisitor>
     402     3408072 :   static inline void IterateBody(HeapObject* obj, ObjectVisitor* v) {
     403             :     int mode_mask = RelocInfo::kCodeTargetMask |
     404             :                     RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
     405             :                     RelocInfo::ModeMask(RelocInfo::CELL) |
     406             :                     RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
     407             :                     RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
     408             :                     RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) |
     409             :                     RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) |
     410             :                     RelocInfo::kDebugBreakSlotMask;
     411             : 
     412       16628 :     IteratePointers(obj, kRelocationInfoOffset, kNextCodeLinkOffset, v);
     413     3408073 :     v->VisitNextCodeLink(Code::cast(obj),
     414             :                          HeapObject::RawField(obj, kNextCodeLinkOffset));
     415             : 
     416     3408073 :     RelocIterator it(Code::cast(obj), mode_mask);
     417             :     Isolate* isolate = obj->GetIsolate();
     418    40283860 :     for (; !it.done(); it.next()) {
     419    36875787 :       it.rinfo()->Visit(isolate, v);
     420             :     }
     421     3408073 :   }
     422             : 
     423             :   template <typename ObjectVisitor>
     424             :   static inline void IterateBody(HeapObject* obj, int object_size,
     425             :                                  ObjectVisitor* v) {
     426     3407128 :     IterateBody(obj, v);
     427             :   }
     428             : 
     429             :   template <typename StaticVisitor>
     430    75043328 :   static inline void IterateBody(HeapObject* obj) {
     431             :     int mode_mask = RelocInfo::kCodeTargetMask |
     432             :                     RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
     433             :                     RelocInfo::ModeMask(RelocInfo::CELL) |
     434             :                     RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
     435             :                     RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
     436             :                     RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) |
     437             :                     RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) |
     438             :                     RelocInfo::kDebugBreakSlotMask;
     439             : 
     440             :     Heap* heap = obj->GetHeap();
     441    75043328 :     IteratePointers<StaticVisitor>(heap, obj, kRelocationInfoOffset,
     442             :                                    kNextCodeLinkOffset);
     443             :     StaticVisitor::VisitNextCodeLink(
     444             :         heap, HeapObject::RawField(obj, kNextCodeLinkOffset));
     445             : 
     446    75043132 :     RelocIterator it(Code::cast(obj), mode_mask);
     447   852027540 :     for (; !it.done(); it.next()) {
     448   776985157 :       it.rinfo()->template Visit<StaticVisitor>(heap);
     449             :     }
     450    75043392 :   }
     451             : 
     452             :   template <typename StaticVisitor>
     453    75043339 :   static inline void IterateBody(HeapObject* obj, int object_size) {
     454    75043339 :     IterateBody<StaticVisitor>(obj);
     455    75043393 :   }
     456             : 
     457    75043323 :   static inline int SizeOf(Map* map, HeapObject* object) {
     458    75043333 :     return reinterpret_cast<Code*>(object)->CodeSize();
     459             :   }
     460             : };
     461             : 
     462             : 
     463             : template <typename Op, typename ReturnType, typename T1, typename T2,
     464             :           typename T3>
     465   104942858 : ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3) {
     466   104942858 :   if (type < FIRST_NONSTRING_TYPE) {
     467    48777037 :     switch (type & kStringRepresentationMask) {
     468             :       case kSeqStringTag:
     469             :         return ReturnType();
     470             :       case kConsStringTag:
     471           0 :         return Op::template apply<ConsString::BodyDescriptor>(p1, p2, p3);
     472             :       case kThinStringTag:
     473           0 :         return Op::template apply<ThinString::BodyDescriptor>(p1, p2, p3);
     474             :       case kSlicedStringTag:
     475           0 :         return Op::template apply<SlicedString::BodyDescriptor>(p1, p2, p3);
     476             :       case kExternalStringTag:
     477             :         if ((type & kStringEncodingMask) == kOneByteStringTag) {
     478             :           return Op::template apply<ExternalOneByteString::BodyDescriptor>(
     479             :               p1, p2, p3);
     480             :         } else {
     481             :           return Op::template apply<ExternalTwoByteString::BodyDescriptor>(
     482             :               p1, p2, p3);
     483             :         }
     484             :     }
     485           0 :     UNREACHABLE();
     486             :     return ReturnType();
     487             :   }
     488             : 
     489    56165821 :   switch (type) {
     490             :     case FIXED_ARRAY_TYPE:
     491           0 :       return Op::template apply<FixedArray::BodyDescriptor>(p1, p2, p3);
     492             :     case FIXED_DOUBLE_ARRAY_TYPE:
     493             :       return ReturnType();
     494             :     case TRANSITION_ARRAY_TYPE:
     495           0 :       return Op::template apply<TransitionArray::BodyDescriptor>(p1, p2, p3);
     496             :     case JS_OBJECT_TYPE:
     497             :     case JS_ERROR_TYPE:
     498             :     case JS_ARGUMENTS_TYPE:
     499             :     case JS_ASYNC_FROM_SYNC_ITERATOR_TYPE:
     500             :     case JS_PROMISE_CAPABILITY_TYPE:
     501             :     case JS_PROMISE_TYPE:
     502             :     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
     503             :     case JS_GENERATOR_OBJECT_TYPE:
     504             :     case JS_ASYNC_GENERATOR_OBJECT_TYPE:
     505             :     case JS_VALUE_TYPE:
     506             :     case JS_DATE_TYPE:
     507             :     case JS_ARRAY_TYPE:
     508             :     case JS_MODULE_NAMESPACE_TYPE:
     509             :     case JS_TYPED_ARRAY_TYPE:
     510             :     case JS_DATA_VIEW_TYPE:
     511             :     case JS_SET_TYPE:
     512             :     case JS_MAP_TYPE:
     513             :     case JS_SET_ITERATOR_TYPE:
     514             :     case JS_MAP_ITERATOR_TYPE:
     515             :     case JS_STRING_ITERATOR_TYPE:
     516             : 
     517             :     case JS_TYPED_ARRAY_KEY_ITERATOR_TYPE:
     518             :     case JS_FAST_ARRAY_KEY_ITERATOR_TYPE:
     519             :     case JS_GENERIC_ARRAY_KEY_ITERATOR_TYPE:
     520             :     case JS_UINT8_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     521             :     case JS_INT8_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     522             :     case JS_UINT16_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     523             :     case JS_INT16_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     524             :     case JS_UINT32_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     525             :     case JS_INT32_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     526             :     case JS_FLOAT32_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     527             :     case JS_FLOAT64_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     528             :     case JS_UINT8_CLAMPED_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     529             :     case JS_FAST_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     530             :     case JS_FAST_HOLEY_SMI_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     531             :     case JS_FAST_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     532             :     case JS_FAST_HOLEY_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     533             :     case JS_FAST_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     534             :     case JS_FAST_HOLEY_DOUBLE_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     535             :     case JS_GENERIC_ARRAY_KEY_VALUE_ITERATOR_TYPE:
     536             :     case JS_UINT8_ARRAY_VALUE_ITERATOR_TYPE:
     537             :     case JS_INT8_ARRAY_VALUE_ITERATOR_TYPE:
     538             :     case JS_UINT16_ARRAY_VALUE_ITERATOR_TYPE:
     539             :     case JS_INT16_ARRAY_VALUE_ITERATOR_TYPE:
     540             :     case JS_UINT32_ARRAY_VALUE_ITERATOR_TYPE:
     541             :     case JS_INT32_ARRAY_VALUE_ITERATOR_TYPE:
     542             :     case JS_FLOAT32_ARRAY_VALUE_ITERATOR_TYPE:
     543             :     case JS_FLOAT64_ARRAY_VALUE_ITERATOR_TYPE:
     544             :     case JS_UINT8_CLAMPED_ARRAY_VALUE_ITERATOR_TYPE:
     545             :     case JS_FAST_SMI_ARRAY_VALUE_ITERATOR_TYPE:
     546             :     case JS_FAST_HOLEY_SMI_ARRAY_VALUE_ITERATOR_TYPE:
     547             :     case JS_FAST_ARRAY_VALUE_ITERATOR_TYPE:
     548             :     case JS_FAST_HOLEY_ARRAY_VALUE_ITERATOR_TYPE:
     549             :     case JS_FAST_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE:
     550             :     case JS_FAST_HOLEY_DOUBLE_ARRAY_VALUE_ITERATOR_TYPE:
     551             :     case JS_GENERIC_ARRAY_VALUE_ITERATOR_TYPE:
     552             : 
     553             :     case JS_REGEXP_TYPE:
     554             :     case JS_GLOBAL_PROXY_TYPE:
     555             :     case JS_GLOBAL_OBJECT_TYPE:
     556             :     case JS_API_OBJECT_TYPE:
     557             :     case JS_SPECIAL_API_OBJECT_TYPE:
     558             :     case JS_MESSAGE_OBJECT_TYPE:
     559             :     case JS_BOUND_FUNCTION_TYPE:
     560           0 :       return Op::template apply<JSObject::BodyDescriptor>(p1, p2, p3);
     561             :     case JS_WEAK_MAP_TYPE:
     562             :     case JS_WEAK_SET_TYPE:
     563           0 :       return Op::template apply<JSWeakCollection::BodyDescriptor>(p1, p2, p3);
     564             :     case JS_ARRAY_BUFFER_TYPE:
     565           0 :       return Op::template apply<JSArrayBuffer::BodyDescriptor>(p1, p2, p3);
     566             :     case JS_FUNCTION_TYPE:
     567           0 :       return Op::template apply<JSFunction::BodyDescriptor>(p1, p2, p3);
     568             :     case ODDBALL_TYPE:
     569           0 :       return Op::template apply<Oddball::BodyDescriptor>(p1, p2, p3);
     570             :     case JS_PROXY_TYPE:
     571           0 :       return Op::template apply<JSProxy::BodyDescriptor>(p1, p2, p3);
     572             :     case FOREIGN_TYPE:
     573             :       return Op::template apply<Foreign::BodyDescriptor>(p1, p2, p3);
     574             :     case MAP_TYPE:
     575           0 :       return Op::template apply<Map::BodyDescriptor>(p1, p2, p3);
     576             :     case CODE_TYPE:
     577           0 :       return Op::template apply<Code::BodyDescriptor>(p1, p2, p3);
     578             :     case CELL_TYPE:
     579           0 :       return Op::template apply<Cell::BodyDescriptor>(p1, p2, p3);
     580             :     case PROPERTY_CELL_TYPE:
     581           0 :       return Op::template apply<PropertyCell::BodyDescriptor>(p1, p2, p3);
     582             :     case WEAK_CELL_TYPE:
     583           0 :       return Op::template apply<WeakCell::BodyDescriptor>(p1, p2, p3);
     584             :     case SYMBOL_TYPE:
     585           0 :       return Op::template apply<Symbol::BodyDescriptor>(p1, p2, p3);
     586             :     case BYTECODE_ARRAY_TYPE:
     587           0 :       return Op::template apply<BytecodeArray::BodyDescriptor>(p1, p2, p3);
     588             : 
     589             :     case HEAP_NUMBER_TYPE:
     590             :     case MUTABLE_HEAP_NUMBER_TYPE:
     591             :     case FILLER_TYPE:
     592             :     case BYTE_ARRAY_TYPE:
     593             :     case FREE_SPACE_TYPE:
     594             :       return ReturnType();
     595             : 
     596             : #define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
     597             :   case FIXED_##TYPE##_ARRAY_TYPE:                       \
     598             :     return Op::template apply<FixedTypedArrayBase::BodyDescriptor>(p1, p2, p3);
     599           0 :       TYPED_ARRAYS(TYPED_ARRAY_CASE)
     600             : #undef TYPED_ARRAY_CASE
     601             : 
     602             :     case SHARED_FUNCTION_INFO_TYPE: {
     603           0 :       return Op::template apply<SharedFunctionInfo::BodyDescriptor>(p1, p2, p3);
     604             :     }
     605             : 
     606             : #define MAKE_STRUCT_CASE(NAME, Name, name) case NAME##_TYPE:
     607             :       STRUCT_LIST(MAKE_STRUCT_CASE)
     608             : #undef MAKE_STRUCT_CASE
     609     1249417 :       if (type == ALLOCATION_SITE_TYPE) {
     610           0 :         return Op::template apply<AllocationSite::BodyDescriptor>(p1, p2, p3);
     611             :       } else {
     612           0 :         return Op::template apply<StructBodyDescriptor>(p1, p2, p3);
     613             :       }
     614             :     default:
     615           0 :       PrintF("Unknown type: %d\n", type);
     616           0 :       UNREACHABLE();
     617             :       return ReturnType();
     618             :   }
     619             : }
     620             : 
     621             : 
     622             : template <typename ObjectVisitor>
     623    33403871 : void HeapObject::IterateFast(ObjectVisitor* v) {
     624             :   BodyDescriptorBase::IteratePointer(this, kMapOffset, v);
     625    33403871 :   IterateBodyFast(v);
     626    33403871 : }
     627             : 
     628             : 
     629             : template <typename ObjectVisitor>
     630    39559833 : void HeapObject::IterateBodyFast(ObjectVisitor* v) {
     631             :   Map* m = map();
     632    39559833 :   IterateBodyFast(m->instance_type(), SizeFromMap(m), v);
     633    39556051 : }
     634             : 
     635             : 
     636             : struct CallIterateBody {
     637             :   template <typename BodyDescriptor, typename ObjectVisitor>
     638             :   static void apply(HeapObject* obj, int object_size, ObjectVisitor* v) {
     639      133524 :     BodyDescriptor::IterateBody(obj, object_size, v);
     640             :   }
     641             : };
     642             : 
     643             : template <typename ObjectVisitor>
     644             : void HeapObject::IterateBodyFast(InstanceType type, int object_size,
     645             :                                  ObjectVisitor* v) {
     646   105006686 :   BodyDescriptorApply<CallIterateBody, void>(type, this, object_size, v);
     647             : }
     648             : }  // namespace internal
     649             : }  // namespace v8
     650             : 
     651             : #endif  // V8_OBJECTS_BODY_DESCRIPTORS_INL_H_

Generated by: LCOV version 1.10