Pass the pointer of owning object in constructorWriteBarrierRange (fa…

…cebook#1511)

Summary:
Pull Request resolved: facebook#1511

Add a `GCCell` pointer parameter to `constructorWriteBarrierRange`,
which represents the owning object address. It's used to get the
correct card table for pointers live in large segment.

Differential Revision: D62171114

include/hermes/VM/AlignedHeapSegment.h

@@ -268,6 +268,16 @@ class AlignedHeapSegment {
     return markBits->at(ind);
   }
 
+#ifndef NDEBUG
+  /// Get the storage end of segment that \p cell resides in.
+  static char *storageEnd(const GCCell *cell) {
+    auto *start = alignedStorageStart(cell);
+    auto *segmentInfo = reinterpret_cast<const SHSegmentInfo *>(start);
+    return start +
+        (segmentInfo->shiftedSegmentSize << HERMESVM_LOG_HEAP_SEGMENT_SIZE);
+  }
+#endif
+
  protected:
   AlignedHeapSegment() = default;
 

include/hermes/VM/ArrayStorage.h

@@ -237,7 +237,7 @@ class ArrayStorageBase final
     auto *fromStart = other->data();
     auto *fromEnd = fromStart + otherSz;
     GCHVType::uninitialized_copy(
-        fromStart, fromEnd, data() + sz, runtime.getHeap());
+        fromStart, fromEnd, data() + sz, runtime.getHeap(), this);
     size_.store(sz + otherSz, std::memory_order_release);
   }
 

include/hermes/VM/GCBase.h

