repo/gentoo:master commit in: net-libs/nodejs/files/, net-libs/nodejs/
"Mike Pagano" <[email protected]> Wed, 05 Aug 2026 13:10:16 +0000 (UTC)
| Newsgroups | gmane.linux.gentoo.cvs |
|---|---|
| Message-ID | <1785935362.d05526535311f48e75ffa1c8d03078af6cd95743.mpagano@gentoo> |
commit: d05526535311f48e75ffa1c8d03078af6cd95743 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Aug 5 13:09:22 2026 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Aug 5 13:09:22 2026 +0000 URL: https://gitweb.gentoo.org/repo/gentoo.git/commit/?id=d0552653 net-libs/nodejs: add 24.19.0 Bug: https://bugs.gentoo.org/980368 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> net-libs/nodejs/Manifest | 1 + net-libs/nodejs/files/nodejs-24.19.0-32-bit.patch | 579 ++++++++++++++++++++++ net-libs/nodejs/nodejs-24.19.0.ebuild | 294 +++++++++++ 3 files changed, 874 insertions(+) diff --git a/net-libs/nodejs/Manifest b/net-libs/nodejs/Manifest index 1ea2d1e8c452..e715ec55060c 100644 --- a/net-libs/nodejs/Manifest +++ b/net-libs/nodejs/Manifest @@ -9,6 +9,7 @@ DIST node-v24.1.0.tar.xz 50168800 BLAKE2B 3eec161010f04e410abda82b146cf957fd5583 DIST node-v24.11.1.tar.xz 51747676 BLAKE2B 85f7fb43d795463af436d646f953133e3bb97bdcd391882068b449b2237f1daac07e06ddb5d78235f4be4e3d521d8a74997a6841bef0dbf49c71616ec9cb490a SHA512 a41c9d53f8ab4f4642259c42e682fd58fc58d6d6657310544008e96e4113503eec82a185922360577c5a5739ba3fadd04e10798f805d7a3399ef4a3e1a233629 DIST node-v24.14.0.tar.xz 53987528 BLAKE2B 3d181bdb01c82ea10add1251b97614ea8bb2cc1de52044a639a1955339c4861e84600bd89c0e951f20f4dc61352838142a4d87bd07380936661d89a7f68bc0e5 SHA512 44f8a4758f34373f44daf1498ecb83261788251a43c9063bc3572ebf9bd647adafbc44474127771f5f9e36aa01feee1ad991e01ab3ec5a892607194441f76aaa DIST node-v24.16.0.tar.xz 55318312 BLAKE2B e5168b8c6baebe6a271bfc31ff3e9f09e30fc794d5ce1d6d092c52c70caa610d7968fa511d3e9fe34ad8bcf6310753753575d9aa1365927e87c5aca29ce4b7f2 SHA512 6edcc82dc847174c99ea7975d9bf3fcfd3201f82f21d4b517623514e17c931c87c0e9d4186d68285b2b4f5bc7a89c5a365ca67e0b9b2f2aaacc697a9e7293bb4 +DIST node-v24.19.0.tar.xz 55505276 BLAKE2B 7a7caa4fc46e598010c8a27e1463018b2cb65d430888aa7181c5e8db5e213379723b2d29f2f446d542900c0850b0dc3f4dfe98d942d2caae244f6a2a93b58c47 SHA512 82057740cace16e02fa973d5fef5fc265150e3c278cc232d32ad7d5a9163b8cbfdf437de8675b8a174c9883a94a680de2ac1c2184957767efd5add3fa8380751 DIST node-v24.2.0.tar.xz 49809356 BLAKE2B fa52bac011b51b44573bfd0c0aa3e90aee7463a505eb354d870651edfb27e84221521e8020d2a018917fdc8efef0112f124b2c239669e90060695ceb8468d7f9 SHA512 39569e668e6f98d0bdb76eae857e884d0765a25cf05cae58da0d5d0e2a96ad0100dcebac97b91ab9693a0e3403746a67222ec5ead8be1a6f0b7c83888d40b466 DIST node-v24.7.0.tar.xz 51707840 BLAKE2B acd46c43d20f43f6134df5bb65fc6835d977edee9a499a328632c4e6f24fb0f98d032cc8b5afa9a153e2b12669a2b2c6cafdb4f2be5c0265060f34e49a4fdb74 SHA512 d90cca68bf1d1b5a550d68dd1d2e6957610809a67c36e198626cd2ba84ebe006f5d8579a7ea1768fc6802edf0ceb7be5200e566944c2632ff83586e0e3f2af2d DIST node-v24.9.0.tar.xz 51787384 BLAKE2B 663fabae1780c3fa7890af3c609f55b4f19234dca2ce6557e62cbdee8d26776eae2c043dee14e5c45273d4657eccfa763264f35cf1bb83e26b37243f49e02abb SHA512 11eae0e0d7497cebdc454b3a34af3da225b9b0407ca1e6f6f5d13659eddc430148c7c8e6f2d9d329ec9c2f670cba8d9bb9a1d6ff4ed39f474dd331a77a543896 diff --git a/net-libs/nodejs/files/nodejs-24.19.0-32-bit.patch b/net-libs/nodejs/files/nodejs-24.19.0-32-bit.patch new file mode 100644 index 000000000000..921e72af0350 --- /dev/null +++ b/net-libs/nodejs/files/nodejs-24.19.0-32-bit.patch @@ -0,0 +1,579 @@ +https://bugs.gentoo.org/969806 +https://raw.githubusercontent.com/pld-linux/nodejs/5be298517dba200f2036287fb80afc799d9dd497/tuple-build-fix.patch + +From ddfa1b3d9201d319e893b4f5624eab43caae86b0 Mon Sep 17 00:00:00 2001 +From: Nico Hartmann <[email protected]> +Date: Fri, 08 Aug 2025 11:43:12 +0200 +Subject: [PATCH] [turboshaft] Rename TupleOp to MakeTupleOp to avoid name conflicts + +Bug: 385155404 +Change-Id: I0f8f4667e09afb1f4d122dadc1e3fcab80ba7acb +Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/6830052 +Commit-Queue: Nico Hartmann <[email protected]> +Reviewed-by: Leszek Swirski <[email protected]> +Cr-Commit-Position: refs/heads/main@{#101805} +--- + +diff --git a/src/compiler/backend/instruction-selector.cc b/src/compiler/backend/instruction-selector.cc +index 745c46a..7f6498d 100644 +--- a/deps/v8/src/compiler/backend/instruction-selector.cc ++++ b/deps/v8/src/compiler/backend/instruction-selector.cc +@@ -430,7 +430,7 @@ + // If the projection has a single use, it is the following tuple, so we + // don't return it, since there is no point in emitting it. + DCHECK(turboshaft_uses(next).size() == 1 && +- graph->Get(turboshaft_uses(next)[0]).Is<TupleOp>()); ++ graph->Get(turboshaft_uses(next)[0]).Is<MakeTupleOp>()); + continue; + } + if (projection->index == projection_index) return next; +@@ -449,7 +449,7 @@ + // (which doesn't count as a regular use since it is just an artifact of + // the Turboshaft graph). + DCHECK(turboshaft_uses(use).size() == 1 && +- graph->Get(turboshaft_uses(use)[0]).Is<TupleOp>()); ++ graph->Get(turboshaft_uses(use)[0]).Is<MakeTupleOp>()); + } + } + } +@@ -2070,7 +2070,7 @@ + // If the projection has a single use, it is the following tuple, so we + // don't care about the value, and can do branch-if-overflow fusion. + DCHECK(turboshaft_uses(projection0_index).size() == 1 && +- graph->Get(turboshaft_uses(projection0_index)[0]).Is<TupleOp>()); ++ graph->Get(turboshaft_uses(projection0_index)[0]).Is<MakeTupleOp>()); + return true; + } + +@@ -2085,7 +2085,7 @@ + // defined, which will imply that it's fine to define {projection0} and + // {binop} now. + for (OpIndex use : turboshaft_uses(projection0_index)) { +- if (this->Get(use).template Is<TupleOp>()) { ++ if (this->Get(use).template Is<MakeTupleOp>()) { + // The Tuple won't have any uses since it would have to be accessed + // through Projections, and Projections on Tuples return the original + // Projection instead (see Assembler::ReduceProjection in +@@ -2493,9 +2493,9 @@ + // {result} back into it through the back edge. In this case, it's + // normal to schedule {result} before the Phi that uses it. + for (OpIndex use : turboshaft_uses(result.value())) { +- // We ignore TupleOp uses, since TupleOp don't lead to emitted machine +- // instructions and are just Turboshaft "meta operations". +- if (!this->Get(use).template Is<TupleOp>() && !IsDefined(use) && ++ // We ignore MakeTupleOp uses, since MakeTupleOp don't lead to emitted ++ // machine instructions and are just Turboshaft "meta operations". ++ if (!this->Get(use).template Is<MakeTupleOp>() && !IsDefined(use) && + this->block(schedule_, use) == current_block_ && + !this->Get(use).template Is<PhiOp>()) { + return; +@@ -3869,7 +3869,7 @@ + TURBOSHAFT_WASM_OPERATION_LIST(UNREACHABLE_CASE) + TURBOSHAFT_OTHER_OPERATION_LIST(UNREACHABLE_CASE) + UNREACHABLE_CASE(PendingLoopPhi) +- UNREACHABLE_CASE(Tuple) ++ UNREACHABLE_CASE(MakeTuple) + UNREACHABLE_CASE(Dead) + UNREACHABLE(); + #undef UNREACHABLE_CASE +diff --git a/src/compiler/turboshaft/assembler.h b/src/compiler/turboshaft/assembler.h +index c2726c2..98d5809 100644 +--- a/deps/v8/src/compiler/turboshaft/assembler.h ++++ b/deps/v8/src/compiler/turboshaft/assembler.h +@@ -960,7 +960,7 @@ + for (int i = 0; i < static_cast<int>(reps.size()); i++) { + projections.push_back(Asm().Projection(idx, i, reps[i])); + } +- return Asm().Tuple(base::VectorOf(projections)); ++ return Asm().MakeTuple(base::VectorOf(projections)); + } + return idx; + } +@@ -4216,22 +4216,22 @@ + return PendingLoopPhi(first, V<T>::rep); + } + +- V<Any> Tuple(base::Vector<const V<Any>> indices) { +- return ReduceIfReachableTuple(indices); ++ V<Any> MakeTuple(base::Vector<const V<Any>> indices) { ++ return ReduceIfReachableMakeTuple(indices); + } +- V<Any> Tuple(std::initializer_list<V<Any>> indices) { +- return ReduceIfReachableTuple(base::VectorOf(indices)); ++ V<Any> MakeTuple(std::initializer_list<V<Any>> indices) { ++ return ReduceIfReachableMakeTuple(base::VectorOf(indices)); + } + template <typename... Ts> +- V<turboshaft::Tuple<Ts...>> Tuple(V<Ts>... indices) { ++ V<turboshaft::Tuple<Ts...>> MakeTuple(V<Ts>... indices) { + std::initializer_list<V<Any>> inputs{V<Any>::Cast(indices)...}; +- return V<turboshaft::Tuple<Ts...>>::Cast(Tuple(base::VectorOf(inputs))); ++ return V<turboshaft::Tuple<Ts...>>::Cast(MakeTuple(base::VectorOf(inputs))); + } + // TODO(chromium:331100916): Remove this overload once everything is properly + // V<>ified. +- V<turboshaft::Tuple<Any, Any>> Tuple(OpIndex left, OpIndex right) { ++ V<turboshaft::Tuple<Any, Any>> MakeTuple(OpIndex left, OpIndex right) { + return V<turboshaft::Tuple<Any, Any>>::Cast( +- Tuple(base::VectorOf({V<Any>::Cast(left), V<Any>::Cast(right)}))); ++ MakeTuple(base::VectorOf({V<Any>::Cast(left), V<Any>::Cast(right)}))); + } + + V<Any> Projection(V<Any> tuple, uint16_t index, RegisterRepresentation rep) { +@@ -5533,7 +5533,7 @@ + // this assumption of the ValueNumberingReducer will break. + V<Any> ReduceProjection(V<Any> tuple, uint16_t index, + RegisterRepresentation rep) { +- if (auto* tuple_op = Asm().matcher().template TryCast<TupleOp>(tuple)) { ++ if (auto* tuple_op = Asm().matcher().template TryCast<MakeTupleOp>(tuple)) { + return tuple_op->input(index); + } + return Stack::ReduceProjection(tuple, index, rep); +diff --git a/src/compiler/turboshaft/copying-phase.h b/src/compiler/turboshaft/copying-phase.h +index c1d20d0..485e0e2 100644 +--- a/deps/v8/src/compiler/turboshaft/copying-phase.h ++++ b/deps/v8/src/compiler/turboshaft/copying-phase.h +@@ -690,7 +690,7 @@ + if (V8_UNLIKELY(v8_flags.turboshaft_verify_reductions)) { + if (new_index.valid()) { + const Operation& new_op = Asm().output_graph().Get(new_index); +- if (!new_op.Is<TupleOp>()) { ++ if (!new_op.Is<MakeTupleOp>()) { + // Checking that the outputs_rep of the new operation are the same as + // the old operation. (except for tuples, since they don't have + // outputs_rep) +diff --git a/src/compiler/turboshaft/fast-api-call-lowering-reducer.h b/src/compiler/turboshaft/fast-api-call-lowering-reducer.h +index d52554b..f833874 100644 +--- a/deps/v8/src/compiler/turboshaft/fast-api-call-lowering-reducer.h ++++ b/deps/v8/src/compiler/turboshaft/fast-api-call-lowering-reducer.h +@@ -137,7 +137,7 @@ + } + + BIND(done, state); +- return __ Tuple(state, __ GetVariable(result)); ++ return __ MakeTuple(state, __ GetVariable(result)); + } + + private: +diff --git a/src/compiler/turboshaft/graph.h b/src/compiler/turboshaft/graph.h +index 030171f..936c8b0 100644 +--- a/deps/v8/src/compiler/turboshaft/graph.h ++++ b/deps/v8/src/compiler/turboshaft/graph.h +@@ -1141,7 +1141,8 @@ + for (OpIndex input : op.inputs()) { + // Tuples should never be used as input, except in other tuples (which is + // used for instance in Int64Lowering::LowerCall). +- DCHECK_IMPLIES(Get(input).Is<TupleOp>(), op.template Is<TupleOp>()); ++ DCHECK_IMPLIES(Get(input).Is<MakeTupleOp>(), ++ op.template Is<MakeTupleOp>()); + Get(input).saturated_use_count.Incr(); + } + } +@@ -1151,7 +1152,8 @@ + for (OpIndex input : op.inputs()) { + // Tuples should never be used as input, except in other tuples (which is + // used for instance in Int64Lowering::LowerCall). +- DCHECK_IMPLIES(Get(input).Is<TupleOp>(), op.template Is<TupleOp>()); ++ DCHECK_IMPLIES(Get(input).Is<MakeTupleOp>(), ++ op.template Is<MakeTupleOp>()); + Get(input).saturated_use_count.Decr(); + } + } +diff --git a/src/compiler/turboshaft/int64-lowering-reducer.h b/src/compiler/turboshaft/int64-lowering-reducer.h +index a814582..e16b3af 100644 +--- a/deps/v8/src/compiler/turboshaft/int64-lowering-reducer.h ++++ b/deps/v8/src/compiler/turboshaft/int64-lowering-reducer.h +@@ -169,7 +169,7 @@ + if (kind == ConstantOp::Kind::kWord64) { + uint32_t high = value.integral >> 32; + uint32_t low = value.integral & std::numeric_limits<uint32_t>::max(); +- return __ Tuple(__ Word32Constant(low), __ Word32Constant(high)); ++ return __ MakeTuple(__ Word32Constant(low), __ Word32Constant(high)); + } + return Next::ReduceConstant(kind, value); + } +@@ -192,8 +192,8 @@ + int32_t new_index = param_index_map_[parameter_index]; + if (rep == RegisterRepresentation::Word64()) { + rep = RegisterRepresentation::Word32(); +- return __ Tuple(Next::ReduceParameter(new_index, rep), +- Next::ReduceParameter(new_index + 1, rep)); ++ return __ MakeTuple(Next::ReduceParameter(new_index, rep), ++ Next::ReduceParameter(new_index + 1, rep)); + } + return Next::ReduceParameter(new_index, rep, debug_name); + } +@@ -241,7 +241,7 @@ + auto [low, high] = Unpack(input_pair); + V<Word32> reversed_low = __ Word32ReverseBytes(low); + V<Word32> reversed_high = __ Word32ReverseBytes(high); +- return __ Tuple(reversed_high, reversed_low); ++ return __ MakeTuple(reversed_high, reversed_low); + } + default: + FATAL("WordUnaryOp kind %d not supported by int64 lowering", +@@ -265,7 +265,7 @@ + + if (from == word32 && to == word64) { + if (kind == Kind::kZeroExtend) { +- return __ Tuple(V<Word32>::Cast(input), __ Word32Constant(0)); ++ return __ MakeTuple(V<Word32>::Cast(input), __ Word32Constant(0)); + } + if (kind == Kind::kSignExtend) { + return LowerSignExtend(input); +@@ -273,8 +273,8 @@ + } + if (from == float64 && to == word64) { + if (kind == Kind::kBitcast) { +- return __ Tuple(__ Float64ExtractLowWord32(input), +- __ Float64ExtractHighWord32(input)); ++ return __ MakeTuple(__ Float64ExtractLowWord32(input), ++ __ Float64ExtractHighWord32(input)); + } + } + if (from == word64 && to == float64) { +@@ -339,7 +339,7 @@ + return __ AtomicWord32PairLoad(base, index, offset); + } + if (result_rep == RegisterRepresentation::Word64()) { +- return __ Tuple( ++ return __ MakeTuple( + __ Load(base, index, kind, loaded_rep, + RegisterRepresentation::Word32(), offset, element_scale), + __ Word32Constant(0)); +@@ -349,7 +349,7 @@ + loaded_rep == MemoryRepresentation::Uint64()) { + auto [high_index, high_offset] = + IncreaseOffset(index, offset, sizeof(int32_t), kind.tagged_base); +- return __ Tuple( ++ return __ MakeTuple( + Next::ReduceLoad(base, index, kind, MemoryRepresentation::Int32(), + RegisterRepresentation::Word32(), offset, + element_scale), +@@ -435,7 +435,7 @@ + auto [expected_low, expected_high] = Unpack(expected.value()); + new_expected = expected_low; + } +- return __ Tuple(Next::ReduceAtomicRMW( ++ return __ MakeTuple(Next::ReduceAtomicRMW( + base, index, value_low, new_expected, bin_op, + RegisterRepresentation::Word32(), memory_rep, kind), + __ Word32Constant(0)); +@@ -455,8 +455,8 @@ + inputs_low.push_back(__ template Projection<0>(input_w32p)); + inputs_high.push_back(__ template Projection<1>(input_w32p)); + } +- return __ Tuple(Next::ReducePhi(base::VectorOf(inputs_low), word32), +- Next::ReducePhi(base::VectorOf(inputs_high), word32)); ++ return __ MakeTuple(Next::ReducePhi(base::VectorOf(inputs_low), word32), ++ Next::ReducePhi(base::VectorOf(inputs_high), word32)); + } + return Next::ReducePhi(inputs, rep); + } +@@ -466,7 +466,7 @@ + auto input_w32p = V<Word32Pair>::Cast(input); + V<Word32> low = __ PendingLoopPhi(__ template Projection<0>(input_w32p)); + V<Word32> high = __ PendingLoopPhi(__ template Projection<1>(input_w32p)); +- return __ Tuple(low, high); ++ return __ MakeTuple(low, high); + } + return Next::ReducePendingLoopPhi(input, rep); + } +@@ -474,7 +474,8 @@ + void FixLoopPhi(const PhiOp& input_phi, OpIndex output_index, + Block* output_graph_loop) { + if (input_phi.rep == RegisterRepresentation::Word64()) { +- const TupleOp& tuple = __ Get(output_index).template Cast<TupleOp>(); ++ const MakeTupleOp& tuple = ++ __ Get(output_index).template Cast<MakeTupleOp>(); + DCHECK_EQ(tuple.input_count, 2); + OpIndex new_inputs[2] = {__ MapToNewGraph(input_phi.input(0)), + __ MapToNewGraph(input_phi.input(1))}; +@@ -527,7 +528,7 @@ + input, Simd128ExtractLaneOp::Kind::kI32x4, 2 * lane)); + V<Word32> high = V<Word32>::Cast(__ Simd128ExtractLane( + input, Simd128ExtractLaneOp::Kind::kI32x4, 2 * lane + 1)); +- return __ Tuple(low, high); ++ return __ MakeTuple(low, high); + } + + V<Simd128> REDUCE(Simd128ReplaceLane)(V<Simd128> into, V<Any> new_lane, +@@ -612,7 +613,7 @@ + private: + bool CheckPairOrPairOp(V<Word32Pair> input) { + #ifdef DEBUG +- if (const TupleOp* tuple = matcher_.TryCast<TupleOp>(input)) { ++ if (const MakeTupleOp* tuple = matcher_.TryCast<MakeTupleOp>(input)) { + DCHECK_EQ(2, tuple->input_count); + RegisterRepresentation word32 = RegisterRepresentation::Word32(); + ValidateOpInputRep(__ output_graph(), tuple->input(0), word32); +@@ -642,7 +643,7 @@ + + V<Word32Pair> LowerSignExtend(V<Word32> input) { + // We use SAR to preserve the sign in the high word. +- return __ Tuple(input, __ Word32ShiftRightArithmetic(input, 31)); ++ return __ MakeTuple(input, __ Word32ShiftRightArithmetic(input, 31)); + } + + V<Word32Pair> LowerClz(V<Word32Pair> input) { +@@ -654,7 +655,7 @@ + result = __ Word32CountLeadingZeros(high); + } + +- return __ Tuple<Word32, Word32>(result, __ Word32Constant(0)); ++ return __ template MakeTuple<Word32, Word32>(result, __ Word32Constant(0)); + } + + V<Word32Pair> LowerCtz(V<Word32Pair> input) { +@@ -667,13 +668,13 @@ + result = __ Word32CountTrailingZeros(low); + } + +- return __ Tuple<Word32, Word32>(result, __ Word32Constant(0)); ++ return __ template MakeTuple<Word32, Word32>(result, __ Word32Constant(0)); + } + + V<Word32Pair> LowerPopCount(V<Word32Pair> input) { + DCHECK(SupportedOperations::word32_popcnt()); + auto [low, high] = Unpack(input); +- return __ Tuple( ++ return __ MakeTuple( + __ Word32Add(__ Word32PopCount(low), __ Word32PopCount(high)), + __ Word32Constant(0)); + } +@@ -698,7 +699,7 @@ + auto [right_low, right_high] = Unpack(right); + V<Word32> low_result = __ Word32BitwiseAnd(left_low, right_low); + V<Word32> high_result = __ Word32BitwiseAnd(left_high, right_high); +- return __ Tuple(low_result, high_result); ++ return __ MakeTuple(low_result, high_result); + } + + V<Word32Pair> LowerBitwiseOr(V<Word32Pair> left, V<Word32Pair> right) { +@@ -706,7 +707,7 @@ + auto [right_low, right_high] = Unpack(right); + V<Word32> low_result = __ Word32BitwiseOr(left_low, right_low); + V<Word32> high_result = __ Word32BitwiseOr(left_high, right_high); +- return __ Tuple(low_result, high_result); ++ return __ MakeTuple(low_result, high_result); + } + + V<Word32Pair> LowerBitwiseXor(V<Word32Pair> left, V<Word32Pair> right) { +@@ -714,7 +715,7 @@ + auto [right_low, right_high] = Unpack(right); + V<Word32> low_result = __ Word32BitwiseXor(left_low, right_low); + V<Word32> high_result = __ Word32BitwiseXor(left_high, right_high); +- return __ Tuple(low_result, high_result); ++ return __ MakeTuple(low_result, high_result); + } + + V<Word32Pair> LowerRotateRight(V<Word32Pair> left, V<Word32> right) { +@@ -733,7 +734,7 @@ + } + if (shift_value == 32) { + // Swap low and high of left. +- return __ Tuple(left_high, left_low); ++ return __ MakeTuple(left_high, left_low); + } + + V<Word32> low_input = left_high; +@@ -753,7 +754,7 @@ + V<Word32> high_node = __ Word32BitwiseOr( + __ Word32ShiftRightLogical(high_input, masked_shift), + __ Word32ShiftLeft(low_input, inv_shift)); +- return __ Tuple(low_node, high_node); ++ return __ MakeTuple(low_node, high_node); + } + + V<Word32> safe_shift = shift; +@@ -786,7 +787,7 @@ + V<Word32> high_node = + __ Word32BitwiseOr(__ Word32BitwiseAnd(rotate_high, bit_mask), + __ Word32BitwiseAnd(rotate_low, inv_mask)); +- return __ Tuple(low_node, high_node); ++ return __ MakeTuple(low_node, high_node); + } + + V<Any> LowerCall(V<CallTarget> callee, OptionalV<FrameState> frame_state, +@@ -870,7 +871,7 @@ + // Example for a call returning [int64, int32]: + // In: Call(...) -> [int64, int32] + // Out: call = Call() -> [int32, int32, int32] +- // Tuple( ++ // MakeTuple( + // Tuple(Projection(call, 0), Projection(call, 1)), + // Projection(call, 2)) + // +@@ -886,8 +887,8 @@ + call_descriptor->GetReturnType(i).representation(); + if (machine_rep == MachineRepresentation::kWord64) { + tuple_inputs.push_back( +- __ Tuple(__ Projection(call, projection_index, word32), +- __ Projection(call, projection_index + 1, word32))); ++ __ MakeTuple(__ Projection(call, projection_index, word32), ++ __ Projection(call, projection_index + 1, word32))); + projection_index += 2; + } else { + tuple_inputs.push_back(__ Projection( +@@ -896,7 +897,7 @@ + } + } + DCHECK_EQ(projection_index, return_count + i64_returns); +- return __ Tuple(base::VectorOf(tuple_inputs)); ++ return __ MakeTuple(base::VectorOf(tuple_inputs)); + } + + void InitializeIndexMaps() { +diff --git a/src/compiler/turboshaft/machine-optimization-reducer.h b/src/compiler/turboshaft/machine-optimization-reducer.h +index 199b844..bf0d4bd 100644 +--- a/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h ++++ b/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h +@@ -1312,7 +1312,8 @@ + overflow = base::bits::SignedSubOverflow32(k1, k2, &res); + break; + } +- return __ Tuple(__ Word32Constant(res), __ Word32Constant(overflow)); ++ return __ MakeTuple(__ Word32Constant(res), ++ __ Word32Constant(overflow)); + } + } else { + DCHECK_EQ(rep, WordRepresentation::Word64()); +@@ -1331,7 +1332,8 @@ + overflow = base::bits::SignedSubOverflow64(k1, k2, &res); + break; + } +- return __ Tuple(__ Word64Constant(res), __ Word32Constant(overflow)); ++ return __ MakeTuple(__ Word64Constant(res), ++ __ Word32Constant(overflow)); + } + } + +@@ -1339,18 +1341,19 @@ + // left - 0 => (left, false) + if (kind == any_of(Kind::kSignedAdd, Kind::kSignedSub) && + matcher_.MatchZero(right)) { +- return __ Tuple(left, __ Word32Constant(0)); ++ return __ MakeTuple(left, __ Word32Constant(0)); + } + + if (kind == Kind::kSignedMul) { + if (int64_t k; matcher_.MatchIntegralWordConstant(right, rep, &k)) { + // left * 0 => (0, false) + if (k == 0) { +- return __ Tuple(__ WordConstant(0, rep), __ Word32Constant(false)); ++ return __ MakeTuple(__ WordConstant(0, rep), ++ __ Word32Constant(false)); + } + // left * 1 => (left, false) + if (k == 1) { +- return __ Tuple(left, __ Word32Constant(false)); ++ return __ MakeTuple(left, __ Word32Constant(false)); + } + // left * -1 => 0 - left + if (k == -1) { +@@ -1370,7 +1373,7 @@ + if (V<Word32> x; matcher_.MatchConstantShiftRightArithmeticShiftOutZeros( + left, &x, WordRepresentation::Word32(), &amount) && + amount == 1) { +- return __ Tuple(x, __ Word32Constant(0)); ++ return __ MakeTuple(x, __ Word32Constant(0)); + } + } + +diff --git a/src/compiler/turboshaft/operations.h b/src/compiler/turboshaft/operations.h +index 4f05fe1..0a67a0b 100644 +--- a/deps/v8/src/compiler/turboshaft/operations.h ++++ b/deps/v8/src/compiler/turboshaft/operations.h +@@ -329,7 +329,7 @@ + V(Call) \ + V(CatchBlockBegin) \ + V(DidntThrow) \ +- V(Tuple) \ ++ V(MakeTuple) \ + V(Projection) \ + V(DebugBreak) \ + V(AssumeMap) \ +@@ -4601,8 +4601,8 @@ + const Block& block, const Graph& graph); + + // Tuples are only used to lower operations with multiple outputs. +-// `TupleOp` should be folded away by subsequent `ProjectionOp`s. +-struct TupleOp : OperationT<TupleOp> { ++// `MakeTupleOp` should be folded away by subsequent `ProjectionOp`s. ++struct MakeTupleOp : OperationT<MakeTupleOp> { + static constexpr OpEffects effects = OpEffects(); + base::Vector<const RegisterRepresentation> outputs_rep() const { return {}; } + +@@ -4611,7 +4611,7 @@ + return {}; + } + +- explicit TupleOp(base::Vector<const V<Any>> inputs) : Base(inputs) {} ++ explicit MakeTupleOp(base::Vector<const V<Any>> inputs) : Base(inputs) {} + + template <typename Fn, typename Mapper> + V8_INLINE auto Explode(Fn fn, Mapper& mapper) const { +diff --git a/src/compiler/turboshaft/turbolev-graph-builder.cc b/src/compiler/turboshaft/turbolev-graph-builder.cc +index 18733cc..378dddd 100644 +--- a/deps/v8/src/compiler/turboshaft/turbolev-graph-builder.cc ++++ b/deps/v8/src/compiler/turboshaft/turbolev-graph-builder.cc +@@ -6191,7 +6191,7 @@ + + void SetMapMaybeMultiReturn(maglev::NodeBase* node, V<Any> idx) { + const Operation& op = __ output_graph().Get(idx); +- if (const TupleOp* tuple = op.TryCast<TupleOp>()) { ++ if (const MakeTupleOp* tuple = op.TryCast<MakeTupleOp>()) { + // If the call returned multiple values, then in Maglev, {node} is + // used as the 1st returned value, and a GetSecondReturnedValue node is + // used to access the 2nd value. We thus call `SetMap` with the 1st +diff --git a/src/compiler/turboshaft/type-inference-analysis.h b/src/compiler/turboshaft/type-inference-analysis.h +index 6370e67..164e3b1 100644 +--- a/deps/v8/src/compiler/turboshaft/type-inference-analysis.h ++++ b/deps/v8/src/compiler/turboshaft/type-inference-analysis.h +@@ -158,7 +158,7 @@ + case Opcode::kRetain: + case Opcode::kUnreachable: + case Opcode::kSwitch: +- case Opcode::kTuple: ++ case Opcode::kMakeTuple: + case Opcode::kStaticAssert: + case Opcode::kDebugBreak: + case Opcode::kDebugPrint: +diff --git a/src/compiler/turboshaft/type-inference-reducer.h b/src/compiler/turboshaft/type-inference-reducer.h +index df241cf..4d1bcd8 100644 +--- a/deps/v8/src/compiler/turboshaft/type-inference-reducer.h ++++ b/deps/v8/src/compiler/turboshaft/type-inference-reducer.h +@@ -445,7 +445,7 @@ + return Type::Invalid(); + } + +- Type GetTupleType(const TupleOp& tuple) { ++ Type GetTupleType(const MakeTupleOp& tuple) { + base::SmallVector<Type, 4> tuple_types; + for (OpIndex input : tuple.inputs()) { + tuple_types.push_back(GetType(input)); +@@ -457,8 +457,8 @@ + Type type = GetTypeOrInvalid(index); + if (type.IsInvalid()) { + const Operation& op = Asm().output_graph().Get(index); +- if (op.Is<TupleOp>()) { +- return GetTupleType(op.Cast<TupleOp>()); ++ if (op.Is<MakeTupleOp>()) { ++ return GetTupleType(op.Cast<MakeTupleOp>()); + } else { + return Typer::TypeForRepresentation(op.outputs_rep(), + Asm().graph_zone()); +diff --git a/src/compiler/turboshaft/wasm-lowering-reducer.h b/src/compiler/turboshaft/wasm-lowering-reducer.h +index 282f1cd..4a43bac 100644 +--- a/deps/v8/src/compiler/turboshaft/wasm-lowering-reducer.h ++++ b/deps/v8/src/compiler/turboshaft/wasm-lowering-reducer.h +@@ -620,7 +620,7 @@ + } + { + BIND(done, base, final_offset, charwidth_shift); +- return __ Tuple({base, final_offset, charwidth_shift}); ++ return __ MakeTuple({base, final_offset, charwidth_shift}); + } + } + + diff --git a/net-libs/nodejs/nodejs-24.19.0.ebuild b/net-libs/nodejs/nodejs-24.19.0.ebuild new file mode 100644 index 000000000000..76112bd89630 --- /dev/null +++ b/net-libs/nodejs/nodejs-24.19.0.ebuild @@ -0,0 +1,294 @@ +# Copyright 1999-2026 Gentoo Authors +# Distributed under the terms of the GNU General Public License v2 + +EAPI=8 + +CONFIG_CHECK="~ADVISE_SYSCALLS" +PYTHON_COMPAT=( python3_{11..14} ) +PYTHON_REQ_USE="threads(+)" + +inherit bash-completion-r1 check-reqs flag-o-matic linux-info +inherit ninja-utils pax-utils python-any-r1 toolchain-funcs xdg-utils + +DESCRIPTION="A JavaScript runtime built on Chrome's V8 JavaScript engine" +HOMEPAGE="https://nodejs.org/" +LICENSE="Apache-1.1 Apache-2.0 BlueOak-1.0.0 BSD BSD-2 MIT npm? ( Artistic-2 )" + +if [[ ${PV} == *9999 ]]; then + inherit git-r3 + EGIT_REPO_URI="https://github.com/nodejs/node" + SLOT="0" +else + SRC_URI=" + https://nodejs.org/dist/v${PV}/node-v${PV}.tar.xz + " + SLOT="0/$(ver_cut 1)" + KEYWORDS="~amd64 ~arm ~arm64 ~loong ~ppc64 ~riscv ~x86 ~x64-macos" + S="${WORKDIR}/node-v${PV}" +fi + +IUSE="corepack cpu_flags_x86_sse2 debug doc +icu +inspector lto +npm pax-kernel +snapshot +ssl +system-icu +system-ssl test" +REQUIRED_USE="inspector? ( icu ssl ) + npm? ( ssl ) + system-icu? ( icu ) + system-ssl? ( ssl ) + x86? ( cpu_flags_x86_sse2 )" + +RESTRICT="!test? ( test )" + +COMMON_DEPEND=">=app-arch/brotli-1.1.0:= + dev-db/sqlite:3 + >=dev-cpp/ada-3.3.0:= + >=dev-cpp/simdutf-7.3.4:= + >=dev-libs/libuv-1.52.1:= + >=dev-libs/simdjson-4.6.1:= + >=net-dns/c-ares-1.34.5:= + >=net-libs/nghttp2-1.69.0:= + >=net-libs/nghttp3-1.14.0:= + virtual/zlib:= + corepack? ( !sys-apps/yarn ) + system-icu? ( >=dev-libs/icu-73:= ) + system-ssl? ( + >=net-libs/ngtcp2-1.14.0:= + >=dev-libs/openssl-3.5.6:0= + ) + !system-ssl? ( >=net-libs/ngtcp2-1.14.0:=[-gnutls] ) + || ( + sys-devel/gcc:* + llvm-runtimes/libatomic-stub + )" +BDEPEND="${PYTHON_DEPS} + app-alternatives/ninja + sys-apps/coreutils + virtual/pkgconfig + test? ( net-misc/curl ) + pax-kernel? ( sys-apps/elfix )" +DEPEND="${COMMON_DEPEND}" +RDEPEND="${COMMON_DEPEND}" + +# These are measured on a loong machine with -ggdb on, and only checked +# if debugging flags are present in CFLAGS. +# +# The final link consumed a little more than 7GiB alone, so 8GiB is the lower +# limit for memory usage. Disk usage was 19.1GiB for the build directory and +# 1.2GiB for the installed image, so we leave some room for architectures with +# fatter binaries and set the disk requirement to 22GiB. +CHECKREQS_MEMORY="8G" +CHECKREQS_DISK_BUILD="22G" + +PATCHES=( + "${FILESDIR}"/${P}-32-bit.patch +) + +pkg_pretend() { + if [[ ${MERGE_TYPE} != "binary" ]]; then + if is-flagq "-g*" && ! is-flagq "-g*0" ; then + einfo "Checking for sufficient disk space and memory to build ${PN} with debugging CFLAGS" + check-reqs_pkg_pretend + fi + fi +} + +pkg_setup() { + python-any-r1_pkg_setup + linux-info_pkg_setup +} + +src_prepare() { + tc-export AR CC CXX PKG_CONFIG + export V=1 + export BUILDTYPE=Release + + # fix compilation on Darwin + # https://code.google.com/p/gyp/issues/detail?id=260 + sed -i -e "/append('-arch/d" tools/gyp/pylib/gyp/xcode_emulation.py || die + + # proper libdir, hat tip @ryanpcmcquen https://github.com/iojs/io.js/issues/504 + local LIBDIR=$(get_libdir) + sed -i -e "s|lib/|${LIBDIR}/|g" tools/install.py || die + sed -i -e "s/'lib'/'${LIBDIR}'/" deps/npm/lib/npm.js || die + + # Avoid writing a depfile, not useful + sed -i -e "/DEPFLAGS =/d" tools/gyp/pylib/gyp/generator/make.py || die + + sed -i -e "/'-O3'/d" common.gypi node.gypi || die + + # debug builds. change install path, remove optimisations and override buildtype + if use debug; then + sed -i -e "s|out/Release/|out/Debug/|g" tools/install.py || die + BUILDTYPE=Debug + fi + + # We need to disable mprotect on two files when it builds Bug 694100. + use pax-kernel && + PATCHES+=( "${FILESDIR}"/${PN}-24.1.0-paxmarking.patch ) + + use ppc64 && + PATCHES+=( "${FILESDIR}/${PN}-24.11.1-restore-ppc64be.patch" ) + + default +} + +src_configure() { + xdg_environment_reset + + # LTO compiler flags are handled by configure.py itself + filter-lto + # The warnings are *so* noisy and make build.logs massive + append-cxxflags $(test-flags-CXX -Wno-template-id-cdtor) + # https://bugs.gentoo.org/931514 + use arm64 && append-flags $(test-flags-CXX -mbranch-protection=none) + + local myconf=( + --ninja + --shared-ada + --shared-brotli + --shared-cares + --shared-libuv + --shared-nghttp2 + --shared-nghttp3 + --shared-ngtcp2 + --shared-simdjson + --shared-simdutf + --shared-sqlite + --shared-zlib + ) + use debug && myconf+=( --debug ) + use lto && myconf+=( --enable-lto ) + if use system-icu; then + myconf+=( --with-intl=system-icu ) + elif use icu; then + myconf+=( --with-intl=full-icu ) + else + myconf+=( --with-intl=none ) + fi + use corepack || myconf+=( --without-corepack ) + use inspector || myconf+=( --without-inspector ) + use npm || myconf+=( --without-npm ) + use snapshot || myconf+=( --without-node-snapshot ) + if use ssl; then + use system-ssl && myconf+=( --shared-openssl --openssl-use-def-ca-store ) + else + myconf+=( --without-ssl ) + fi + + local myarch="" + case "${ARCH}:${ABI}" in + *:amd64) myarch="x64";; + *:arm) myarch="arm";; + *:arm64) myarch="arm64";; + loong:lp64*) myarch="loong64";; + riscv:lp64*) myarch="riscv64";; + *:ppc64) myarch="ppc64";; + *:x32) myarch="x32";; + *:x86) myarch="ia32";; + *) myarch="${ABI}";; + esac + + GYP_DEFINES="linux_use_gold_flags=0 + linux_use_bundled_binutils=0 + linux_use_bundled_gold=0" \ + "${EPYTHON}" configure.py \ + --prefix="${EPREFIX}"/usr \ + --dest-cpu=${myarch} \ + "${myconf[@]}" || die +} + +src_compile() { + eninja -C out/Release +} + +src_install() { + local LIBDIR="${ED}/usr/$(get_libdir)" + default + + pax-mark -m "${ED}"/usr/bin/node + + if use doc; then + docinto html + dodoc -r "${S}"/doc/* + fi + + if use npm; then + keepdir /etc/npm + echo "NPM_CONFIG_GLOBALCONFIG=${EPREFIX}/etc/npm/npmrc" > "${T}"/50npm + doenvd "${T}"/50npm + + # Install bash completion for `npm` + local tmp_npm_completion_file="$(TMPDIR="${T}" mktemp -t npm.XXXXXXXXXX)" + "${ED}/usr/bin/npm" completion > "${tmp_npm_completion_file}" + newbashcomp "${tmp_npm_completion_file}" npm + + # Move man pages + doman "${LIBDIR}"/node_modules/npm/man/man{1,5,7}/* + + # Clean up + rm -f "${LIBDIR}"/node_modules/npm/{.mailmap,.npmignore,Makefile} + + local find_exp="-or -name" + local find_name=() + for match in "AUTHORS*" "CHANGELOG*" "CONTRIBUT*" "README*" \ + ".travis.yml" ".eslint*" ".wercker.yml" ".npmignore" \ + "*.bat" "*.cmd"; do + find_name+=( ${find_exp} "${match}" ) + done + + # Remove various development and/or inappropriate files and + # useless docs of dependend packages. + find "${LIBDIR}"/node_modules \ + \( -type d -name examples \) -or \( -type f \( \ + -iname "LICEN?E*" \ + "${find_name[@]}" \ + \) \) -exec rm -rf "{}" \; + fi + + use corepack && + "${D}"/usr/bin/corepack enable --install-directory "${D}"/usr/bin + + mv "${ED}"/usr/share/doc/node "${ED}"/usr/share/doc/${PF} || die +} + +src_test() { + local drop_tests=( + test/parallel/test-dns.js + test/parallel/test-dns-resolveany-bad-ancount.js + test/parallel/test-dns-setserver-when-querying.js + test/parallel/test-dotenv.js + test/parallel/test-fs-mkdir.js + test/parallel/test-fs-read-stream.js + test/parallel/test-fs-utimes-y2K38.js + test/parallel/test-fs-watch-recursive-add-file.js + test/parallel/test-http2-client-set-priority.js + test/parallel/test-http2-priority-event.js + test/parallel/test-process-euid-egid.js + test/parallel/test-process-get-builtin.mjs + test/parallel/test-process-initgroups.js + test/parallel/test-process-setgroups.js + test/parallel/test-process-uid-gid.js + test/parallel/test-release-npm.js + test/parallel/test-socket-write-after-fin-error.js + test/parallel/test-strace-openat-openssl.js + test/sequential/test-tls-session-timeout.js + test/sequential/test-util-debug.js + ) + use inspector || + drop_tests+=( + test/parallel/test-inspector-emit-protocol-event.js + test/parallel/test-inspector-network-arbitrary-data.js + test/parallel/test-inspector-network-domain.js + test/parallel/test-inspector-network-fetch.js + test/parallel/test-inspector-network-http.js + test/sequential/test-watch-mode.mjs + ) + rm -f "${drop_tests[@]}" || die "disabling tests failed" + + out/${BUILDTYPE}/cctest || die + "${EPYTHON}" tools/test.py --mode=${BUILDTYPE,,} --flaky-tests=dontcare -J message parallel sequential || die +} + +pkg_postinst() { + if use npm; then + ewarn "remember to run: source /etc/profile if you plan to use nodejs" + ewarn " in your current shell" + fi +}