deps: patch V8 to 15.6.75.33

Refs: v8/v8@15.6.75.25...15.6.75.33
PR-URL: #67174
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>

Author: nodejs-github-bot

deps/v8/include/cppgc/heap-consistency.h

@@ -146,8 +146,8 @@ class HeapConsistency final {
   }
 
   /**
-   * Steele-style write barrier that re-processes an object if it has already
-   * been processed.
+   * Steele-style write barrier that processes an object regardless of whether
+   * or not it has already been processed.
    *
    * \param params The parameters retrieved from `GetWriteBarrierType()`.
    * \param object The pointer to the object which must point to an object that

deps/v8/include/v8-version.h

@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 15
 #define V8_MINOR_VERSION 6
 #define V8_BUILD_NUMBER 75
-#define V8_PATCH_LEVEL 25
+#define V8_PATCH_LEVEL 33
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

deps/v8/src/builtins/promise-any.tq

@@ -26,9 +26,7 @@ extern operator '[]' macro LoadContextElementNoCell(
 // together with the errors array. Since all closures for a single Promise.any
 // call use the same context, we need to store the indices for the individual
 // closures somewhere else (we put them into the identity hash field of the
-// closures), and we also need to have a separate marker for when the closure
-// was called already (we slap the native context onto the closure in that
-// case to mark it's done). See Promise.all which uses the same approach.
+// closures).
 transitioning macro CreatePromiseAnyRejectElementContext(
     implicit context: Context)(capability: PromiseCapability,
     nativeContext: NativeContext): PromiseAnyRejectElementContext {
@@ -75,36 +73,30 @@ transitioning javascript builtin PromiseAnyRejectElementClosure(
     js-implicit context: Context, receiver: JSAny, target: JSFunction)(
     value: JSAny): JSAny {
   // 1. Let F be the active function object.
-
-  // 2. Let alreadyCalled be F.[[AlreadyCalled]].
-
-  // 3. If alreadyCalled.[[Value]] is true, return undefined.
-
-  // We use the function's context as the marker to remember whether this
-  // reject element closure was already called. It points to the reject
-  // element context (which is a FunctionContext) until it was called the
-  // first time, in which case we make it point to the native context here
-  // to mark this reject element closure as done.
-  if (IsNativeContext(context)) deferred {
-      return Undefined;
-    }
-
   dcheck(
       context.length ==
       SmiTag(
           PromiseAnyRejectElementContextSlots::kPromiseAnyRejectElementLength));
   const context = %RawDownCast<PromiseAnyRejectElementContext>(context);
 
-  // 4. Set alreadyCalled.[[Value]] to true.
-  const nativeContext = LoadNativeContext(context);
-  target.context = nativeContext;
-
   // 5. Let index be F.[[Index]].
   dcheck(kPropertyArrayNoHashSentinel == 0);
   const identityHash = LoadJSReceiverIdentityHash(target) otherwise unreachable;
   dcheck(ChangeUint32ToWord(identityHash) < kSmiMaxValue);
   const index = Signed(ChangeUint32ToWord(identityHash)) - 1;
 
+  // 8. Let remainingElementsCount be F.[[RemainingElements]].
+  let remainingElementsCount = *ContextSlot(
+      context,
+      PromiseAnyRejectElementContextSlots::
+          kPromiseAnyRejectElementRemainingSlot);
+
+  // If all promises were already rejected, the remaining count will already be
+  // 0.
+  if (remainingElementsCount == 0) deferred {
+      return Undefined;
+    }
+
   // 6. Let errors be F.[[Errors]].
   let errorsRef:&FixedArray = ContextSlot(
       context,
@@ -113,12 +105,6 @@ transitioning javascript builtin PromiseAnyRejectElementClosure(
 
   // 7. Let promiseCapability be F.[[Capability]].
 
-  // 8. Let remainingElementsCount be F.[[RemainingElements]].
-  let remainingElementsCount = *ContextSlot(
-      context,
-      PromiseAnyRejectElementContextSlots::
-          kPromiseAnyRejectElementRemainingSlot);
-
   // 9. Set errors[index] to x.
 
   // The max computation below is an optimization to avoid excessive allocations
@@ -138,11 +124,22 @@ transitioning javascript builtin PromiseAnyRejectElementClosure(
           errors, 0, errors.length_intptr, newCapacity, PromiseHole);
       *errorsRef = errors;
     }
+
+  // 2. Let alreadyCalled be F.[[AlreadyCalled]].
+  // 3. If alreadyCalled.[[Value]] is true, return undefined.
+  // 4. Set alreadyCalled.[[Value]] to true.
+  if (errors.objects[index] != PromiseHole) deferred {
+      return Undefined;
+    }
+
+  // Make sure that we never see the PromiseHole here as a result.
+  check(value != PromiseHole);
   errors.objects[index] = value;
 
   // 10. Set remainingElementsCount.[[Value]] to
   // remainingElementsCount.[[Value]] - 1.
   remainingElementsCount = remainingElementsCount - 1;
+  check(remainingElementsCount >= 0);
   *ContextSlot(
       context,
       PromiseAnyRejectElementContextSlots::

deps/v8/src/compiler/js-generic-lowering.cc

@@ -759,9 +759,6 @@ void JSGenericLowering::LowerJSGetTemplateObject(Node* node) {
   SharedFunctionInfoRef shared = p.shared();
   TemplateObjectDescriptionRef description = p.description();
 
-  DCHECK_EQ(node->op()->ControlInputCount(), 1);
-  node->RemoveInput(NodeProperties::FirstControlIndex(node));
-
   static_assert(JSGetTemplateObjectNode::FeedbackVectorIndex() == 0);
   node->InsertInput(zone(), 0, jsgraph()->ConstantNoHole(shared, broker()));
   node->InsertInput(zone(), 1,

deps/v8/src/compiler/js-operator.cc

@@ -1614,7 +1614,7 @@ const Operator* JSOperatorBuilder::GetTemplateObject(
   GetTemplateObjectParameters parameters(description, shared, feedback);
   return zone()->New<Operator1<GetTemplateObjectParameters>>(  // --
       IrOpcode::kJSGetTemplateObject,                          // opcode
-      Operator::kEliminatable,                                 // properties
+      Operator::kNoDeopt | Operator::kNoThrow,                 // properties
       "JSGetTemplateObject",                                   // name
       1, 1, 1, 1, 1, 0,                                        // counts
       parameters);                                             // parameter

deps/v8/src/compiler/turboshaft/pipelines.cc

@@ -85,6 +85,21 @@ bool Pipeline::AllocateRegisters(const RegisterConfiguration* config,
 
   RUN_MAYBE_ABORT(DecideSpillingModePhase);
   RUN_MAYBE_ABORT(AssignSpillSlotsPhase);
+
+  // The prologue grows the frame with a single stack pointer decrement, before
+  // the function entry stack check runs. A frame no larger than the smallest OS
+  // page cannot step over a guard page, so bail out rather than emit an
+  // unchecked stack pointer jump of arbitrary size.
+  // When replacing this bailout with a different strategy, consider doing the
+  // same in Maglev as well.
+  constexpr int kMaxStackSlots = 4 * KB / kSystemPointerSize;
+  if (data_->info()->IsOptimizing() &&
+      data_->frame()->GetTotalFrameSlotCount() > kMaxStackSlots) {
+    data_->info()->AbortOptimization(BailoutReason::kFunctionTooBig);
+    data()->ClearRegisterComponent();
+    return false;
+  }
+
   RUN_MAYBE_ABORT(CommitAssignmentPhase);
 
   // TODO(chromium:725559): remove this check once

deps/v8/src/heap/cppgc-internal/marker.h

@@ -10,6 +10,7 @@
 #include "include/cppgc/heap.h"
 #include "include/cppgc/platform.h"
 #include "include/cppgc/visitor.h"
+#include "src/base/logging.h"
 #include "src/base/macros.h"
 #include "src/base/platform/time.h"
 #include "src/heap/base/incremental-marking-schedule.h"
@@ -238,20 +239,15 @@ class V8_EXPORT_PRIVATE Marker final : public MarkerBase {
 
 template <MarkerBase::WriteBarrierType type>
 void MarkerBase::WriteBarrierForObject(HeapObjectHeader& header) {
-  // The barrier optimizes for the bailout cases:
-  // - kDijkstra: Marked objects.
-  // - kSteele: Unmarked objects.
-  switch (type) {
-    case MarkerBase::WriteBarrierType::kDijkstra:
-      if (!header.TryMarkAtomic()) {
-        return;
-      }
-      break;
-    case MarkerBase::WriteBarrierType::kSteele:
-      if (!header.IsMarked<AccessMode::kAtomic>()) {
-        return;
-      }
-      break;
+  // The Dijkstra barrier bails out on marked objects.
+  // The Steele barrier marks the object regardless of its current state.
+  // It's important to make sure the object is marked here since unmarking
+  // below for in construction objects expects a marked object.
+  const bool was_already_marked = !header.TryMarkAtomic();
+  if (type == MarkerBase::WriteBarrierType::kDijkstra) {
+    if (was_already_marked) {
+      return;
+    }
   }
 
   // The barrier fired. Filter out in-construction objects here. This possibly
@@ -267,13 +263,18 @@ void MarkerBase::WriteBarrierForObject(HeapObjectHeader& header) {
     return;
   }
 
-  switch (type) {
-    case MarkerBase::WriteBarrierType::kDijkstra:
-      mutator_marking_state_.write_barrier_worklist().Push(&header);
-      break;
-    case MarkerBase::WriteBarrierType::kSteele:
-      mutator_marking_state_.retrace_marked_objects_worklist().Push(&header);
-      break;
+  DCHECK_IMPLIES(was_already_marked,
+                 type == MarkerBase::WriteBarrierType::kSteele);
+  if ((type == MarkerBase::WriteBarrierType::kDijkstra) ||
+      !was_already_marked) {
+    // Push previously unmarked objects to the write barrier worklist, even for
+    // the Steele barrier, since popping from that worklist would also update
+    // the marked bytes counter.
+    mutator_marking_state_.write_barrier_worklist().Push(&header);
+  } else {
+    DCHECK((type == MarkerBase::WriteBarrierType::kSteele) &&
+           was_already_marked);
+    mutator_marking_state_.retrace_marked_objects_worklist().Push(&header);
   }
 }
 

deps/v8/src/maglev/maglev-compiler.cc

@@ -285,6 +285,8 @@ bool MaglevCompiler::Compile(LocalIsolate* local_isolate,
   // FunctionEntryStackCheck runs. A frame no larger than the smallest OS page
   // cannot step over a guard page, so bail out rather than emit an unchecked
   // stack pointer jump of arbitrary size.
+  // When replacing this bailout with a different strategy, consider doing the
+  // same in Turboshaft as well.
   if (graph->tagged_stack_slots() + graph->untagged_stack_slots() >
       kMaxStackSlots) {
     return false;

deps/v8/src/maglev/maglev-graph-builder.cc

@@ -6368,6 +6368,7 @@ void MaglevGraphBuilder::AdvanceThroughContinuationForPolymorphicPropertyLoad(
   while (iterator_.current_offset() < continuation.last_continuation) {
     iterator_.Advance();
     UpdateSourceAndBytecodePosition(iterator_.current_offset());
+    PrewalkBytecode();
   }
 }
 

deps/v8/src/objects/js-function.cc

@@ -991,8 +991,9 @@ void JSFunction::EnsureHasInitialMap(Isolate* isolate,
   // system.
   // TODO(leszeks): Figure out if this CHECK is needed.
   CHECK(IsJSReceiver(*prototype));
-  JSFunction::SetInitialMap(isolate, function, map, prototype);
+  // Initialize slack tracking before publishing the map to concurrent readers.
   map->StartInobjectSlackTracking();
+  JSFunction::SetInitialMap(isolate, function, map, prototype);
 }
 
 namespace {
@@ -1183,11 +1184,12 @@ bool FastInitializeDerivedMap(Isolate* isolate,
       Map::CopyInitialMap(isolate, constructor_initial_map, instance_size,
                           in_object_properties, unused_property_fields);
   map->set_new_target_is_base(false);
+  // Initialize slack tracking before publishing the map to concurrent readers.
+  map->set_construction_counter(Map::kNoSlackTracking);
+  map->StartInobjectSlackTracking();
   DirectHandle<JSReceiver> prototype(new_target->instance_prototype(), isolate);
   JSFunction::SetInitialMap(isolate, new_target, map, prototype, constructor);
   DCHECK(IsJSReceiver(new_target->instance_prototype()));
-  map->set_construction_counter(Map::kNoSlackTracking);
-  map->StartInobjectSlackTracking();
   return true;
 }