objects-body-descriptors-inl.h 45.9 KB
Newer Older
1 2 3 4
// Copyright 2015 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.

5 6
#ifndef V8_OBJECTS_OBJECTS_BODY_DESCRIPTORS_INL_H_
#define V8_OBJECTS_OBJECTS_BODY_DESCRIPTORS_INL_H_
7

8
#include "src/objects/objects-body-descriptors.h"
9 10 11

#include <algorithm>

12
#include "src/codegen/reloc-info.h"
13
#include "src/objects/cell.h"
14
#include "src/objects/data-handler.h"
15
#include "src/objects/feedback-vector.h"
16
#include "src/objects/foreign-inl.h"
17
#include "src/objects/hash-table.h"
18
#include "src/objects/js-collection.h"
19
#include "src/objects/js-weak-refs.h"
20
#include "src/objects/oddball.h"
21
#include "src/objects/ordered-hash-table-inl.h"
22
#include "src/objects/source-text-module.h"
23
#include "src/objects/synthetic-module.h"
24
#include "src/objects/transitions.h"
25
#include "src/wasm/wasm-objects-inl.h"
26 27 28 29 30

namespace v8 {
namespace internal {

template <int start_offset>
31
int FlexibleBodyDescriptor<start_offset>::SizeOf(Map map, HeapObject object) {
32
  return object.SizeFromMap(map);
33 34
}

35 36
template <int start_offset>
int FlexibleWeakBodyDescriptor<start_offset>::SizeOf(Map map,
37
                                                     HeapObject object) {
38
  return object.SizeFromMap(map);
39 40
}

41
bool BodyDescriptorBase::IsValidJSObjectSlotImpl(Map map, HeapObject obj,
42
                                                 int offset) {
43 44 45
#ifdef V8_COMPRESS_POINTERS
  STATIC_ASSERT(kEmbedderDataSlotSize == 2 * kTaggedSize);
  int embedder_fields_offset = JSObject::GetEmbedderFieldsStartOffset(map);
46
  int inobject_fields_offset = map.GetInObjectPropertyOffset(0);
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61
  // |embedder_fields_offset| may be greater than |inobject_fields_offset| if
  // the object does not have embedder fields but the check handles this
  // case properly.
  if (embedder_fields_offset <= offset && offset < inobject_fields_offset) {
    // offset points to embedder fields area:
    // [embedder_fields_offset, inobject_fields_offset).
    STATIC_ASSERT(base::bits::IsPowerOfTwo(kEmbedderDataSlotSize));
    return ((offset - embedder_fields_offset) & (kEmbedderDataSlotSize - 1)) ==
           EmbedderDataSlot::kTaggedPayloadOffset;
  }
#else
  // We store raw aligned pointers as Smis, so it's safe to treat the whole
  // embedder field area as tagged slots.
  STATIC_ASSERT(kEmbedderDataSlotSize == kTaggedSize);
#endif
62
  if (!FLAG_unbox_double_fields || map.HasFastPointerLayout()) {
63 64 65
    return true;
  } else {
    DCHECK(FLAG_unbox_double_fields);
66
    DCHECK(IsAligned(offset, kSystemPointerSize));
67

68
    LayoutDescriptorHelper helper(map);
69 70 71 72 73 74
    DCHECK(!helper.all_fields_tagged());
    return helper.IsTagged(offset);
  }
}

template <typename ObjectVisitor>
75
void BodyDescriptorBase::IterateJSObjectBodyImpl(Map map, HeapObject obj,
76 77 78
                                                 int start_offset,
                                                 int end_offset,
                                                 ObjectVisitor* v) {
79 80 81
#ifdef V8_COMPRESS_POINTERS
  STATIC_ASSERT(kEmbedderDataSlotSize == 2 * kTaggedSize);
  int header_size = JSObject::GetHeaderSize(map);
82
  int inobject_fields_offset = map.GetInObjectPropertyOffset(0);
83 84
  // We are always requested to process header and embedder fields.
  DCHECK_LE(inobject_fields_offset, end_offset);
85
  // Embedder fields are located between header and inobject properties.
86 87 88 89
  if (header_size < inobject_fields_offset) {
    // There are embedder fields.
    IteratePointers(obj, start_offset, header_size, v);
    // Iterate only tagged payload of the embedder slots and skip raw payload.
90 91
    DCHECK_EQ(header_size, JSObject::GetEmbedderFieldsStartOffset(map));
    for (int offset = header_size + EmbedderDataSlot::kTaggedPayloadOffset;
92 93 94 95 96 97 98 99 100 101 102
         offset < inobject_fields_offset; offset += kEmbedderDataSlotSize) {
      IteratePointer(obj, offset, v);
    }
    // Proceed processing inobject properties.
    start_offset = inobject_fields_offset;
  }
#else
  // We store raw aligned pointers as Smis, so it's safe to iterate the whole
  // embedder field area as tagged slots.
  STATIC_ASSERT(kEmbedderDataSlotSize == kTaggedSize);
#endif
103
  if (!FLAG_unbox_double_fields || map.HasFastPointerLayout()) {
104 105 106
    IteratePointers(obj, start_offset, end_offset, v);
  } else {
    DCHECK(FLAG_unbox_double_fields);
107 108
    DCHECK(IsAligned(start_offset, kSystemPointerSize) &&
           IsAligned(end_offset, kSystemPointerSize));
109

110
    LayoutDescriptorHelper helper(map);
111 112 113 114 115 116 117 118 119 120 121 122
    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)) {
        IteratePointers(obj, offset, end_of_region_offset, v);
      }
      offset = end_of_region_offset;
    }
  }
}

template <typename ObjectVisitor>
123
DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(HeapObject obj,
124 125 126
                                                          int start_offset,
                                                          int end_offset,
                                                          ObjectVisitor* v) {
127
  v->VisitPointers(obj, obj.RawField(start_offset), obj.RawField(end_offset));
128 129 130
}

template <typename ObjectVisitor>
131
void BodyDescriptorBase::IteratePointer(HeapObject obj, int offset,
132
                                        ObjectVisitor* v) {
133
  v->VisitPointer(obj, obj.RawField(offset));
134 135
}

136 137
template <typename ObjectVisitor>
DISABLE_CFI_PERF void BodyDescriptorBase::IterateMaybeWeakPointers(
138
    HeapObject obj, int start_offset, int end_offset, ObjectVisitor* v) {
139 140
  v->VisitPointers(obj, obj.RawMaybeWeakField(start_offset),
                   obj.RawMaybeWeakField(end_offset));
141 142
}

143
template <typename ObjectVisitor>
144
void BodyDescriptorBase::IterateMaybeWeakPointer(HeapObject obj, int offset,
145
                                                 ObjectVisitor* v) {
146
  v->VisitPointer(obj, obj.RawMaybeWeakField(offset));
147 148
}

