Pass the pointer of owning object in GCPointer::set() part II

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

@@ -204,6 +204,12 @@ enum XorPtrKeyID {
 ///         const GCSmallHermesValue *start,
 ///         uint32_t numHVs);
 ///
+///   The above barriers may have a variant with "ForLargeObj" suffix, which is
+///   used when the heap location may be from a GCCell that supports large
+///   allocation. This variant is less efficient since it has to load the cards
+///   array through pointer in SHSegmentInfo, instead of the inline array field
+///   in CardTable structure.
+///
 ///   In debug builds: is a write barrier necessary for a write of the given
 ///   GC pointer \p value to the given \p loc?
 ///      bool needsWriteBarrier(void *loc, void *value);
@@ -226,7 +232,7 @@ enum XorPtrKeyID {
 ///   Return the maximum amount of bytes holdable by this heap.
 ///     gcheapsize_t max() const;
 ///   Return the total amount of bytes of storage this GC will require.
-///   This will be a multiple of AlignedHeapSegment::storageSize().
+///   This will be a multiple of FixedSizeHeapSegment::storageSize().
 ///     gcheapsize_t storageFootprint() const;
 ///
 class GCBase {
@@ -1154,18 +1160,44 @@ class GCBase {
   /// Default implementations for read and write barriers: do nothing.
   void writeBarrier(const GCHermesValue *loc, HermesValue value);
   void writeBarrier(const GCSmallHermesValue *loc, SmallHermesValue value);
+  void writeBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCHermesValue *loc,
+      HermesValue value);
+  void writeBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCSmallHermesValue *loc,
+      SmallHermesValue value);
   void writeBarrier(const GCPointerBase *loc, const GCCell *value);
+  void writeBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCPointerBase *loc,
+      const GCCell *value);
   void constructorWriteBarrier(const GCHermesValue *loc, HermesValue value);
   void constructorWriteBarrier(
       const GCSmallHermesValue *loc,
       SmallHermesValue value);
+  void constructorWriteBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCHermesValue *loc,
+      HermesValue value);
+  void constructorWriteBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCSmallHermesValue *loc,
+      SmallHermesValue value);
   void constructorWriteBarrier(const GCPointerBase *loc, const GCCell *value);
+  void constructorWriteBarrierForLargeObj(
+      const GCCell *owningObj,
+      const GCPointerBase *loc,
+      const GCCell *value);
   void writeBarrierRange(const GCHermesValue *start, uint32_t numHVs);
   void writeBarrierRange(const GCSmallHermesValue *start, uint32_t numHVs);
   void constructorWriteBarrierRange(
+      const GCCell *owningObj,
       const GCHermesValue *start,
       uint32_t numHVs);
   void constructorWriteBarrierRange(
+      const GCCell *owningObj,
       const GCSmallHermesValue *start,
       uint32_t numHVs);
   void snapshotWriteBarrier(const GCHermesValue *loc);

include/hermes/VM/GCPointer-inline.h

@@ -59,6 +59,44 @@ GCPointerBase::set(PointerBase &base, CompressedPointer ptr, GC &gc) {
   setNoBarrier(ptr);
 }
 