@@ -1162,6 +1162,7 @@ class GCBase {
   void constructorWriteBarrier(const GCPointerBase *loc, const GCCell *value);
   template <typename HVType>
   void constructorWriteBarrierRange(
+      const GCCell *owningObj,
       const GCHermesValueBase<HVType> *start,
       uint32_t numHVs);
   template <typename HVType>

include/hermes/VM/HadesGC.h

@@ -216,27 +216,30 @@ class HadesGC final : public GCBase {
 
   template <typename HVType>
   void constructorWriteBarrierRange(
+      const GCCell *owningObj,
       const GCHermesValueBase<HVType> *start,
       uint32_t numHVs) {
     // A pointer that lives in YG never needs any write barriers.
     if (LLVM_UNLIKELY(!inYoungGen(start)))
-      constructorWriteBarrierRangeSlow(start, numHVs);
+      constructorWriteBarrierRangeSlow(owningObj, start, numHVs);
   }
   template <typename HVType>
   void constructorWriteBarrierRangeSlow(
+      const GCCell *owningObj,
       const GCHermesValueBase<HVType> *start,
       uint32_t numHVs) {
     assert(
-        FixedSizeHeapSegment::containedInSame(start, start + numHVs) &&
+        reinterpret_cast<const char *>(start + numHVs) <
+            AlignedHeapSegment::storageEnd(owningObj) &&
         "Range must start and end within a heap segment.");
 
-    // Most constructors should be running in the YG, so in the common case, we
-    // can avoid doing anything for the whole range. If the range is in the OG,
-    // then just dirty all the cards corresponding to it, and we can scan them
-    // for pointers later. This is less precise but makes the write barrier
-    // faster.
+    // Most constructors should be running in the YG, so in the common case,
+    // we can avoid doing anything for the whole range. If the range is in
+    // the OG, then just dirty all the cards corresponding to it, and we can
+    // scan them for pointers later. This is less precise but makes the
+    // write barrier faster.
 
-    FixedSizeHeapSegment::cardTableCovering(start)->dirtyCardsForAddressRange(
+    AlignedHeapSegment::cardTableCovering(owningObj)->dirtyCardsForAddressRange(
         start, start + numHVs);
   }
 

include/hermes/VM/HermesValue-inline.h

@@ -182,7 +182,8 @@ inline GCHermesValueBase<HVType> *GCHermesValueBase<HVType>::uninitialized_copy(
     GCHermesValueBase<HVType> *first,
     GCHermesValueBase<HVType> *last,
     GCHermesValueBase<HVType> *result,
-    GC &gc) {
+    GC &gc,
+    const GCCell *owningObj) {
 #ifndef NDEBUG
   uintptr_t fromFirst = reinterpret_cast<uintptr_t>(first),
             fromLast = reinterpret_cast<uintptr_t>(last);
@@ -194,7 +195,7 @@ inline GCHermesValueBase<HVType> *GCHermesValueBase<HVType>::uninitialized_copy(
       "Uninitialized range cannot overlap with an initialized one.");
 #endif
 
-  gc.constructorWriteBarrierRange(result, last - first);
+  gc.constructorWriteBarrierRange(owningObj, result, last - first);
   // memcpy is fine for an uninitialized copy.
   std::memcpy(
       reinterpret_cast<void *>(result), first, (last - first) * sizeof(HVType));

include/hermes/VM/HermesValue.h

@@ -589,7 +589,8 @@ class GCHermesValueBase final : public HVType {
       GCHermesValueBase<HVType> *first,
       GCHermesValueBase<HVType> *last,
       GCHermesValueBase<HVType> *result,
-      GC &gc);
+      GC &gc,
+      const GCCell *owningObj);
 
   /// Copies a range of values and performs a write barrier on each.
   template <typename InputIt, typename OutputIt>

include/hermes/VM/MallocGC.h

@@ -243,6 +243,7 @@ class MallocGC final : public GCBase {
   void writeBarrierRange(const GCHermesValueBase<HVType> *, uint32_t) {}
   template <typename HVType>
   void constructorWriteBarrierRange(
+      const GCCell *,
       const GCHermesValueBase<HVType> *,
       uint32_t) {}
   template <typename HVType>

lib/VM/ArrayStorage.cpp

@@ -104,7 +104,8 @@ ExecutionStatus ArrayStorageBase<HVType>::reallocateToLarger(
   {
     GCHVType *from = self->data() + fromFirst;
     GCHVType *to = newSelf->data() + toFirst;
-    GCHVType::uninitialized_copy(from, from + copySize, to, runtime.getHeap());
+    GCHVType::uninitialized_copy(
+        from, from + copySize, to, runtime.getHeap(), newSelf);
   }
 
   // Initialize the elements before the first copied element.

lib/VM/GCBase.cpp

@@ -965,6 +965,11 @@ bool GCBase::shouldSanitizeHandles() {
     runtimeGCDispatch([&](auto *gc) { gc->name(arg1, arg2); }); \
   }
 
+#define GCBASE_BARRIER_3(name, type1, type2, type3)                   \
+  void GCBase::name(type1 arg1, type2 arg2, type3 arg3) {             \
+    runtimeGCDispatch([&](auto *gc) { gc->name(arg1, arg2, arg3); }); \
+  }
+
 GCBASE_BARRIER_2(writeBarrier, const GCHermesValue *, HermesValue);
 GCBASE_BARRIER_2(writeBarrier, const GCSmallHermesValue *, SmallHermesValue);
 GCBASE_BARRIER_2(writeBarrier, const GCPointerBase *, const GCCell *);
@@ -979,9 +984,14 @@ GCBASE_BARRIER_2(
     const GCCell *);
 GCBASE_BARRIER_2(writeBarrierRange, const GCHermesValue *, uint32_t);
 GCBASE_BARRIER_2(writeBarrierRange, const GCSmallHermesValue *, uint32_t);
-GCBASE_BARRIER_2(constructorWriteBarrierRange, const GCHermesValue *, uint32_t);
-GCBASE_BARRIER_2(
+GCBASE_BARRIER_3(
+    constructorWriteBarrierRange,
+    const GCCell *,
+    const GCHermesValue *,
+    uint32_t);
+GCBASE_BARRIER_3(
     constructorWriteBarrierRange,
+    const GCCell *,
     const GCSmallHermesValue *,
     uint32_t);
 GCBASE_BARRIER_1(snapshotWriteBarrier, const GCHermesValue *);

lib/VM/SegmentedArray.cpp

@@ -294,7 +294,8 @@ ExecutionStatus SegmentedArrayBase<HVType>::growRight(
       self->inlineStorage(),
       self->inlineStorage() + numSlotsUsed,
       newSegmentedArray->inlineStorage(),
-      runtime.getHeap());
+      runtime.getHeap(),
+      newSegmentedArray.get());
   // Set the size of the new array to be the same as the old array's size.
   newSegmentedArray->numSlotsUsed_.store(
       numSlotsUsed, std::memory_order_release);