149 150
template <typename ObjectVisitor>
DISABLE_CFI_PERF void BodyDescriptorBase::IterateCustomWeakPointers(
151
    HeapObject obj, int start_offset, int end_offset, ObjectVisitor* v) {
152 153
  v->VisitCustomWeakPointers(obj, obj.RawField(start_offset),
                             obj.RawField(end_offset));
154 155
}

156 157 158 159 160 161
template <typename ObjectVisitor>
DISABLE_CFI_PERF void BodyDescriptorBase::IterateEphemeron(HeapObject obj,
                                                           int index,
                                                           int key_offset,
                                                           int value_offset,
                                                           ObjectVisitor* v) {
162 163
  v->VisitEphemeron(obj, index, obj.RawField(key_offset),
                    obj.RawField(value_offset));
164 165
}

166
template <typename ObjectVisitor>
167
void BodyDescriptorBase::IterateCustomWeakPointer(HeapObject obj, int offset,
168
                                                  ObjectVisitor* v) {
169
  v->VisitCustomWeakPointer(obj, obj.RawField(offset));
170 171
}

172 173
class JSObject::BodyDescriptor final : public BodyDescriptorBase {
 public:
174
  static const int kStartOffset = JSReceiver::kPropertiesOrHashOffset;
175

176
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
177
    if (offset < kStartOffset) return false;
178
    return IsValidJSObjectSlotImpl(map, obj, offset);
179 180 181
  }

  template <typename ObjectVisitor>
182
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
183
                                 ObjectVisitor* v) {
184
    IterateJSObjectBodyImpl(map, obj, kStartOffset, object_size, v);
185 186
  }

187
  static inline int SizeOf(Map map, HeapObject object) {
188
    return map.instance_size();
189 190
  }
};
191

192 193
class JSObject::FastBodyDescriptor final : public BodyDescriptorBase {
 public:
194
  static const int kStartOffset = JSReceiver::kPropertiesOrHashOffset;
195

196
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
197 198 199 200
    return offset >= kStartOffset;
  }

  template <typename ObjectVisitor>
201
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
202 203 204 205
                                 ObjectVisitor* v) {
    IteratePointers(obj, kStartOffset, object_size, v);
  }

206
  static inline int SizeOf(Map map, HeapObject object) {
207
    return map.instance_size();
208 209 210
  }
};

211
class WeakCell::BodyDescriptor final : public BodyDescriptorBase {
212
 public:
213
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
214
    return offset >= HeapObject::kHeaderSize;
215 216 217
  }

  template <typename ObjectVisitor>
218
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
219
                                 ObjectVisitor* v) {
220
    IteratePointers(obj, HeapObject::kHeaderSize, kTargetOffset, v);
221
    IterateCustomWeakPointer(obj, kTargetOffset, v);
222 223
    IterateCustomWeakPointer(obj, kUnregisterTokenOffset, v);
    IteratePointers(obj, kUnregisterTokenOffset + kTaggedSize, object_size, v);
224 225
  }

226
  static inline int SizeOf(Map map, HeapObject object) {
227
    return map.instance_size();
228 229 230
  }
};

231 232
class JSWeakRef::BodyDescriptor final : public BodyDescriptorBase {
 public:
233
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
234
    return IsValidJSObjectSlotImpl(map, obj, offset);
235 236 237
  }

  template <typename ObjectVisitor>
238
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
239 240 241
                                 ObjectVisitor* v) {
    IteratePointers(obj, JSReceiver::kPropertiesOrHashOffset, kTargetOffset, v);
    IterateCustomWeakPointer(obj, kTargetOffset, v);
242 243
    IterateJSObjectBodyImpl(map, obj, kTargetOffset + kTaggedSize, object_size,
                            v);
244 245
  }

246
  static inline int SizeOf(Map map, HeapObject object) {
247
    return map.instance_size();
248 249 250
  }
};

251
class JSFinalizationRegistry::BodyDescriptor final : public BodyDescriptorBase {
252 253 254 255 256 257 258 259
 public:
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
    return IsValidJSObjectSlotImpl(map, obj, offset);
  }

  template <typename ObjectVisitor>
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                 ObjectVisitor* v) {
260 261 262 263 264
    IteratePointers(obj, JSObject::BodyDescriptor::kStartOffset,
                    kNextDirtyOffset, v);
    IterateCustomWeakPointer(obj, kNextDirtyOffset, v);
    IterateJSObjectBodyImpl(map, obj, kNextDirtyOffset + kTaggedSize,
                            object_size, v);
265 266 267 268 269 270 271
  }

  static inline int SizeOf(Map map, HeapObject object) {
    return map.instance_size();
  }
};

272 273
class SharedFunctionInfo::BodyDescriptor final : public BodyDescriptorBase {
 public:
274
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
275 276 277 278 279
    static_assert(kEndOfWeakFieldsOffset == kStartOfStrongFieldsOffset,
                  "Leverage that strong fields directly follow weak fields"
                  "to call FixedBodyDescriptor<...>::IsValidSlot below");
    return FixedBodyDescriptor<kStartOfWeakFieldsOffset,
                               kEndOfStrongFieldsOffset,
280 281 282 283
                               kAlignedSize>::IsValidSlot(map, obj, offset);
  }

  template <typename ObjectVisitor>
284
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
285 286
                                 ObjectVisitor* v) {
    IterateCustomWeakPointer(obj, kFunctionDataOffset, v);
287
    IteratePointers(obj, SharedFunctionInfo::kStartOfStrongFieldsOffset,
288
                    SharedFunctionInfo::kEndOfStrongFieldsOffset, v);
289 290
  }

291
  static inline int SizeOf(Map map, HeapObject object) {
292
    return map.instance_size();
293 294 295
  }
};

296
class AllocationSite::BodyDescriptor final : public BodyDescriptorBase {
297
 public:
298 299 300 301 302 303 304
  STATIC_ASSERT(AllocationSite::kCommonPointerFieldEndOffset ==
                AllocationSite::kPretenureDataOffset);
  STATIC_ASSERT(AllocationSite::kPretenureDataOffset + kInt32Size ==
                AllocationSite::kPretenureCreateCountOffset);
  STATIC_ASSERT(AllocationSite::kPretenureCreateCountOffset + kInt32Size ==
                AllocationSite::kWeakNextOffset);

305
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
306 307 308 309 310
    if (offset >= AllocationSite::kStartOffset &&
        offset < AllocationSite::kCommonPointerFieldEndOffset) {
      return true;
    }
    // check for weak_next offset
311
    if (map.instance_size() == AllocationSite::kSizeWithWeakNext &&
312 313 314 315
        offset == AllocationSite::kWeakNextOffset) {
      return true;
    }
    return false;
316 317 318
  }

  template <typename ObjectVisitor>
