deps: V8: cherry-pick 6 commits

Cherry-pick ad49f12.
Original commit message:

    [cleanup] Move Compressed[XXX]Slot definitions to separate header

    ... and fix header includes to please the respective bot.

    Drive-by-fix: decompression implementation is now MSVC friendly.

    Bug: v8:7703, v8:8834
    Change-Id: Iaf589138e5bafb32b0d9feab5cf074b71f241a3c
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1505579
    Commit-Queue: Igor Sheludko <ishell@chromium.org>
    Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60074}

Refs: https://github.com/v8/v8/commit/ad49f12908644fa1dc7e5aa28839a85872084f8c

Cherry-pick 14f07a8.
Original commit message:

    [ptr-compr] Define kTaggedPayloadOffset correctly on Big Endian

    smi size is sill 8 bytes when V8_COMPRESS_POINTERS is undefined.

    Bug: v8:7703
    Change-Id: I0d1e757e42e8b1e6b10960420135245e24553175
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1508572
    Commit-Queue: Junliang Yan <jyan@ca.ibm.com>
    Auto-Submit: Junliang Yan <jyan@ca.ibm.com>
    Reviewed-by: Igor Sheludko <ishell@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60097}

Refs: https://github.com/v8/v8/commit/14f07a8b30dd28bd6508924fae01e0c2d1892aad

Cherry-pick 676014b.
Original commit message:

    [ptr-compr] Fix MSVC build

    ... which complained about truncating uintptr_t constant to uint32_t.

    Bug: v8:7703
    Change-Id: I6fae2bf1e5de79e6131479b84a8d8aa5b9de909f
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1508672
    Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
    Commit-Queue: Igor Sheludko <ishell@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60100}

Refs: https://github.com/v8/v8/commit/676014b36ffb28f9d25e5d232547deb5735baa44

Cherry-pick 4e6a1a7.
Original commit message:

    [heap] Clean-up some weak map entries in scavenger

    This change enables clean-up of weak map entries in the
    scavenger of the weak map is in the young generation.
    With this change, the scavenger treats keys in ephemerons as
    weak instead of strong, but does not implement full ephemeron
    semantics: Values are treated always as strong, independently
    of whether the key is live or not.

    This approach ensures that no value is cleaned up accidentally.
    After scavenging, all entries with dead keys are removed from
    weak maps. After that, some values that are not referenced anywhere
    anymore might still be in the heap, and those can be cleaned up
    in the next scavenge.

    What the scavenger does, amounts to one iteration of the
    fixed-point algorithm required to implement ephemeron semantics.
    We hope that this is a reasonable trade-off between time spent
    tracing and cleaned-up entries.

    This change does not affect weak maps that reside in old space.

    Bug: v8:8557
    Change-Id: Ic5618b3b863ad8c314c87449571150e756fecbf0
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1467182
    Commit-Queue: Sigurd Schneider <sigurds@chromium.org>
    Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60101}

Refs: https://github.com/v8/v8/commit/4e6a1a75cd75916b45956071e581df6121bceaa8

Cherry-pick afbfd75.
Original commit message:

    [ptr-compr] Fix ptr-compr broken by 4e6a1a75

    (https://chromium-review.googlesource.com/c/v8/v8/+/1467182)

    Bug: v8:7703
    Change-Id: Ia6b74b985735af67bde56b30e4a709247eb591be
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1508674
    Commit-Queue: Igor Sheludko <ishell@chromium.org>
    Commit-Queue: Ulan Degenbaev <ulan@chromium.org>
    Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60102}

Refs: https://github.com/v8/v8/commit/afbfd7563d88b90b095b454344f91de6138cbbf3

