Merge branch 'nodejs:main' into main

Author: aka76bm

.github/workflows/post-release.yml

@@ -0,0 +1,32 @@
+name: Post-Release actions
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: The version to generate a blog post for.
+        type: string
+        required: true
+  release:
+    types: [released]
+
+permissions:
+  contents: read
+
+jobs:
+  post-release-actions:
+    if: github.repository == 'nodejs/node'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Trigger update-links workflow on nodejs/release-cloudflare-worker
+        run: |
+          gh workflow run update-links.yml --repo nodejs/release-cloudflare-worker
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }}
+
+      - name: Trigger create-release-post workflow on nodejs/nodejs.org
+        run: |
+          gh workflow run create-release-post.yml --repo nodejs/nodejs.org -f version=$VERSION
+        env:
+          GITHUB_TOKEN: ${{ secrets.GH_USER_TOKEN }}
+          VERSION: ${{ inputs.version || github.event.release.tag_name }}

.github/workflows/update-release-links.yml

@@ -3,9 +3,9 @@
 Select a Node.js version below to view the changelog history:
 
 * [Node.js 25](doc/changelogs/CHANGELOG_V25.md) **Current**
-* [Node.js 24](doc/changelogs/CHANGELOG_V24.md) **Current**
+* [Node.js 24](doc/changelogs/CHANGELOG_V24.md) **Long Term Support**
 * [Node.js 23](doc/changelogs/CHANGELOG_V23.md) End-of-Life
-* [Node.js 22](doc/changelogs/CHANGELOG_V22.md) **Long Term Support**
+* [Node.js 22](doc/changelogs/CHANGELOG_V22.md) Long Term Support
 * [Node.js 21](doc/changelogs/CHANGELOG_V21.md) End-of-Life
 * [Node.js 20](doc/changelogs/CHANGELOG_V20.md) Long Term Support
 * [Node.js 19](doc/changelogs/CHANGELOG_V19.md) End-of-Life
@@ -35,16 +35,18 @@ release.
 <table>
 <tr>
   <th title="Current"><a href="doc/changelogs/CHANGELOG_V25.md">25</a> (Current)</th>
-  <th title="Current"><a href="doc/changelogs/CHANGELOG_V24.md">24</a> (Current)</th>
+  <th title="LTS Until 2028-04"><a href="doc/changelogs/CHANGELOG_V24.md">24</a> (LTS)</th>
   <th title="LTS Until 2027-04"><a href="doc/changelogs/CHANGELOG_V22.md">22</a> (LTS)</th>
   <th title="LTS Until 2026-04"><a href="doc/changelogs/CHANGELOG_V20.md">20</a> (LTS)</th>
 </tr>
 <tr>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V25.md#25.0.0">25.0.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V25.md#25.1.0">25.1.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V25.md#25.0.0">25.0.0</a><br/>
   </td>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V24.md#24.10.0">24.10.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V24.md#24.11.0">24.11.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V24.md#24.10.0">24.10.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.9.0">24.9.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.8.0">24.8.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V24.md#24.7.0">24.7.0</a><br/>
@@ -60,7 +62,8 @@ release.
 <a href="doc/changelogs/CHANGELOG_V24.md#24.0.0">24.0.0</a><br/>
   </td>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V22.md#22.21.0">22.21.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V22.md#22.21.1">22.21.1</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V22.md#22.21.0">22.21.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V22.md#22.20.0">22.20.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V22.md#22.19.0">22.19.0</a><br/>
 <a href="doc/changelogs/CHANGELOG_V22.md#22.18.0">22.18.0</a><br/>

CHANGELOG.md

@@ -0,0 +1,33 @@
+'use strict';
+
+const common = require('../common');
+const { Readable, Writable } = require('stream');
+const { finished } = require('stream/promises');
+
+const bench = common.createBenchmark(main, {
+  n: [1e7],
+  streamType: ['readable', 'writable'],
+});
+
+async function main({ n, streamType }) {
+  bench.start();
+
+  for (let i = 0; i < n; i++) {
+    let stream;
+
+    switch (streamType) {
+      case 'readable':
+        stream = new Readable({ read() { this.push(null); } });
+        stream.resume();
+        break;
+      case 'writable':
+        stream = new Writable({ write(chunk, enc, cb) { cb(); } });
+        stream.end();
+        break;
+    }
+
+    await finished(stream);
+  }
+
+  bench.end(n);
+}