319
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
320
                                 ObjectVisitor* v) {
321 322 323
    // Iterate over all the common pointer fields
    IteratePointers(obj, AllocationSite::kStartOffset,
                    AllocationSite::kCommonPointerFieldEndOffset, v);
324 325 326 327 328 329
    // Skip PretenureDataOffset and PretenureCreateCount which are Int32 fields.
    // Visit weak_next only if it has weak_next field.
    if (object_size == AllocationSite::kSizeWithWeakNext) {
      IterateCustomWeakPointers(obj, AllocationSite::kWeakNextOffset,
                                AllocationSite::kSizeWithWeakNext, v);
    }
330 331
  }

332
  static inline int SizeOf(Map map, HeapObject object) {
333
    return map.instance_size();
334 335 336
  }
};

337 338
class JSArrayBuffer::BodyDescriptor final : public BodyDescriptorBase {
 public:
339
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
340 341
    if (offset < kEndOfTaggedFieldsOffset) return true;
    if (offset < kHeaderSize) return false;
342
    return IsValidJSObjectSlotImpl(map, obj, offset);
343 344 345
  }

  template <typename ObjectVisitor>
346
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
347
                                 ObjectVisitor* v) {
348
    // JSArrayBuffer instances contain raw data that the GC does not know about.
349
    IteratePointers(obj, kPropertiesOrHashOffset, kEndOfTaggedFieldsOffset, v);
350
    IterateJSObjectBodyImpl(map, obj, kHeaderSize, object_size, v);
351 352
  }

353
  static inline int SizeOf(Map map, HeapObject object) {
354
    return map.instance_size();
355 356 357
  }
};

358
class JSTypedArray::BodyDescriptor final : public BodyDescriptorBase {
359
 public:
360
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
361
    if (offset < kEndOfTaggedFieldsOffset) return true;
362 363
    // TODO(v8:4153): Remove this.
    if (offset == kBasePointerOffset) return true;
364
    if (offset < kHeaderSize) return false;
365
    return IsValidJSObjectSlotImpl(map, obj, offset);
366 367 368
  }

  template <typename ObjectVisitor>
369
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
370
                                 ObjectVisitor* v) {
371 372
    // JSTypedArray contains raw data that the GC does not know about.
    IteratePointers(obj, kPropertiesOrHashOffset, kEndOfTaggedFieldsOffset, v);
373 374
    // TODO(v8:4153): Remove this.
    IteratePointer(obj, kBasePointerOffset, v);
375 376 377 378
    IterateJSObjectBodyImpl(map, obj, kHeaderSize, object_size, v);
  }

  static inline int SizeOf(Map map, HeapObject object) {
379
    return map.instance_size();
380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
  }
};

class JSDataView::BodyDescriptor final : public BodyDescriptorBase {
 public:
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
    if (offset < kEndOfTaggedFieldsOffset) return true;
    if (offset < kHeaderSize) return false;
    return IsValidJSObjectSlotImpl(map, obj, offset);
  }

  template <typename ObjectVisitor>
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                 ObjectVisitor* v) {
    // JSDataView contains raw data that the GC does not know about.
395
    IteratePointers(obj, kPropertiesOrHashOffset, kEndOfTaggedFieldsOffset, v);
396
    IterateJSObjectBodyImpl(map, obj, kHeaderSize, object_size, v);
397 398
  }

399
  static inline int SizeOf(Map map, HeapObject object) {
400
    return map.instance_size();
401 402 403
  }
};

404
template <typename Derived>
405
class V8_EXPORT_PRIVATE SmallOrderedHashTable<Derived>::BodyDescriptor final
406
    : public BodyDescriptorBase {
407
 public:
408
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
409
    Derived table = Derived::cast(obj);
410 411
    // Only data table part contains tagged values.
    return (offset >= DataTableStartOffset()) &&
412
           (offset < table.GetBucketsStartOffset());
413 414 415
  }

  template <typename ObjectVisitor>
416
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
417
                                 ObjectVisitor* v) {
418
    Derived table = Derived::cast(obj);
419
    int start_offset = DataTableStartOffset();
420
    int end_offset = table.GetBucketsStartOffset();
421
    IteratePointers(obj, start_offset, end_offset, v);
422 423
  }

424
  static inline int SizeOf(Map map, HeapObject obj) {
425
    Derived table = Derived::cast(obj);
426
    return Derived::SizeFor(table.Capacity());
427 428 429
  }
};

430 431
class ByteArray::BodyDescriptor final : public BodyDescriptorBase {
 public:
432
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
433 434

  template <typename ObjectVisitor>
435
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
436 437
                                 ObjectVisitor* v) {}

438
  static inline int SizeOf(Map map, HeapObject obj) {
439
    return ByteArray::SizeFor(ByteArray::cast(obj).synchronized_length());
440 441 442
  }
};

443 444
class BytecodeArray::BodyDescriptor final : public BodyDescriptorBase {
 public:
445
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
446 447
    return offset >= kConstantPoolOffset &&
           offset <= kSourcePositionTableOffset;
448 449 450
  }

  template <typename ObjectVisitor>
451
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
452 453
                                 ObjectVisitor* v) {
    IteratePointer(obj, kConstantPoolOffset, v);
454
    IteratePointer(obj, kHandlerTableOffset, v);
455
    IteratePointer(obj, kSourcePositionTableOffset, v);
456 457
  }

458
  static inline int SizeOf(Map map, HeapObject obj) {
459
    return BytecodeArray::SizeFor(
460
        BytecodeArray::cast(obj).synchronized_length());
461 462 463
  }
};

464 465
class BigInt::BodyDescriptor final : public BodyDescriptorBase {
 public:
466
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
467 468

  template <typename ObjectVisitor>
469
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
470 471
                                 ObjectVisitor* v) {}

472
  static inline int SizeOf(Map map, HeapObject obj) {
473
    return BigInt::SizeFor(BigInt::cast(obj).synchronized_length());
474 475 476
  }
};

477 478
class FixedDoubleArray::BodyDescriptor final : public BodyDescriptorBase {
 public:
479
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
480 481

  template <typename ObjectVisitor>
482
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
483 484
                                 ObjectVisitor* v) {}

485
  static inline int SizeOf(Map map, HeapObject obj) {
486
    return FixedDoubleArray::SizeFor(
487
        FixedDoubleArray::cast(obj).synchronized_length());
488 489 490
  }
};

491 492
class FeedbackMetadata::BodyDescriptor final : public BodyDescriptorBase {
 public:
493
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
494 495

  template <typename ObjectVisitor>
496
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
497 498
                                 ObjectVisitor* v) {}

499
  static inline int SizeOf(Map map, HeapObject obj) {
500
    return FeedbackMetadata::SizeFor(
501
        FeedbackMetadata::cast(obj).synchronized_slot_count());
502 503 504
  }
};