Cherry-pick f792eb8.
Original commit message:

    [ptr-compr][arm64] Update pointer compression arm64's implementation

    Since kTaggedSize got shrinked and we are actually compressing
    the pointers (as oppposed to zeroing their upper bits),
    we need to update the arm64 codebase to accommodate this change.

    Cq-Include-Trybots: luci.v8.try:v8_linux64_arm64_pointer_compression_rel_ng
    Bug: v8:7703
    Change-Id: I890f3ab8c046f47232e80f85830f9ae8f4dbced4
    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1499498
    Commit-Queue: Santiago Aboy Solanes <solanes@chromium.org>
    Reviewed-by: Igor Sheludko <ishell@chromium.org>
    Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
    Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#60172}

Refs: https://github.com/v8/v8/commit/f792eb83a6501d44d4ef51b11894ce2ba9dc8f91

PR-URL: https://github.com/nodejs/node/pull/26685
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>

8 files changed, 101 insertions, 31 deletions

diff --git a/deps/v8/src/heap/heap-write-barrier-inl.h b/deps/v8/src/heap/heap-write-barrier-inl.h
index 63d16ca82d..9b2d3a8fa3 100644
--- a/deps/v8/src/heap/heap-write-barrier-inl.h
+++ b/deps/v8/src/heap/heap-write-barrier-inl.h
@@ -15,6 +15,7 @@
 // elsewhere.
 #include "src/isolate.h"
 #include "src/objects/code.h"
+#include "src/objects/compressed-slots-inl.h"
 #include "src/objects/fixed-array.h"
 #include "src/objects/heap-object.h"
 #include "src/objects/maybe-object-inl.h"
diff --git a/deps/v8/src/heap/heap.h b/deps/v8/src/heap/heap.h
index 7f687e8fdf..29aa5fa9fb 100644
--- a/deps/v8/src/heap/heap.h
+++ b/deps/v8/src/heap/heap.h
@@ -2347,6 +2347,20 @@ class HeapObjectAllocationTracker {
   virtual ~HeapObjectAllocationTracker() = default;
 };
 
+template <typename T>
+T ForwardingAddress(T heap_obj) {
+  MapWord map_word = heap_obj->map_word();
+
+  if (map_word.IsForwardingAddress()) {
+    return T::cast(map_word.ToForwardingAddress());
+  } else if (Heap::InFromPage(heap_obj)) {
+    return T();
+  } else {
+    // TODO(ulan): Support minor mark-compactor here.
+    return heap_obj;
+  }
+}
+
 }  // namespace internal
 }  // namespace v8
 
diff --git a/deps/v8/src/heap/incremental-marking.cc b/deps/v8/src/heap/incremental-marking.cc
index 2a665394d3..3332eff38d 100644
--- a/deps/v8/src/heap/incremental-marking.cc
+++ b/deps/v8/src/heap/incremental-marking.cc
@@ -609,22 +609,6 @@ void IncrementalMarking::UpdateMarkingWorklistAfterScavenge() {
   UpdateWeakReferencesAfterScavenge();
 }
 
-namespace {
-template <typename T>
-T ForwardingAddress(T heap_obj) {
-  MapWord map_word = heap_obj->map_word();
-
-  if (map_word.IsForwardingAddress()) {
-    return T::cast(map_word.ToForwardingAddress());
-  } else if (Heap::InFromPage(heap_obj)) {
-    return T();
-  } else {
-    // TODO(ulan): Support minor mark-compactor here.
-    return heap_obj;
-  }
-}
-}  // namespace
-
 void IncrementalMarking::UpdateWeakReferencesAfterScavenge() {
   weak_objects_->weak_references.Update(
       [](std::pair<HeapObject, HeapObjectSlot> slot_in,
diff --git a/deps/v8/src/heap/scavenger-inl.h b/deps/v8/src/heap/scavenger-inl.h
index 1ac96b7362..4736519099 100644
--- a/deps/v8/src/heap/scavenger-inl.h
+++ b/deps/v8/src/heap/scavenger-inl.h
@@ -480,6 +480,21 @@ void ScavengeVisitor::VisitPointersImpl(HeapObject host, TSlot start,
   }
 }
 
+int ScavengeVisitor::VisitEphemeronHashTable(Map map,
+                                             EphemeronHashTable table) {
+  // Register table with the scavenger, so it can take care of the weak keys
+  // later. This allows to only iterate the tables' values, which are treated
+  // as strong independetly of whether the key is live.
+  scavenger_->AddEphemeronHashTable(table);
+  for (int i = 0; i < table->Capacity(); i++) {
+    ObjectSlot value_slot =
+        table->RawFieldOfElementAt(EphemeronHashTable::EntryToValueIndex(i));
+    VisitPointer(table, value_slot);
+  }
+
+  return table->SizeFromMap(map);
+}
+
 }  // namespace internal
 }  // namespace v8
 