+inline void GCPointerBase::set(
+    PointerBase &base,
+    GCCell *ptr,
+    GC &gc,
+    const GCCell *owningObj) {
+  assert(
+      (!ptr || gc.validPointer(ptr)) &&
+      "Cannot set a GCPointer to an invalid pointer");
+  // Write barrier must happen before the write.
+  gc.writeBarrierForLargeObj(owningObj, this, ptr);
+  setNoBarrier(CompressedPointer::encode(ptr, base));
+}
+
+inline void GCPointerBase::setNonNull(
+    PointerBase &base,
+    GCCell *ptr,
+    GC &gc,
+    const GCCell *owningObj) {
+  assert(
+      gc.validPointer(ptr) && "Cannot set a GCPointer to an invalid pointer");
+  // Write barrier must happen before the write.
+  gc.writeBarrierForLargeObj(owningObj, this, ptr);
+  setNoBarrier(CompressedPointer::encodeNonNull(ptr, base));
+}
+
+inline void GCPointerBase::set(
+    PointerBase &base,
+    CompressedPointer ptr,
+    GC &gc,
+    const GCCell *owningObj) {
+  assert(
+      (!ptr || gc.validPointer(ptr.get(base))) &&
+      "Cannot set a GCPointer to an invalid pointer");
+  // Write barrier must happen before the write.
+  gc.writeBarrierForLargeObj(owningObj, this, ptr.get(base));
+  setNoBarrier(ptr);
+}
+
 inline void GCPointerBase::setNull(GC &gc) {
   gc.snapshotWriteBarrier(this);
   setNoBarrier(CompressedPointer(nullptr));

include/hermes/VM/GCPointer.h

@@ -34,14 +34,31 @@ class GCPointerBase : public CompressedPointer {
   class NoBarriers : public std::false_type {};
   class YesBarriers : public std::true_type {};
 
-  /// This must be used to assign a new value to this GCPointer.
+  /// This must be used to assign a new value to this GCPointer. This must not
+  /// be used if it lives in an object that supports large allocation.
   /// \param ptr The memory being pointed to.
   /// \param base The base of ptr.
   /// \param gc Used for write barriers.
   inline void set(PointerBase &base, GCCell *ptr, GC &gc);
   inline void set(PointerBase &base, CompressedPointer ptr, GC &gc);
   inline void setNonNull(PointerBase &base, GCCell *ptr, GC &gc);
 
+  /// This must be used to assign a new value to this GCPointer.
+  /// \param ptr The memory being pointed to.
+  /// \param base The base of ptr.
+  /// \param gc Used for write barriers.
+  /// \param owningObj The object that contains this GCPointer, used by the
+  /// writer barriers.
+  inline void
+  set(PointerBase &base, GCCell *ptr, GC &gc, const GCCell *owningObj);
+  inline void set(
+      PointerBase &base,
+      CompressedPointer ptr,
+      GC &gc,
+      const GCCell *owningObj);
+  inline void
+  setNonNull(PointerBase &base, GCCell *ptr, GC &gc, const GCCell *owningObj);
+
   /// Set this pointer to null. This needs a write barrier in some types of
   /// garbage collectors.
   inline void setNull(GC &gc);
@@ -86,7 +103,8 @@ class GCPointer : public GCPointerBase {
     return vmcast<T>(GCPointerBase::getNonNull(base));
   }
 
-  /// Assign a new value to this GCPointer.
+  /// Assign a new value to this GCPointer. This must not be used if it lives in
+  /// an object that supports large allocation.
   /// \param base The base of ptr.
   /// \param ptr The memory being pointed to.
   /// \param gc Used for write barriers.
@@ -97,10 +115,33 @@ class GCPointer : public GCPointerBase {
     GCPointerBase::setNonNull(base, ptr, gc);
   }
 
-  /// Convenience overload of GCPointer::set for other GCPointers.
+  /// Assign a new value to this GCPointer.
+  /// \param ptr The memory being pointed to.
+  /// \param gc Used for write barriers.
+  /// \param owningObj The object that contains this GCPointer, used by the
+  /// writer barriers.
+  void set(PointerBase &base, T *ptr, GC &gc, const GCCell *owningObj) {
+    GCPointerBase::set(base, ptr, gc, owningObj);
+  }
+  void setNonNull(PointerBase &base, T *ptr, GC &gc, const GCCell *owningObj) {
+    GCPointerBase::setNonNull(base, ptr, gc, owningObj);
+  }
+
+  /// Convenience overload of GCPointer::set for other GCPointers. This must not
+  /// be used if it lives in an object that supports large allocation.
   void set(PointerBase &base, const GCPointer<T> &ptr, GC &gc) {
     GCPointerBase::set(base, ptr, gc);
   }
+
+  /// Convenience overload of GCPointer::set for other GCPointers. \p owningObj
+  /// is used by the writer barriers.
+  void set(
+      PointerBase &base,
+      const GCPointer<T> &ptr,
+      GC &gc,
+      const GCCell *owningObj) {
+    GCPointerBase::set(base, ptr, gc, owningObj);
+  }
 };
 
 } // namespace vm