505 506
class FeedbackVector::BodyDescriptor final : public BodyDescriptorBase {
 public:
507
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
508
    return offset == kSharedFunctionInfoOffset ||
Irina Yatsenko's avatar
Irina Yatsenko committed
509
           offset == kOptimizedCodeWeakOrSmiOffset ||
510 511
           offset == kClosureFeedbackCellArrayOffset ||
           offset >= kFeedbackSlotsOffset;
512 513 514
  }

  template <typename ObjectVisitor>
515
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
516 517
                                 ObjectVisitor* v) {
    IteratePointer(obj, kSharedFunctionInfoOffset, v);
Irina Yatsenko's avatar
Irina Yatsenko committed
518
    IterateMaybeWeakPointer(obj, kOptimizedCodeWeakOrSmiOffset, v);
519
    IteratePointer(obj, kClosureFeedbackCellArrayOffset, v);
520
    IterateMaybeWeakPointers(obj, kFeedbackSlotsOffset, object_size, v);
521 522
  }

523
  static inline int SizeOf(Map map, HeapObject obj) {
524
    return FeedbackVector::SizeFor(FeedbackVector::cast(obj).length());
525 526 527
  }
};

528
class PreparseData::BodyDescriptor final : public BodyDescriptorBase {
529
 public:
530
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
531
    return offset >= PreparseData::cast(obj).inner_start_offset();
532 533 534
  }

  template <typename ObjectVisitor>
535
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
536
                                 ObjectVisitor* v) {
537
    PreparseData data = PreparseData::cast(obj);
538 539
    int start_offset = data.inner_start_offset();
    int end_offset = start_offset + data.children_length() * kTaggedSize;
540
    IteratePointers(obj, start_offset, end_offset, v);
541 542
  }

543
  static inline int SizeOf(Map map, HeapObject obj) {
544
    PreparseData data = PreparseData::cast(obj);
545
    return PreparseData::SizeFor(data.data_length(), data.children_length());
546 547 548
  }
};

549 550
class PrototypeInfo::BodyDescriptor final : public BodyDescriptorBase {
 public:
551
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
552 553 554 555
    return offset >= HeapObject::kHeaderSize;
  }

  template <typename ObjectVisitor>
556
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
557 558 559
                                 ObjectVisitor* v) {
    IteratePointers(obj, HeapObject::kHeaderSize, kObjectCreateMapOffset, v);
    IterateMaybeWeakPointer(obj, kObjectCreateMapOffset, v);
560
    IteratePointers(obj, kObjectCreateMapOffset + kTaggedSize, object_size, v);
561 562
  }

563
  static inline int SizeOf(Map map, HeapObject obj) {
564
    return obj.SizeFromMap(map);
565 566 567
  }
};

568
class JSWeakCollection::BodyDescriptorImpl final : public BodyDescriptorBase {
569
 public:
570
  STATIC_ASSERT(kTableOffset + kTaggedSize == kHeaderSizeOfAllWeakCollections);
571

572
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
573
    return IsValidJSObjectSlotImpl(map, obj, offset);
574 575 576
  }

  template <typename ObjectVisitor>
577
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
578
                                 ObjectVisitor* v) {
579
    IterateJSObjectBodyImpl(map, obj, kPropertiesOrHashOffset, object_size, v);
580 581
  }

582
  static inline int SizeOf(Map map, HeapObject object) {
583
    return map.instance_size();
584
  }
585 586 587 588
};

class Foreign::BodyDescriptor final : public BodyDescriptorBase {
 public:
589
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
590 591

  template <typename ObjectVisitor>
592
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
593
                                 ObjectVisitor* v) {
594
    v->VisitExternalReference(
595 596
        Foreign::cast(obj), reinterpret_cast<Address*>(
                                obj.RawField(kForeignAddressOffset).address()));
597 598
  }

599
  static inline int SizeOf(Map map, HeapObject object) { return kSize; }
600 601 602 603
};

class ExternalOneByteString::BodyDescriptor final : public BodyDescriptorBase {
 public:
604
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
605 606

  template <typename ObjectVisitor>
607
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
608
                                 ObjectVisitor* v) {}
609

610
  static inline int SizeOf(Map map, HeapObject object) { return kSize; }
611 612 613 614
};

class ExternalTwoByteString::BodyDescriptor final : public BodyDescriptorBase {
 public:
615
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
616 617

  template <typename ObjectVisitor>
618
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
619
                                 ObjectVisitor* v) {}
620

621
  static inline int SizeOf(Map map, HeapObject object) { return kSize; }
622 623
};

624 625 626 627 628 629 630 631 632 633 634 635 636 637
class CoverageInfo::BodyDescriptor final : public BodyDescriptorBase {
 public:
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }

  template <typename ObjectVisitor>
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                 ObjectVisitor* v) {}

  static inline int SizeOf(Map map, HeapObject object) {
    CoverageInfo info = CoverageInfo::cast(object);
    return CoverageInfo::SizeFor(info.slot_count());
  }
};

638 639
class Code::BodyDescriptor final : public BodyDescriptorBase {
 public:
640
  STATIC_ASSERT(kRelocationInfoOffset + kTaggedSize ==
641
                kDeoptimizationDataOffset);
642
  STATIC_ASSERT(kDeoptimizationDataOffset + kTaggedSize ==
643
                kSourcePositionTableOffset);
644
  STATIC_ASSERT(kSourcePositionTableOffset + kTaggedSize ==
645
                kCodeDataContainerOffset);
646
  STATIC_ASSERT(kCodeDataContainerOffset + kTaggedSize == kDataStart);
647

648
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
649 650 651 652
    // Slots in code can't be invalid because we never trim code objects.
    return true;
  }

653 654 655
  static constexpr int kRelocModeMask =
      RelocInfo::ModeMask(RelocInfo::CODE_TARGET) |
      RelocInfo::ModeMask(RelocInfo::RELATIVE_CODE_TARGET) |
656 657
      RelocInfo::ModeMask(RelocInfo::FULL_EMBEDDED_OBJECT) |
      RelocInfo::ModeMask(RelocInfo::COMPRESSED_EMBEDDED_OBJECT) |
658 659 660 661 662 663
      RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) |
      RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
      RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) |
      RelocInfo::ModeMask(RelocInfo::OFF_HEAP_TARGET) |
      RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY);

664
  template <typename ObjectVisitor>
665
  static inline void IterateBody(Map map, HeapObject obj, ObjectVisitor* v) {
666
    // GC does not visit data/code in the header and in the body directly.
667
    IteratePointers(obj, kRelocationInfoOffset, kDataStart, v);
668

669
    RelocIterator it(Code::cast(obj), kRelocModeMask);
670
    v->VisitRelocInfo(&it);
671 672 673
  }

  template <typename ObjectVisitor>
