nodejs/nodejs24
SHA256
8
0
Fork 1
forked from pool/nodejs24
generated from pool/new_package
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity
Files
main
nodejs24/v8_nameclash.patch

577 lines
27 KiB
Diff
Raw Permalink Blame History

based on:
commit ddfa1b3d9201d319e893b4f5624eab43caae86b0
Author: Nico Hartmann <nicohartmann@chromium.org>
Date: Fri Aug 8 11:43:12 2025 +0200
[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 <nicohartmann@chromium.org>
Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Cr-Commit-Position: refs/heads/main@{#101805}
Index: node-v24.11.1/deps/v8/src/compiler/backend/instruction-selector.cc
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/backend/instruction-selector.cc
+++ node-v24.11.1/deps/v8/src/compiler/backend/instruction-selector.cc
@@ -378,7 +378,7 @@ OptionalOpIndex InstructionSelectorT::Fi
// 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;
@@ -397,7 +397,7 @@ OptionalOpIndex InstructionSelectorT::Fi
// (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>());
}
}
}
@@ -2020,7 +2020,7 @@ bool InstructionSelectorT::CanDoBranchIf
// 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;
}
@@ -2035,7 +2035,7 @@ bool InstructionSelectorT::CanDoBranchIf
// 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
@@ -2438,9 +2438,9 @@ void InstructionSelectorT::TryPrepareSch
// {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
+ // 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<TupleOp>() && !IsDefined(use) &&
+ if (!this->Get(use).template Is<MakeTupleOp>() && !IsDefined(use) &&
this->block(schedule_, use) == current_block_ &&
!this->Get(use).template Is<PhiOp>()) {
return;
@@ -3801,7 +3801,7 @@ void InstructionSelectorT::VisitNode(OpI
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
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/assembler.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/assembler.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/assembler.h
@@ -956,7 +956,7 @@ class EmitProjectionReducer
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;
}
@@ -4131,22 +4131,22 @@ class TurboshaftAssemblerOpInterface
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) {
@@ -5401,7 +5401,7 @@ class Assembler : public AssemblerData,
// 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);
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/copying-phase.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/copying-phase.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/copying-phase.h
@@ -689,7 +689,7 @@ class GraphVisitor : public OutputGraphA
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)
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/fast-api-call-lowering-reducer.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/fast-api-call-lowering-reducer.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/fast-api-call-lowering-reducer.h
@@ -137,7 +137,7 @@ class FastApiCallLoweringReducer : publi
}
BIND(done, state);
- return __ Tuple(state, __ GetVariable(result));
+ return __ MakeTuple(state, __ GetVariable(result));
}
private:
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/graph.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/graph.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/graph.h
@@ -1131,7 +1131,8 @@ class Graph {
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();
}
}
@@ -1141,7 +1142,8 @@ class Graph {
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();
}
}
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/int64-lowering-reducer.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/int64-lowering-reducer.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/int64-lowering-reducer.h
@@ -169,7 +169,7 @@ class Int64LoweringReducer : public Next
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 @@ class Int64LoweringReducer : public Next
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 @@ class Int64LoweringReducer : public Next
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 @@ class Int64LoweringReducer : public Next
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 @@ class Int64LoweringReducer : public Next
}
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) {
@@ -334,7 +334,7 @@ class Int64LoweringReducer : public Next
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));
@@ -344,7 +344,7 @@ class Int64LoweringReducer : public Next
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),
@@ -419,7 +419,7 @@ class Int64LoweringReducer : public Next
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));
@@ -438,8 +438,8 @@ class Int64LoweringReducer : public Next
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);
}
@@ -449,7 +449,7 @@ class Int64LoweringReducer : public Next
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);
}
@@ -457,7 +457,8 @@ class Int64LoweringReducer : public Next
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))};
@@ -510,7 +511,7 @@ class Int64LoweringReducer : public Next
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,
@@ -595,7 +596,7 @@ class Int64LoweringReducer : public Next
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);
@@ -625,7 +626,7 @@ class Int64LoweringReducer : public Next
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) {
@@ -637,7 +638,7 @@ class Int64LoweringReducer : public Next
result = __ Word32CountLeadingZeros(high);
}
- return __ Tuple<Word32, Word32>(result, __ Word32Constant(0));
+ return __ template MakeTuple<Word32, Word32>(result, __ Word32Constant(0));
}
V<Word32Pair> LowerCtz(V<Word32Pair> input) {
@@ -650,13 +651,13 @@ class Int64LoweringReducer : public Next
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));
}
@@ -681,7 +682,7 @@ class Int64LoweringReducer : public Next
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) {
@@ -689,7 +690,7 @@ class Int64LoweringReducer : public Next
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) {
@@ -697,7 +698,7 @@ class Int64LoweringReducer : public Next
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) {
@@ -716,7 +717,7 @@ class Int64LoweringReducer : public Next
}
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;
@@ -736,7 +737,7 @@ class Int64LoweringReducer : public Next
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;
@@ -769,7 +770,7 @@ class Int64LoweringReducer : public Next
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,
@@ -853,7 +854,7 @@ class Int64LoweringReducer : public Next
// 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))
//
@@ -869,8 +870,8 @@ class Int64LoweringReducer : public Next
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(
@@ -879,7 +880,7 @@ class Int64LoweringReducer : public Next
}
}
DCHECK_EQ(projection_index, return_count + i64_returns);
- return __ Tuple(base::VectorOf(tuple_inputs));
+ return __ MakeTuple(base::VectorOf(tuple_inputs));
}
void InitializeIndexMaps() {
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/machine-optimization-reducer.h
@@ -1291,7 +1291,8 @@ class MachineOptimizationReducer : publi
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());
@@ -1310,7 +1311,8 @@ class MachineOptimizationReducer : publi
overflow = base::bits::SignedSubOverflow64(k1, k2, &res);
break;
}
- return __ Tuple(__ Word64Constant(res), __ Word32Constant(overflow));
+ return __ MakeTuple(__ Word64Constant(res),
+ __ Word32Constant(overflow));
}
}
@@ -1318,18 +1320,19 @@ class MachineOptimizationReducer : publi
// 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) {
@@ -1349,7 +1352,7 @@ class MachineOptimizationReducer : publi
if (V<Word32> x; matcher_.MatchConstantShiftRightArithmeticShiftOutZeros(
left, &x, WordRepresentation::Word32(), &amount) &&
amount == 1) {
- return __ Tuple(x, __ Word32Constant(0));
+ return __ MakeTuple(x, __ Word32Constant(0));
}
}
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/operations.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/operations.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/operations.h
@@ -324,7 +324,7 @@ using Variable = SnapshotTable<OpIndex,
V(Call) \
V(CatchBlockBegin) \
V(DidntThrow) \
- V(Tuple) \
+ V(MakeTuple) \
V(Projection) \
V(DebugBreak) \
V(AssumeMap) \
@@ -4524,8 +4524,8 @@ V8_EXPORT_PRIVATE base::SmallVector<Bloc
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 {}; }
@@ -4534,7 +4534,7 @@ struct TupleOp : OperationT<TupleOp> {
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 {
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/turbolev-graph-builder.cc
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/turbolev-graph-builder.cc
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/turbolev-graph-builder.cc
@@ -5831,7 +5831,7 @@ class GraphBuildingNodeProcessor {
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
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/type-inference-analysis.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/type-inference-analysis.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/type-inference-analysis.h
@@ -158,7 +158,7 @@ class TypeInferenceAnalysis {
case Opcode::kRetain:
case Opcode::kUnreachable:
case Opcode::kSwitch:
- case Opcode::kTuple:
+ case Opcode::kMakeTuple:
case Opcode::kStaticAssert:
case Opcode::kDebugBreak:
case Opcode::kDebugPrint:
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/type-inference-reducer.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/type-inference-reducer.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/type-inference-reducer.h
@@ -445,7 +445,7 @@ class TypeInferenceReducer
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 @@ class TypeInferenceReducer
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());
Index: node-v24.11.1/deps/v8/src/compiler/turboshaft/wasm-lowering-reducer.h
===================================================================
--- node-v24.11.1.orig/deps/v8/src/compiler/turboshaft/wasm-lowering-reducer.h
+++ node-v24.11.1/deps/v8/src/compiler/turboshaft/wasm-lowering-reducer.h
@@ -520,7 +520,7 @@ class WasmLoweringReducer : public Next
}
{
BIND(done, base, final_offset, charwidth_shift);
- return __ Tuple({base, final_offset, charwidth_shift});
+ return __ MakeTuple({base, final_offset, charwidth_shift});
}
}
Reference in New Issue View Git Blame Copy Permalink