diff --git a/deps/v8/src/heap/scavenger.cc b/deps/v8/src/heap/scavenger.cc
index df0ed8886e..b6403d472f 100644
--- a/deps/v8/src/heap/scavenger.cc
+++ b/deps/v8/src/heap/scavenger.cc
@@ -151,11 +151,25 @@ class IterateAndScavengePromotedObjectsVisitor final : public ObjectVisitor {
   const bool record_slots_;
 };
 
-static bool IsUnscavengedHeapObject(Heap* heap, FullObjectSlot p) {
-  return Heap::InFromPage(*p) &&
-         !HeapObject::cast(*p)->map_word().IsForwardingAddress();
+namespace {
+
+V8_INLINE bool IsUnscavengedHeapObject(Heap* heap, Object object) {
+  return Heap::InFromPage(object) &&
+         !HeapObject::cast(object)->map_word().IsForwardingAddress();
+}
+
+// Same as IsUnscavengedHeapObject() above but specialized for HeapObjects.
+V8_INLINE bool IsUnscavengedHeapObject(Heap* heap, HeapObject heap_object) {
+  return Heap::InFromPage(heap_object) &&
+         !heap_object->map_word().IsForwardingAddress();
+}
+
+bool IsUnscavengedHeapObjectSlot(Heap* heap, FullObjectSlot p) {
+  return IsUnscavengedHeapObject(heap, *p);
 }
 
+}  // namespace
+
 class ScavengeWeakObjectRetainer : public WeakObjectRetainer {
  public:
   Object RetainAs(Object object) override {
@@ -185,9 +199,10 @@ void ScavengerCollector::CollectGarbage() {
   OneshotBarrier barrier(base::TimeDelta::FromMilliseconds(kMaxWaitTimeMs));
   Scavenger::CopiedList copied_list(num_scavenge_tasks);
   Scavenger::PromotionList promotion_list(num_scavenge_tasks);
+  EphemeronTableList ephemeron_table_list(num_scavenge_tasks);
   for (int i = 0; i < num_scavenge_tasks; i++) {
     scavengers[i] = new Scavenger(this, heap_, is_logging, &copied_list,
-                                  &promotion_list, i);
+                                  &promotion_list, &ephemeron_table_list, i);
     job.AddTask(new ScavengingTask(heap_, scavengers[i], &barrier));
   }
 
@@ -235,7 +250,7 @@ void ScavengerCollector::CollectGarbage() {
       TRACE_GC(heap_->tracer(),
                GCTracer::Scope::SCAVENGER_SCAVENGE_WEAK_GLOBAL_HANDLES_PROCESS);
       isolate_->global_handles()->MarkYoungWeakUnmodifiedObjectsPending(
-          &IsUnscavengedHeapObject);
+          &IsUnscavengedHeapObjectSlot);
       isolate_->global_handles()->IterateYoungWeakUnmodifiedRootsForFinalizers(
           &root_scavenge_visitor);
       scavengers[kMainThreadId]->Process();
@@ -244,7 +259,7 @@ void ScavengerCollector::CollectGarbage() {
       DCHECK(promotion_list.IsEmpty());
       isolate_->global_handles()
           ->IterateYoungWeakUnmodifiedRootsForPhantomHandles(
-              &root_scavenge_visitor, &IsUnscavengedHeapObject);
+              &root_scavenge_visitor, &IsUnscavengedHeapObjectSlot);
     }
 
     {
@@ -280,8 +295,7 @@ void ScavengerCollector::CollectGarbage() {
     }
   }
 
-  ScavengeWeakObjectRetainer weak_object_retainer;
-  heap_->ProcessYoungWeakReferences(&weak_object_retainer);
+  ProcessWeakReferences(&ephemeron_table_list);
 
   // Set age mark.
   heap_->new_space_->set_age_mark(heap_->new_space()->top());
@@ -349,11 +363,12 @@ int ScavengerCollector::NumberOfScavengeTasks() {
 
 Scavenger::Scavenger(ScavengerCollector* collector, Heap* heap, bool is_logging,
                      CopiedList* copied_list, PromotionList* promotion_list,
-                     int task_id)
+                     EphemeronTableList* ephemeron_table_list, int task_id)
     : collector_(collector),
       heap_(heap),
       promotion_list_(promotion_list, task_id),
       copied_list_(copied_list, task_id),
+      ephemeron_table_list_(ephemeron_table_list, task_id),
       local_pretenuring_feedback_(kInitialLocalPretenuringFeedbackCapacity),
       copied_size_(0),
       promoted_size_(0),
@@ -440,12 +455,45 @@ void Scavenger::Process(OneshotBarrier* barrier) {
   } while (!done);
 }
 
+void ScavengerCollector::ProcessWeakReferences(
+    EphemeronTableList* ephemeron_table_list) {
+  ScavengeWeakObjectRetainer weak_object_retainer;
+  heap_->ProcessYoungWeakReferences(&weak_object_retainer);
+  ClearYoungEphemerons(ephemeron_table_list);
+}
+
+// Clears ephemerons contained in {EphemeronHashTable}s in young generation.
+void ScavengerCollector::ClearYoungEphemerons(
+    EphemeronTableList* ephemeron_table_list) {
+  ephemeron_table_list->Iterate([this](EphemeronHashTable table) {
+    for (int i = 0; i < table->Capacity(); i++) {
+      ObjectSlot key_slot =
+          table->RawFieldOfElementAt(EphemeronHashTable::EntryToIndex(i));
+      Object key = *key_slot;
+      if (key->IsHeapObject()) {
+        if (IsUnscavengedHeapObject(heap_, HeapObject::cast(key))) {
+          table->RemoveEntry(i);
+        } else {
+          HeapObject forwarded = ForwardingAddress(HeapObject::cast(key));
+          HeapObjectReference::Update(HeapObjectSlot(key_slot), forwarded);
+        }
+      }
+    }
+  });
+  ephemeron_table_list->Clear();
+}
+
 void Scavenger::Finalize() {
   heap()->MergeAllocationSitePretenuringFeedback(local_pretenuring_feedback_);
   heap()->IncrementSemiSpaceCopiedObjectSize(copied_size_);
   heap()->IncrementPromotedObjectsSize(promoted_size_);
   collector_->MergeSurvivingNewLargeObjects(surviving_new_large_objects_);
   allocator_.Finalize();
+  ephemeron_table_list_.FlushToGlobal();
+}
+
+void Scavenger::AddEphemeronHashTable(EphemeronHashTable table) {
+  ephemeron_table_list_.Push(table);
 }
 
 void RootScavengeVisitor::VisitRootPointer(Root root, const char* description,
diff --git a/deps/v8/src/heap/scavenger.h b/deps/v8/src/heap/scavenger.h
index e122ab8cdf..b33713ec3f 100644
--- a/deps/v8/src/heap/scavenger.h
+++ b/deps/v8/src/heap/scavenger.h
@@ -27,6 +27,10 @@ using SurvivingNewLargeObjectsMap =
     std::unordered_map<HeapObject, Map, Object::Hasher>;
 using SurvivingNewLargeObjectMapEntry = std::pair<HeapObject, Map>;
 
+constexpr int kEphemeronTableListSegmentSize = 128;
+using EphemeronTableList =
+    Worklist<EphemeronHashTable, kEphemeronTableListSegmentSize>;
+
 class ScavengerCollector {
  public:
   static const int kMaxScavengerTasks = 8;
@@ -42,6 +46,8 @@ class ScavengerCollector {
 
   int NumberOfScavengeTasks();
 
+  void ProcessWeakReferences(EphemeronTableList* ephemeron_table_list);
+  void ClearYoungEphemerons(EphemeronTableList* ephemeron_table_list);
   void HandleSurvivingNewLargeObjects();
 
   Isolate* const isolate_;
@@ -109,10 +115,9 @@ class Scavenger {
   static const int kCopiedListSegmentSize = 256;
 
   using CopiedList = Worklist<ObjectAndSize, kCopiedListSegmentSize>;
-
   Scavenger(ScavengerCollector* collector, Heap* heap, bool is_logging,
             CopiedList* copied_list, PromotionList* promotion_list,
-            int task_id);
+            EphemeronTableList* ephemeron_table_list, int task_id);
 
   // Entry point for scavenging an old generation page. For scavenging single
   // objects see RootScavengingVisitor and ScavengeVisitor below.
@@ -125,6 +130,8 @@ class Scavenger {
   // Finalize the Scavenger. Needs to be called from the main thread.
   void Finalize();
 
+  void AddEphemeronHashTable(EphemeronHashTable table);
+
   size_t bytes_copied() const { return copied_size_; }
   size_t bytes_promoted() const { return promoted_size_; }
 
@@ -199,6 +206,7 @@ class Scavenger {
   Heap* const heap_;
   PromotionList::View promotion_list_;
   CopiedList::View copied_list_;
+  EphemeronTableList::View ephemeron_table_list_;
   Heap::PretenuringFeedbackMap local_pretenuring_feedback_;
   size_t copied_size_;
   size_t promoted_size_;
@@ -242,6 +250,7 @@ class ScavengeVisitor final : public NewSpaceVisitor<ScavengeVisitor> {
 
   V8_INLINE void VisitCodeTarget(Code host, RelocInfo* rinfo) final;
   V8_INLINE void VisitEmbeddedPointer(Code host, RelocInfo* rinfo) final;
+  V8_INLINE int VisitEphemeronHashTable(Map map, EphemeronHashTable object);
 
  private:
   template <typename TSlot>
diff --git a/deps/v8/src/heap/slot-set.h b/deps/v8/src/heap/slot-set.h
index 2d9fb327be..7870e57b56 100644
--- a/deps/v8/src/heap/slot-set.h
+++ b/deps/v8/src/heap/slot-set.h
@@ -11,13 +11,10 @@
 #include "src/allocation.h"
 #include "src/base/atomic-utils.h"
 #include "src/base/bits.h"
+#include "src/objects/compressed-slots.h"
 #include "src/objects/slots.h"
 #include "src/utils.h"
 
-#ifdef V8_COMPRESS_POINTERS
-#include "src/ptr-compr.h"
-#endif
-
 namespace v8 {
 namespace internal {
 
diff --git a/deps/v8/src/heap/worklist.h b/deps/v8/src/heap/worklist.h
index c086b87e59..82a278a042 100644
--- a/deps/v8/src/heap/worklist.h
+++ b/deps/v8/src/heap/worklist.h
@@ -51,6 +51,8 @@ class Worklist {
       return worklist_->LocalPushSegmentSize(task_id_);
     }
 
+    void FlushToGlobal() { worklist_->FlushToGlobal(task_id_); }
+
    private:
     Worklist<EntryType, SEGMENT_SIZE>* worklist_;
     int task_id_;