674
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
675
                                 ObjectVisitor* v) {
676
    IterateBody(map, obj, v);
677 678
  }

679
  static inline int SizeOf(Map map, HeapObject object) {
680
    return Code::unchecked_cast(object).CodeSize();
681 682 683
  }
};

684 685
class SeqOneByteString::BodyDescriptor final : public BodyDescriptorBase {
 public:
686
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
687 688

  template <typename ObjectVisitor>
689
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
690 691
                                 ObjectVisitor* v) {}

692
  static inline int SizeOf(Map map, HeapObject obj) {
693
    SeqOneByteString string = SeqOneByteString::cast(obj);
694
    return SeqOneByteString::SizeFor(string.synchronized_length());
695 696 697 698 699
  }
};

class SeqTwoByteString::BodyDescriptor final : public BodyDescriptorBase {
 public:
700
  static bool IsValidSlot(Map map, HeapObject obj, int offset) { return false; }
701 702

  template <typename ObjectVisitor>
703
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
704 705
                                 ObjectVisitor* v) {}

706
  static inline int SizeOf(Map map, HeapObject obj) {
707
    SeqTwoByteString string = SeqTwoByteString::cast(obj);
708
    return SeqTwoByteString::SizeFor(string.synchronized_length());
709 710
  }
};
711

712 713
class WasmInstanceObject::BodyDescriptor final : public BodyDescriptorBase {
 public:
714
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
715 716 717 718 719 720 721 722 723
    SLOW_DCHECK(std::is_sorted(std::begin(kTaggedFieldOffsets),
                               std::end(kTaggedFieldOffsets)));
    STATIC_ASSERT(sizeof(*kTaggedFieldOffsets) == sizeof(uint16_t));
    if (offset < int{8 * sizeof(*kTaggedFieldOffsets)} &&
        std::binary_search(std::begin(kTaggedFieldOffsets),
                           std::end(kTaggedFieldOffsets),
                           static_cast<uint16_t>(offset))) {
      return true;
    }
724
    return IsValidJSObjectSlotImpl(map, obj, offset);
725 726 727
  }

  template <typename ObjectVisitor>
728
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
729
                                 ObjectVisitor* v) {
730
    IteratePointers(obj, kPropertiesOrHashOffset, JSObject::kHeaderSize, v);
731 732 733
    for (uint16_t offset : kTaggedFieldOffsets) {
      IteratePointer(obj, offset, v);
    }
734
    IterateJSObjectBodyImpl(map, obj, kHeaderSize, object_size, v);
735 736
  }

737
  static inline int SizeOf(Map map, HeapObject object) {
738
    return map.instance_size();
739 740 741
  }
};

742 743
class Map::BodyDescriptor final : public BodyDescriptorBase {
 public:
744
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
745 746 747 748 749 750
    static_assert(
        Map::kEndOfStrongFieldsOffset == Map::kStartOfWeakFieldsOffset,
        "Leverage that weak fields directly follow strong fields for the "
        "check below");
    return offset >= Map::kStartOfStrongFieldsOffset &&
           offset < Map::kEndOfWeakFieldsOffset;
751 752 753
  }

  template <typename ObjectVisitor>
754
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
755
                                 ObjectVisitor* v) {
756 757
    IteratePointers(obj, Map::kStartOfStrongFieldsOffset,
                    Map::kEndOfStrongFieldsOffset, v);
758 759 760
    IterateMaybeWeakPointer(obj, kTransitionsOrPrototypeInfoOffset, v);
  }

761
  static inline int SizeOf(Map map, HeapObject obj) { return Map::kSize; }
762 763
};

764 765
class DataHandler::BodyDescriptor final : public BodyDescriptorBase {
 public:
766
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
767 768 769 770
    return offset >= HeapObject::kHeaderSize;
  }

  template <typename ObjectVisitor>
771
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
772 773 774 775 776 777
                                 ObjectVisitor* v) {
    static_assert(kSmiHandlerOffset < kData1Offset,
                  "Field order must be in sync with this iteration code");
    static_assert(kData1Offset < kSizeWithData1,
                  "Field order must be in sync with this iteration code");
    IteratePointers(obj, kSmiHandlerOffset, kData1Offset, v);
778
    IterateMaybeWeakPointers(obj, kData1Offset, object_size, v);
779 780
  }

781
  static inline int SizeOf(Map map, HeapObject object) {
782
    return object.SizeFromMap(map);
783 784 785
  }
};

786
class NativeContext::BodyDescriptor final : public BodyDescriptorBase {
787
 public:
788
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
789
    return offset < NativeContext::kEndOfTaggedFieldsOffset;
790 791 792
  }

  template <typename ObjectVisitor>
793
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
794
                                 ObjectVisitor* v) {
795 796 797 798
    IteratePointers(obj, NativeContext::kStartOfStrongFieldsOffset,
                    NativeContext::kEndOfStrongFieldsOffset, v);
    IterateCustomWeakPointers(obj, NativeContext::kStartOfWeakFieldsOffset,
                              NativeContext::kEndOfWeakFieldsOffset, v);
799 800
  }

801
  static inline int SizeOf(Map map, HeapObject object) {
802
    return NativeContext::kSize;
803 804 805 806 807
  }
};

class CodeDataContainer::BodyDescriptor final : public BodyDescriptorBase {
 public:
808
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
809 810 811 812 813
    return offset >= CodeDataContainer::kHeaderSize &&
           offset < CodeDataContainer::kSize;
  }

  template <typename ObjectVisitor>
814
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
815 816 817 818 819 820 821 822
                                 ObjectVisitor* v) {
    IteratePointers(obj, CodeDataContainer::kHeaderSize,
                    CodeDataContainer::kPointerFieldsStrongEndOffset, v);
    IterateCustomWeakPointers(
        obj, CodeDataContainer::kPointerFieldsStrongEndOffset,
        CodeDataContainer::kPointerFieldsWeakEndOffset, v);
  }

823
  static inline int SizeOf(Map map, HeapObject object) {
824 825 826 827
    return CodeDataContainer::kSize;
  }
};

828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
class WasmStruct::BodyDescriptor final : public BodyDescriptorBase {
 public:
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
    // Fields in WasmStructs never change their types in place, so
    // there should never be a need to call this function.
    UNREACHABLE();
    return false;
  }

  template <typename ObjectVisitor>
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                 ObjectVisitor* v) {
    WasmStruct wasm_struct = WasmStruct::cast(obj);
    wasm::StructType* type = WasmStruct::type(map);
    for (uint32_t i = 0; i < type->field_count(); i++) {
      if (!type->field(i).IsReferenceType()) continue;
      int offset =
          WasmStruct::kHeaderSize + static_cast<int>(type->field_offset(i));
      v->VisitPointer(wasm_struct, wasm_struct.RawField(offset));
    }
  }

  static inline int SizeOf(Map map, HeapObject object) {
    return map.instance_size();
  }
};