benchmark/streams/finished.js

@@ -11,7 +11,7 @@
 #define V8_MAJOR_VERSION 14
 #define V8_MINOR_VERSION 2
 #define V8_BUILD_NUMBER 231
-#define V8_PATCH_LEVEL 9
+#define V8_PATCH_LEVEL 14
 
 // Use 1 for candidates and 0 otherwise.
 // (Boolean macro values are not supported by all preprocessors.)

deps/v8/include/v8-version.h

@@ -3185,12 +3185,9 @@ void ReloadParentStack(MacroAssembler* masm, Register return_reg,
   Register parent = tmp2;
   __ Ld_d(parent, MemOperand(active_stack, wasm::kStackParentOffset));
 
-  // Update active stack.
-  __ StoreRootRelative(IsolateData::active_stack_offset(), parent);
-
   // Switch stack!
-  SwitchStacks(masm, ExternalReference::wasm_return_stack(), active_stack,
-               nullptr, no_reg, {return_reg, return_value, context, parent});
+  SwitchStacks(masm, ExternalReference::wasm_return_stack(), parent, nullptr,
+               no_reg, {return_reg, return_value, context, parent});
   LoadJumpBuffer(masm, parent, false, tmp3);
 }
 
@@ -3425,22 +3422,18 @@ void Builtins::Generate_WasmSuspend(MacroAssembler* masm) {
   ResetWasmJspiFrameStackSlots(masm);
 
   Label resume;
-  DEFINE_REG(stack);
-  __ LoadRootRelative(stack, IsolateData::active_stack_offset());
   DEFINE_REG(scratch);
 
-  // Update active stack.
   DEFINE_REG(parent);
   __ LoadProtectedPointerField(
       parent, FieldMemOperand(suspender, WasmSuspenderObject::kParentOffset));
   DEFINE_REG(target_stack);
   __ LoadExternalPointerField(
       target_stack, FieldMemOperand(parent, WasmSuspenderObject::kStackOffset),
       kWasmStackMemoryTag);
-  __ StoreRootRelative(IsolateData::active_stack_offset(), target_stack);
 
-  SwitchStacks(masm, ExternalReference::wasm_suspend_stack(), stack, &resume,
-               no_reg, {target_stack, suspender, parent});
+  SwitchStacks(masm, ExternalReference::wasm_suspend_stack(), target_stack,
+               &resume, no_reg, {target_stack, suspender, parent});
   __ StoreRootRelative(IsolateData::active_suspender_offset(), parent);
   __ LoadTaggedField(
       kReturnRegister0,
@@ -3512,11 +3505,8 @@ void Generate_WasmResumeHelper(MacroAssembler* masm, wasm::OnResume on_resume) {
       target_stack,
       FieldMemOperand(suspender, WasmSuspenderObject::kStackOffset),
       kWasmStackMemoryTag);
-
-  __ StoreRootRelative(IsolateData::active_stack_offset(), target_stack);
-  SwitchStacks(masm, ExternalReference::wasm_resume_jspi_stack(), active_stack,
+  SwitchStacks(masm, ExternalReference::wasm_resume_jspi_stack(), target_stack,
                &suspend, suspender, {target_stack});
-
   regs.ResetExcept(target_stack);
 
   // -------------------------------------------
@@ -3563,11 +3553,8 @@ void Builtins::Generate_WasmFXResume(MacroAssembler* masm) {
   __ EnterFrame(StackFrame::WASM_STACK_EXIT);
   Register target_stack = WasmFXResumeDescriptor::GetRegisterParameter(0);
   Label suspend;
-  Register active_stack = a0;
-  __ LoadRootRelative(active_stack, IsolateData::active_stack_offset());
-  __ StoreRootRelative(IsolateData::active_stack_offset(), target_stack);
   SwitchStacks(masm, ExternalReference::wasm_resume_wasmfx_stack(),
-               active_stack, &suspend, no_reg, {target_stack});
+               target_stack, &suspend, no_reg, {target_stack});
   LoadJumpBuffer(masm, target_stack, true, a1);
   __ Trap();
   __ bind(&suspend);
@@ -3580,9 +3567,8 @@ void Builtins::Generate_WasmFXReturn(MacroAssembler* masm) {
   __ LoadRootRelative(active_stack, IsolateData::active_stack_offset());
   Register parent = a1;
   __ Move(parent, MemOperand(active_stack, wasm::kStackParentOffset));
-  __ StoreRootRelative(IsolateData::active_stack_offset(), parent);
-  SwitchStacks(masm, ExternalReference::wasm_return_stack(), active_stack,
-               nullptr, no_reg, {parent});
+  SwitchStacks(masm, ExternalReference::wasm_return_stack(), parent, nullptr,
+               no_reg, {parent});
   LoadJumpBuffer(masm, parent, true, a2);
   __ Trap();
 }
@@ -3599,14 +3585,15 @@ void SwitchToAllocatedStack(MacroAssembler* masm, RegisterAllocator& regs,
                             Label* suspend) {
   ResetWasmJspiFrameStackSlots(masm);
   DEFINE_SCOPED(scratch)
-  DEFINE_REG(parent_stack)
-  __ LoadRootRelative(parent_stack, IsolateData::active_stack_offset());
-  __ Ld_d(parent_stack, MemOperand(parent_stack, wasm::kStackParentOffset));
-
-  SwitchStacks(masm, ExternalReference::wasm_start_stack(), parent_stack,
-               suspend, no_reg, {wasm_instance, wrapper_buffer});
+  DEFINE_REG(stack)
+  __ LoadRootRelative(stack, IsolateData::active_suspender_offset());
+  __ LoadExternalPointerField(
+      stack, FieldMemOperand(stack, WasmSuspenderObject::kStackOffset),
+      kWasmStackMemoryTag);
+  SwitchStacks(masm, ExternalReference::wasm_start_stack(), stack, suspend,
+               no_reg, {wasm_instance, wrapper_buffer});
 
-  FREE_REG(parent_stack);
+  FREE_REG(stack);
   // Save the old stack's fp in t0, and use it to access the parameters in
   // the parent frame.
   regs.Pinned(t1, &original_fp);

deps/v8/src/builtins/loong64/builtins-loong64.cc

@@ -142,6 +142,58 @@ void MacroAssembler::PushStandardFrame(Register function_reg) {
   Add_d(fp, sp, Operand(offset));
 }
 
+void MacroAssembler::PreCheckSkippedWriteBarrier(Register object,
+                                                 Register value,
+                                                 Register scratch, Label* ok) {
+  ASM_CODE_COMMENT(this);
+  DCHECK(!AreAliased(object, scratch));
+  DCHECK(!AreAliased(value, scratch));
+
+  // The most common case: Static write barrier elimination is allowed on the
+  // last young allocation.
+  {
+    UseScratchRegisterScope temps(this);
+    Register scratch1 = temps.Acquire();
+    Sub_d(scratch, object, kHeapObjectTag);
+    Ld_d(scratch1, MemOperand(kRootRegister,
+                              IsolateData::last_young_allocation_offset()));
+    Branch(ok, Condition::kEqual, scratch, Operand(scratch1));
+  }
+
+  // Write barier can also be removed if value is in read-only space.
+  CheckPageFlag(value, MemoryChunk::kIsInReadOnlyHeapMask, ne, ok);
+
+  Label not_ok;
+
+  // Handle allocation folding, allow WB removal if:
+  //   LAB start <= last_young_allocation_ < (object address+1) < LAB top
+  // Note that object has tag bit set, so object == object address+1.
+  {
+    UseScratchRegisterScope temps(this);
+    Register scratch1 = temps.Acquire();
+
+    // Check LAB start <= last_young_allocation_.
+    Ld_d(scratch, MemOperand(kRootRegister,
+                             IsolateData::new_allocation_info_start_offset()));
+    Ld_d(scratch1, MemOperand(kRootRegister,
+                              IsolateData::last_young_allocation_offset()));
+    Branch(&not_ok, Condition::kUnsignedGreaterThan, scratch,
+           Operand(scratch1));
+
+    // Check last_young_allocation_ < (object address+1).
+    Branch(&not_ok, Condition::kUnsignedGreaterThanEqual, scratch1,
+           Operand(object));
+
+    // Check (object address+1) < LAB top.
+    Ld_d(scratch, MemOperand(kRootRegister,
+                             IsolateData::new_allocation_info_top_offset()));
+    Branch(ok, Condition::kUnsignedLessThan, object, Operand(scratch));
+  }
+
+  // Slow path: Potentially check more cases in C++.
+  bind(&not_ok);
+}
+
 // Clobbers object, dst, value, and ra, if (ra_status == kRAHasBeenSaved)
 // The register 'object' contains a heap object pointer.  The heap object
 // tag is shifted away.
@@ -582,11 +634,33 @@ void MacroAssembler::CallVerifySkippedWriteBarrierStubSaveRegisters(
 void MacroAssembler::CallVerifySkippedWriteBarrierStub(Register object,
                                                        Register value) {
   ASM_CODE_COMMENT(this);
+  UseScratchRegisterScope temps(this);
+  Register scratch = temps.Acquire();
+  PrepareCallCFunction(2, scratch);
   MovePair(kCArgRegs[0], object, kCArgRegs[1], value);
   CallCFunction(ExternalReference::verify_skipped_write_barrier(), 2,
                 SetIsolateDataSlots::kNo);
 }
 
+void MacroAssembler::CallVerifySkippedIndirectWriteBarrierStubSaveRegisters(
+    Register object, Register value, SaveFPRegsMode fp_mode) {
+  ASM_CODE_COMMENT(this);
+  PushCallerSaved(fp_mode);
+  CallVerifySkippedIndirectWriteBarrierStub(object, value);
+  PopCallerSaved(fp_mode);
+}
+
+void MacroAssembler::CallVerifySkippedIndirectWriteBarrierStub(Register object,
+                                                               Register value) {
+  ASM_CODE_COMMENT(this);
+  UseScratchRegisterScope temps(this);
+  Register scratch = temps.Acquire();
+  PrepareCallCFunction(2, scratch);
+  MovePair(kCArgRegs[0], object, kCArgRegs[1], value);
+  CallCFunction(ExternalReference::verify_skipped_indirect_write_barrier(), 2,
+                SetIsolateDataSlots::kNo);
+}
+
 void MacroAssembler::MoveObjectAndSlot(Register dst_object, Register dst_slot,
                                        Register object, Operand offset) {
   ASM_CODE_COMMENT(this);

deps/v8/src/codegen/loong64/macro-assembler-loong64.cc

@@ -181,6 +181,9 @@ class V8_EXPORT_PRIVATE MacroAssembler : public MacroAssemblerBase {
   void LoadRootRelative(Register destination, int32_t offset) final;
   void StoreRootRelative(int32_t offset, Register value) final;
 
+  void PreCheckSkippedWriteBarrier(Register object, Register value,
+                                   Register scratch, Label* ok);
+
   // Operand pointing to an external reference.
   // May emit code to set up the scratch register. The operand is
   // only guaranteed to be correct as long as the scratch register
@@ -360,6 +363,11 @@ class V8_EXPORT_PRIVATE MacroAssembler : public MacroAssemblerBase {
                                                       SaveFPRegsMode fp_mode);
   void CallVerifySkippedWriteBarrierStub(Register object, Register value);
 
+  void CallVerifySkippedIndirectWriteBarrierStubSaveRegisters(
+      Register object, Register value, SaveFPRegsMode fp_mode);
+  void CallVerifySkippedIndirectWriteBarrierStub(Register object,
+                                                 Register value);
+
   // For a given |object| and |offset|:
   //   - Move |object| to |dst_object|.
   //   - Compute the address of the slot pointed to by |offset| in |object| and

deps/v8/src/codegen/loong64/macro-assembler-loong64.h

@@ -36,6 +36,8 @@ struct PositionTableEntry {
   int code_offset;
   bool is_statement;
   bool is_breakable;
+
+  bool operator==(const PositionTableEntry&) const = default;
 };
 
 class V8_EXPORT_PRIVATE SourcePositionTableBuilder {
@@ -95,6 +97,8 @@ class V8_EXPORT_PRIVATE SourcePositionTableIterator {
     PositionTableEntry position_;
     IterationFilter iteration_filter_;
     FunctionEntryFilter function_entry_filter_;
+
+    bool operator==(const IndexAndPositionState&) const = default;
   };
 
   // We expose three flavours of the iterator, depending on the argument passed