855 856
class EmbedderDataArray::BodyDescriptor final : public BodyDescriptorBase {
 public:
857
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
858
#ifdef V8_COMPRESS_POINTERS
859
    STATIC_ASSERT(kEmbedderDataSlotSize == 2 * kTaggedSize);
860 861 862 863 864 865 866
    STATIC_ASSERT(base::bits::IsPowerOfTwo(kEmbedderDataSlotSize));
    return (offset < EmbedderDataArray::kHeaderSize) ||
           (((offset - EmbedderDataArray::kHeaderSize) &
             (kEmbedderDataSlotSize - 1)) ==
            EmbedderDataSlot::kTaggedPayloadOffset);
#else
    STATIC_ASSERT(kEmbedderDataSlotSize == kTaggedSize);
867 868 869
    // We store raw aligned pointers as Smis, so it's safe to iterate the whole
    // array.
    return true;
870
#endif
871 872 873
  }

  template <typename ObjectVisitor>
874
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
875
                                 ObjectVisitor* v) {
876
#ifdef V8_COMPRESS_POINTERS
877
    STATIC_ASSERT(kEmbedderDataSlotSize == 2 * kTaggedSize);
878 879 880 881 882 883 884
    // Iterate only tagged payload of the embedder slots and skip raw payload.
    for (int offset = EmbedderDataArray::OffsetOfElementAt(0) +
                      EmbedderDataSlot::kTaggedPayloadOffset;
         offset < object_size; offset += kEmbedderDataSlotSize) {
      IteratePointer(obj, offset, v);
    }
#else
885 886
    // We store raw aligned pointers as Smis, so it's safe to iterate the whole
    // array.
887
    STATIC_ASSERT(kEmbedderDataSlotSize == kTaggedSize);
888
    IteratePointers(obj, EmbedderDataArray::kHeaderSize, object_size, v);
889
#endif
890 891
  }

892
  static inline int SizeOf(Map map, HeapObject object) {
893
    return object.SizeFromMap(map);
894 895 896
  }
};

897
template <typename Op, typename ReturnType, typename T1, typename T2,
898 899
          typename T3, typename T4>
ReturnType BodyDescriptorApply(InstanceType type, T1 p1, T2 p2, T3 p3, T4 p4) {
900 901 902 903 904
  if (type < FIRST_NONSTRING_TYPE) {
    switch (type & kStringRepresentationMask) {
      case kSeqStringTag:
        return ReturnType();
      case kConsStringTag:
905
        return Op::template apply<ConsString::BodyDescriptor>(p1, p2, p3, p4);
906
      case kThinStringTag:
907
        return Op::template apply<ThinString::BodyDescriptor>(p1, p2, p3, p4);
908
      case kSlicedStringTag:
909
        return Op::template apply<SlicedString::BodyDescriptor>(p1, p2, p3, p4);
910 911 912
      case kExternalStringTag:
        if ((type & kStringEncodingMask) == kOneByteStringTag) {
          return Op::template apply<ExternalOneByteString::BodyDescriptor>(
913
              p1, p2, p3, p4);
914 915
        } else {
          return Op::template apply<ExternalTwoByteString::BodyDescriptor>(
916
              p1, p2, p3, p4);
917 918 919 920 921 922
        }
    }
    UNREACHABLE();
  }

  switch (type) {
923 924 925
    case EMBEDDER_DATA_ARRAY_TYPE:
      return Op::template apply<EmbedderDataArray::BodyDescriptor>(p1, p2, p3,
                                                                   p4);
926
    case FIXED_ARRAY_TYPE:
927
    case OBJECT_BOILERPLATE_DESCRIPTION_TYPE:
928
    case CLOSURE_FEEDBACK_CELL_ARRAY_TYPE:
929
    case HASH_TABLE_TYPE:
930 931
    case ORDERED_HASH_MAP_TYPE:
    case ORDERED_HASH_SET_TYPE:
932
    case ORDERED_NAME_DICTIONARY_TYPE:
933 934 935 936 937
    case NAME_DICTIONARY_TYPE:
    case GLOBAL_DICTIONARY_TYPE:
    case NUMBER_DICTIONARY_TYPE:
    case SIMPLE_NUMBER_DICTIONARY_TYPE:
    case STRING_TABLE_TYPE:
938
    case SCOPE_INFO_TYPE:
939
    case SCRIPT_CONTEXT_TABLE_TYPE:
940
      return Op::template apply<FixedArray::BodyDescriptor>(p1, p2, p3, p4);
941 942 943
    case EPHEMERON_HASH_TABLE_TYPE:
      return Op::template apply<EphemeronHashTable::BodyDescriptor>(p1, p2, p3,
                                                                    p4);
944
    case AWAIT_CONTEXT_TYPE:
945 946 947 948 949 950 951 952
    case BLOCK_CONTEXT_TYPE:
    case CATCH_CONTEXT_TYPE:
    case DEBUG_EVALUATE_CONTEXT_TYPE:
    case EVAL_CONTEXT_TYPE:
    case FUNCTION_CONTEXT_TYPE:
    case MODULE_CONTEXT_TYPE:
    case SCRIPT_CONTEXT_TYPE:
    case WITH_CONTEXT_TYPE:
953 954 955
      return Op::template apply<Context::BodyDescriptor>(p1, p2, p3, p4);
    case NATIVE_CONTEXT_TYPE:
      return Op::template apply<NativeContext::BodyDescriptor>(p1, p2, p3, p4);
956
    case WEAK_FIXED_ARRAY_TYPE:
957
      return Op::template apply<WeakFixedArray::BodyDescriptor>(p1, p2, p3, p4);
958 959
    case WEAK_ARRAY_LIST_TYPE:
      return Op::template apply<WeakArrayList::BodyDescriptor>(p1, p2, p3, p4);
960 961
    case FIXED_DOUBLE_ARRAY_TYPE:
      return ReturnType();
962
    case FEEDBACK_METADATA_TYPE:
963 964
      return Op::template apply<FeedbackMetadata::BodyDescriptor>(p1, p2, p3,
                                                                  p4);
965
    case PROPERTY_ARRAY_TYPE:
966
      return Op::template apply<PropertyArray::BodyDescriptor>(p1, p2, p3, p4);
967
    case DESCRIPTOR_ARRAY_TYPE:
968 969
      return Op::template apply<DescriptorArray::BodyDescriptor>(p1, p2, p3,
                                                                 p4);
970
    case TRANSITION_ARRAY_TYPE:
971 972
      return Op::template apply<TransitionArray::BodyDescriptor>(p1, p2, p3,
                                                                 p4);
973
    case FEEDBACK_CELL_TYPE:
974
      return Op::template apply<FeedbackCell::BodyDescriptor>(p1, p2, p3, p4);
975
    case FEEDBACK_VECTOR_TYPE:
976
      return Op::template apply<FeedbackVector::BodyDescriptor>(p1, p2, p3, p4);
977 978
    case COVERAGE_INFO_TYPE:
      return Op::template apply<CoverageInfo::BodyDescriptor>(p1, p2, p3, p4);
979 980
    case WASM_STRUCT_TYPE:
      return Op::template apply<WasmStruct::BodyDescriptor>(p1, p2, p3, p4);
981
    case JS_OBJECT_TYPE:
982
    case JS_ERROR_TYPE:
983
    case JS_ARGUMENTS_OBJECT_TYPE:
984
    case JS_ASYNC_FROM_SYNC_ITERATOR_TYPE:
985
    case JS_PROMISE_TYPE:
986 987
    case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
    case JS_GENERATOR_OBJECT_TYPE:
988
    case JS_ASYNC_FUNCTION_OBJECT_TYPE:
989
    case JS_ASYNC_GENERATOR_OBJECT_TYPE:
990
    case JS_PRIMITIVE_WRAPPER_TYPE:
991
    case JS_DATE_TYPE:
992
    case JS_AGGREGATE_ERROR_TYPE:
993
    case JS_ARRAY_TYPE:
994
    case JS_ARRAY_ITERATOR_TYPE:
995
    case JS_MODULE_NAMESPACE_TYPE:
996 997
    case JS_SET_TYPE:
    case JS_MAP_TYPE:
998 999 1000 1001 1002
    case JS_SET_KEY_VALUE_ITERATOR_TYPE:
    case JS_SET_VALUE_ITERATOR_TYPE:
    case JS_MAP_KEY_ITERATOR_TYPE:
    case JS_MAP_KEY_VALUE_ITERATOR_TYPE:
    case JS_MAP_VALUE_ITERATOR_TYPE:
1003
    case JS_STRING_ITERATOR_TYPE:
1004 1005
    case JS_REG_EXP_STRING_ITERATOR_TYPE:
    case JS_REG_EXP_TYPE:
1006 1007
    case JS_GLOBAL_PROXY_TYPE:
    case JS_GLOBAL_OBJECT_TYPE:
1008
    case JS_API_OBJECT_TYPE:
1009
    case JS_SPECIAL_API_OBJECT_TYPE:
1010
    case JS_MESSAGE_OBJECT_TYPE:
1011
    case JS_BOUND_FUNCTION_TYPE:
1012
    case JS_FINALIZATION_REGISTRY_TYPE:
1013
#ifdef V8_INTL_SUPPORT
1014 1015 1016
    case JS_V8_BREAK_ITERATOR_TYPE:
    case JS_COLLATOR_TYPE:
    case JS_DATE_TIME_FORMAT_TYPE:
1017
    case JS_DISPLAY_NAMES_TYPE:
1018 1019 1020 1021 1022 1023 1024
    case JS_LIST_FORMAT_TYPE:
    case JS_LOCALE_TYPE:
    case JS_NUMBER_FORMAT_TYPE:
    case JS_PLURAL_RULES_TYPE:
    case JS_RELATIVE_TIME_FORMAT_TYPE:
    case JS_SEGMENT_ITERATOR_TYPE:
    case JS_SEGMENTER_TYPE:
1025
#endif  // V8_INTL_SUPPORT
1026 1027 1028 1029 1030
    case WASM_EXCEPTION_OBJECT_TYPE:
    case WASM_GLOBAL_OBJECT_TYPE:
    case WASM_MEMORY_OBJECT_TYPE:
    case WASM_MODULE_OBJECT_TYPE:
    case WASM_TABLE_OBJECT_TYPE:
1031
      return Op::template apply<JSObject::BodyDescriptor>(p1, p2, p3, p4);
1032
    case WASM_INSTANCE_OBJECT_TYPE:
1033 1034
      return Op::template apply<WasmInstanceObject::BodyDescriptor>(p1, p2, p3,
                                                                    p4);
1035 1036
    case JS_WEAK_MAP_TYPE:
    case JS_WEAK_SET_TYPE:
1037 1038
      return Op::template apply<JSWeakCollection::BodyDescriptor>(p1, p2, p3,
                                                                  p4);
1039
    case JS_ARRAY_BUFFER_TYPE:
1040
      return Op::template apply<JSArrayBuffer::BodyDescriptor>(p1, p2, p3, p4);
1041 1042 1043 1044
    case JS_DATA_VIEW_TYPE:
      return Op::template apply<JSDataView::BodyDescriptor>(p1, p2, p3, p4);
    case JS_TYPED_ARRAY_TYPE:
      return Op::template apply<JSTypedArray::BodyDescriptor>(p1, p2, p3, p4);
1045
    case JS_FUNCTION_TYPE:
1046
      return Op::template apply<JSFunction::BodyDescriptor>(p1, p2, p3, p4);
1047 1048
    case WEAK_CELL_TYPE:
      return Op::template apply<WeakCell::BodyDescriptor>(p1, p2, p3, p4);
1049 1050
    case JS_WEAK_REF_TYPE:
      return Op::template apply<JSWeakRef::BodyDescriptor>(p1, p2, p3, p4);
1051
    case ODDBALL_TYPE:
1052
      return Op::template apply<Oddball::BodyDescriptor>(p1, p2, p3, p4);
1053
    case JS_PROXY_TYPE:
1054
      return Op::template apply<JSProxy::BodyDescriptor>(p1, p2, p3, p4);
1055
    case FOREIGN_TYPE:
1056
      return Op::template apply<Foreign::BodyDescriptor>(p1, p2, p3, p4);
1057
    case MAP_TYPE:
1058
      return Op::template apply<Map::BodyDescriptor>(p1, p2, p3, p4);
1059
    case CODE_TYPE:
1060
      return Op::template apply<Code::BodyDescriptor>(p1, p2, p3, p4);
1061
    case CELL_TYPE:
1062
      return Op::template apply<Cell::BodyDescriptor>(p1, p2, p3, p4);
1063
    case PROPERTY_CELL_TYPE:
1064
      return Op::template apply<PropertyCell::BodyDescriptor>(p1, p2, p3, p4);
1065
    case SYMBOL_TYPE:
1066
      return Op::template apply<Symbol::BodyDescriptor>(p1, p2, p3, p4);
1067
    case BYTECODE_ARRAY_TYPE:
1068
      return Op::template apply<BytecodeArray::BodyDescriptor>(p1, p2, p3, p4);
1069
    case SMALL_ORDERED_HASH_SET_TYPE:
1070 1071
      return Op::template apply<
          SmallOrderedHashTable<SmallOrderedHashSet>::BodyDescriptor>(p1, p2,
1072
                                                                      p3, p4);
1073 1074 1075
    case SMALL_ORDERED_HASH_MAP_TYPE:
      return Op::template apply<
          SmallOrderedHashTable<SmallOrderedHashMap>::BodyDescriptor>(p1, p2,
1076
                                                                      p3, p4);
1077 1078 1079 1080
    case SMALL_ORDERED_NAME_DICTIONARY_TYPE:
      return Op::template apply<
          SmallOrderedHashTable<SmallOrderedNameDictionary>::BodyDescriptor>(
          p1, p2, p3, p4);
1081
    case CODE_DATA_CONTAINER_TYPE:
1082 1083
      return Op::template apply<CodeDataContainer::BodyDescriptor>(p1, p2, p3,
                                                                   p4);
1084
    case PREPARSE_DATA_TYPE:
1085
      return Op::template apply<PreparseData::BodyDescriptor>(p1, p2, p3, p4);
1086
    case UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE:
1087
      return Op::template apply<
1088
          UncompiledDataWithoutPreparseData::BodyDescriptor>(p1, p2, p3, p4);
1089
    case UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE:
1090 1091
      return Op::template apply<UncompiledDataWithPreparseData::BodyDescriptor>(
          p1, p2, p3, p4);
1092 1093 1094 1095
    case HEAP_NUMBER_TYPE:
    case FILLER_TYPE:
    case BYTE_ARRAY_TYPE:
    case FREE_SPACE_TYPE:
1096
    case BIGINT_TYPE:
1097 1098 1099
      return ReturnType();

    case SHARED_FUNCTION_INFO_TYPE: {
1100 1101
      return Op::template apply<SharedFunctionInfo::BodyDescriptor>(p1, p2, p3,
                                                                    p4);
1102
    }
1103 1104
    case ALLOCATION_SITE_TYPE:
      return Op::template apply<AllocationSite::BodyDescriptor>(p1, p2, p3, p4);
1105

1106
#define MAKE_STRUCT_CASE(TYPE, Name, name) case TYPE:
1107 1108
      STRUCT_LIST(MAKE_STRUCT_CASE)
#undef MAKE_STRUCT_CASE
1109
      if (type == PROTOTYPE_INFO_TYPE) {
1110 1111
        return Op::template apply<PrototypeInfo::BodyDescriptor>(p1, p2, p3,
                                                                 p4);
1112 1113 1114
      } else if (type == WASM_CAPI_FUNCTION_DATA_TYPE) {
        return Op::template apply<WasmCapiFunctionData::BodyDescriptor>(p1, p2,
                                                                        p3, p4);
1115 1116 1117
      } else if (type == WASM_INDIRECT_FUNCTION_TABLE_TYPE) {
        return Op::template apply<WasmIndirectFunctionTable::BodyDescriptor>(
            p1, p2, p3, p4);
1118
      } else {
1119
        return Op::template apply<StructBodyDescriptor>(p1, p2, p3, p4);
1120
      }
1121
    case CALL_HANDLER_INFO_TYPE:
1122
      return Op::template apply<StructBodyDescriptor>(p1, p2, p3, p4);
1123 1124
    case LOAD_HANDLER_TYPE:
    case STORE_HANDLER_TYPE:
1125
      return Op::template apply<DataHandler::BodyDescriptor>(p1, p2, p3, p4);
1126 1127 1128
    case SOURCE_TEXT_MODULE_TYPE:
      return Op::template apply<SourceTextModule::BodyDescriptor>(p1, p2, p3,
                                                                  p4);
1129 1130 1131
    case SYNTHETIC_MODULE_TYPE:
      return Op::template apply<SyntheticModule::BodyDescriptor>(p1, p2, p3,
                                                                 p4);
1132 1133 1134 1135 1136 1137
#define MAKE_TORQUE_BODY_DESCRIPTOR_APPLY(TYPE, TypeName) \
  case TYPE:                                              \
    return Op::template apply<TypeName::BodyDescriptor>(p1, p2, p3, p4);
      TORQUE_BODY_DESCRIPTOR_LIST(MAKE_TORQUE_BODY_DESCRIPTOR_APPLY)
#undef MAKE_TORQUE_BODY_DESCRIPTOR_APPLY

1138 1139 1140 1141 1142 1143 1144 1145
    default:
      PrintF("Unknown type: %d\n", type);
      UNREACHABLE();
  }
}

template <typename ObjectVisitor>
void HeapObject::IterateFast(ObjectVisitor* v) {
1146
  BodyDescriptorBase::IteratePointer(*this, kMapOffset, v);
1147
  IterateBodyFast(v);
1148 1149 1150 1151
}

template <typename ObjectVisitor>
void HeapObject::IterateBodyFast(ObjectVisitor* v) {
1152
  Map m = map();
1153
  IterateBodyFast(m, SizeFromMap(m), v);
1154 1155 1156 1157
}

struct CallIterateBody {
  template <typename BodyDescriptor, typename ObjectVisitor>
1158
  static void apply(Map map, HeapObject obj, int object_size,
1159 1160
                    ObjectVisitor* v) {
    BodyDescriptor::IterateBody(map, obj, object_size, v);
1161 1162 1163 1164
  }
};

template <typename ObjectVisitor>
1165
void HeapObject::IterateBodyFast(Map map, int object_size, ObjectVisitor* v) {
1166
  BodyDescriptorApply<CallIterateBody, void>(map.instance_type(), map, *this,
1167
                                             object_size, v);
1168
}
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182

class EphemeronHashTable::BodyDescriptor final : public BodyDescriptorBase {
 public:
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
    return (offset >= EphemeronHashTable::kHeaderSize);
  }

  template <typename ObjectVisitor>
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                 ObjectVisitor* v) {
    int entries_start = EphemeronHashTable::kHeaderSize +
                        EphemeronHashTable::kElementsStartIndex * kTaggedSize;
    IteratePointers(obj, EphemeronHashTable::kHeaderSize, entries_start, v);
    EphemeronHashTable table = EphemeronHashTable::unchecked_cast(obj);
1183
    for (InternalIndex i : table.IterateEntries()) {
1184 1185
      const int key_index = EphemeronHashTable::EntryToIndex(i);
      const int value_index = EphemeronHashTable::EntryToValueIndex(i);
1186
      IterateEphemeron(obj, i.as_int(), OffsetOfElementAt(key_index),
1187 1188 1189 1190 1191
                       OffsetOfElementAt(value_index), v);
    }
  }

  static inline int SizeOf(Map map, HeapObject object) {
1192
    return object.SizeFromMap(map);
1193 1194 1195
  }
};

1196 1197 1198
}  // namespace internal
}  // namespace v8

1199
#endif  // V8_OBJECTS_OBJECTS_BODY_DESCRIPTORS_INL_H_