diff --git a/src/compiler/change-lowering-unittest.cc b/src/compiler/change-lowering-unittest.cc index f9229f6168..cad2609912 100644 --- a/src/compiler/change-lowering-unittest.cc +++ b/src/compiler/change-lowering-unittest.cc @@ -130,7 +130,7 @@ TARGET_TEST_P(ChangeLoweringCommonTest, ChangeBitToBool) { Node* phi = reduction.replacement(); Capture branch; EXPECT_THAT(phi, - IsPhi(IsTrueConstant(), IsFalseConstant(), + IsPhi(kMachAnyTagged, IsTrueConstant(), IsFalseConstant(), IsMerge(IsIfTrue(AllOf(CaptureEq(&branch), IsBranch(val, graph()->start()))), IsIfFalse(CaptureEq(&branch))))); @@ -201,7 +201,8 @@ TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) { Capture add, branch, heap_number, if_true; EXPECT_THAT( phi, - IsPhi(IsFinish( + IsPhi(kMachAnyTagged, + IsFinish( AllOf(CaptureEq(&heap_number), IsAllocateHeapNumber(_, CaptureEq(&if_true))), IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number), @@ -231,6 +232,7 @@ TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToFloat64) { EXPECT_THAT( phi, IsPhi( + kMachFloat64, IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true))), IsChangeInt32ToFloat64( @@ -258,7 +260,8 @@ TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToInt32) { Capture branch, if_true; EXPECT_THAT( phi, - IsPhi(IsChangeFloat64ToInt32(IsLoad( + IsPhi(kMachInt32, + IsChangeFloat64ToInt32(IsLoad( kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true)))), IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())), @@ -283,7 +286,8 @@ TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToUint32) { Capture branch, if_true; EXPECT_THAT( phi, - IsPhi(IsChangeFloat64ToUint32(IsLoad( + IsPhi(kMachUint32, + IsChangeFloat64ToUint32(IsLoad( kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true)))), IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())), @@ -309,7 +313,7 @@ TARGET_TEST_F(ChangeLowering32Test, ChangeUint32ToTagged) { EXPECT_THAT( phi, IsPhi( - IsWord32Shl(val, IsInt32Constant(SmiShiftAmount())), + kMachAnyTagged, IsWord32Shl(val, IsInt32Constant(SmiShiftAmount())), IsFinish( AllOf(CaptureEq(&heap_number), IsAllocateHeapNumber(_, CaptureEq(&if_false))), @@ -365,6 +369,7 @@ TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToFloat64) { EXPECT_THAT( phi, IsPhi( + kMachFloat64, IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true))), IsChangeInt32ToFloat64(IsTruncateInt64ToInt32( @@ -392,7 +397,8 @@ TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToInt32) { Capture branch, if_true; EXPECT_THAT( phi, - IsPhi(IsChangeFloat64ToInt32(IsLoad( + IsPhi(kMachInt32, + IsChangeFloat64ToInt32(IsLoad( kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true)))), IsTruncateInt64ToInt32( @@ -418,7 +424,8 @@ TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToUint32) { Capture branch, if_true; EXPECT_THAT( phi, - IsPhi(IsChangeFloat64ToUint32(IsLoad( + IsPhi(kMachUint32, + IsChangeFloat64ToUint32(IsLoad( kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()), IsControlEffect(CaptureEq(&if_true)))), IsTruncateInt64ToInt32( @@ -445,8 +452,8 @@ TARGET_TEST_F(ChangeLowering64Test, ChangeUint32ToTagged) { EXPECT_THAT( phi, IsPhi( - IsWord64Shl(IsChangeUint32ToUint64(val), - IsInt32Constant(SmiShiftAmount())), + kMachAnyTagged, IsWord64Shl(IsChangeUint32ToUint64(val), + IsInt32Constant(SmiShiftAmount())), IsFinish( AllOf(CaptureEq(&heap_number), IsAllocateHeapNumber(_, CaptureEq(&if_false))), diff --git a/src/compiler/change-lowering.cc b/src/compiler/change-lowering.cc index e9fd7400d0..f3d732b063 100644 --- a/src/compiler/change-lowering.cc +++ b/src/compiler/change-lowering.cc @@ -111,8 +111,9 @@ Reduction ChangeLowering::ChangeBitToBool(Node* val, Node* control) { Node* false_value = jsgraph()->FalseConstant(); Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); - Node* phi = - graph()->NewNode(common()->Phi(2), true_value, false_value, merge); + Node* phi = graph()->NewNode( + common()->Phi(static_cast(kTypeBool | kRepTagged), 2), + true_value, false_value, merge); return Replace(phi); } @@ -150,7 +151,8 @@ Reduction ChangeLowering::ChangeInt32ToTagged(Node* val, Node* control) { Node* smi = graph()->NewNode(common()->Projection(0), add); Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); - Node* phi = graph()->NewNode(common()->Phi(2), heap_number, smi, merge); + Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), heap_number, + smi, merge); return Replace(phi); } @@ -174,7 +176,9 @@ Reduction ChangeLowering::ChangeTaggedToUI32(Node* val, Node* control, Node* number = ChangeSmiToInt32(val); Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); - Node* phi = graph()->NewNode(common()->Phi(2), change, number, merge); + Node* phi = graph()->NewNode( + common()->Phi((signedness == kSigned) ? kMachInt32 : kMachUint32, 2), + change, number, merge); return Replace(phi); } @@ -196,7 +200,8 @@ Reduction ChangeLowering::ChangeTaggedToFloat64(Node* val, Node* control) { ChangeSmiToInt32(val)); Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); - Node* phi = graph()->NewNode(common()->Phi(2), load, number, merge); + Node* phi = + graph()->NewNode(common()->Phi(kMachFloat64, 2), load, number, merge); return Replace(phi); } @@ -223,7 +228,8 @@ Reduction ChangeLowering::ChangeUint32ToTagged(Node* val, Node* control) { graph()->NewNode(machine()->ChangeUint32ToFloat64(), val), if_false); Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false); - Node* phi = graph()->NewNode(common()->Phi(2), smi, heap_number, merge); + Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), smi, + heap_number, merge); return Replace(phi); } diff --git a/src/compiler/common-operator.h b/src/compiler/common-operator.h index cc447ee8f4..d871fb781e 100644 --- a/src/compiler/common-operator.h +++ b/src/compiler/common-operator.h @@ -5,10 +5,9 @@ #ifndef V8_COMPILER_COMMON_OPERATOR_H_ #define V8_COMPILER_COMMON_OPERATOR_H_ -#include "src/v8.h" - #include "src/assembler.h" #include "src/compiler/linkage.h" +#include "src/compiler/machine-type.h" #include "src/compiler/opcodes.h" #include "src/compiler/operator.h" #include "src/unique.h" @@ -142,10 +141,10 @@ class CommonOperatorBuilder { return new (zone_) Operator1 >( IrOpcode::kHeapConstant, Operator::kPure, 0, 1, "HeapConstant", value); } - Operator* Phi(int arguments) { + Operator* Phi(MachineType type, int arguments) { DCHECK(arguments > 0); // Disallow empty phis. - return new (zone_) Operator1(IrOpcode::kPhi, Operator::kPure, - arguments, 1, "Phi", arguments); + return new (zone_) Operator1(IrOpcode::kPhi, Operator::kPure, + arguments, 1, "Phi", type); } Operator* EffectPhi(int arguments) { DCHECK(arguments > 0); // Disallow empty phis. diff --git a/src/compiler/graph-builder.cc b/src/compiler/graph-builder.cc index f763a6eaac..9f23321ed9 100644 --- a/src/compiler/graph-builder.cc +++ b/src/compiler/graph-builder.cc @@ -161,7 +161,7 @@ void StructuredGraphBuilder::Environment::PrepareForLoop() { Node* StructuredGraphBuilder::NewPhi(int count, Node* input, Node* control) { - Operator* phi_op = common()->Phi(count); + Operator* phi_op = common()->Phi(kMachAnyTagged, count); Node** buffer = zone()->NewArray(count + 1); MemsetPointer(buffer, input, count); buffer[count] = control; @@ -224,7 +224,7 @@ Node* StructuredGraphBuilder::MergeValue(Node* value, Node* other, if (value->opcode() == IrOpcode::kPhi && NodeProperties::GetControlInput(value) == control) { // Phi already exists, add input. - value->set_op(common()->Phi(inputs)); + value->set_op(common()->Phi(kMachAnyTagged, inputs)); value->InsertInput(zone(), inputs - 1, other); } else if (value != other) { // Phi does not exist yet, introduce one. diff --git a/src/compiler/graph-unittest.cc b/src/compiler/graph-unittest.cc index 2af9065e00..5be2ec5408 100644 --- a/src/compiler/graph-unittest.cc +++ b/src/compiler/graph-unittest.cc @@ -285,17 +285,21 @@ class IsConstantMatcher FINAL : public NodeMatcher { class IsPhiMatcher FINAL : public NodeMatcher { public: - IsPhiMatcher(const Matcher& value0_matcher, + IsPhiMatcher(const Matcher& type_matcher, + const Matcher& value0_matcher, const Matcher& value1_matcher, const Matcher& control_matcher) : NodeMatcher(IrOpcode::kPhi), + type_matcher_(type_matcher), value0_matcher_(value0_matcher), value1_matcher_(value1_matcher), control_matcher_(control_matcher) {} virtual void DescribeTo(std::ostream* os) const OVERRIDE { NodeMatcher::DescribeTo(os); - *os << " whose value0 ("; + *os << " whose type ("; + type_matcher_.DescribeTo(os); + *os << "), value0 ("; value0_matcher_.DescribeTo(os); *os << "), value1 ("; value1_matcher_.DescribeTo(os); @@ -307,6 +311,8 @@ class IsPhiMatcher FINAL : public NodeMatcher { virtual bool MatchAndExplain(Node* node, MatchResultListener* listener) const OVERRIDE { return (NodeMatcher::MatchAndExplain(node, listener) && + PrintMatchAndExplain(OpParameter(node), "type", + type_matcher_, listener) && PrintMatchAndExplain(NodeProperties::GetValueInput(node, 0), "value0", value0_matcher_, listener) && PrintMatchAndExplain(NodeProperties::GetValueInput(node, 1), @@ -316,6 +322,7 @@ class IsPhiMatcher FINAL : public NodeMatcher { } private: + const Matcher type_matcher_; const Matcher value0_matcher_; const Matcher value1_matcher_; const Matcher control_matcher_; @@ -669,11 +676,12 @@ Matcher IsNumberConstant(const Matcher& value_matcher) { } -Matcher IsPhi(const Matcher& value0_matcher, +Matcher IsPhi(const Matcher& type_matcher, + const Matcher& value0_matcher, const Matcher& value1_matcher, const Matcher& merge_matcher) { - return MakeMatcher( - new IsPhiMatcher(value0_matcher, value1_matcher, merge_matcher)); + return MakeMatcher(new IsPhiMatcher(type_matcher, value0_matcher, + value1_matcher, merge_matcher)); } diff --git a/src/compiler/graph-unittest.h b/src/compiler/graph-unittest.h index 3ff7cacb33..90266f642b 100644 --- a/src/compiler/graph-unittest.h +++ b/src/compiler/graph-unittest.h @@ -69,7 +69,8 @@ Matcher IsFloat64Constant(const Matcher& value_matcher); Matcher IsInt32Constant(const Matcher& value_matcher); Matcher IsInt64Constant(const Matcher& value_matcher); Matcher IsNumberConstant(const Matcher& value_matcher); -Matcher IsPhi(const Matcher& value0_matcher, +Matcher IsPhi(const Matcher& type_matcher, + const Matcher& value0_matcher, const Matcher& value1_matcher, const Matcher& merge_matcher); Matcher IsProjection(const Matcher& index_matcher, diff --git a/src/compiler/instruction-selector-unittest.cc b/src/compiler/instruction-selector-unittest.cc index cc67567d83..f987e0f16c 100644 --- a/src/compiler/instruction-selector-unittest.cc +++ b/src/compiler/instruction-selector-unittest.cc @@ -182,7 +182,7 @@ TARGET_TEST_F(InstructionSelectorTest, ReferenceParameter) { // Finish. -TARGET_TEST_F(InstructionSelectorTest, Parameter) { +TARGET_TEST_F(InstructionSelectorTest, Finish) { StreamBuilder m(this, kMachAnyTagged, kMachAnyTagged); Node* param = m.Parameter(0); Node* finish = m.NewNode(m.common()->Finish(1), param, m.graph()->start()); @@ -201,6 +201,7 @@ TARGET_TEST_F(InstructionSelectorTest, Parameter) { ASSERT_TRUE(s[1]->Output()->IsUnallocated()); EXPECT_TRUE(UnallocatedOperand::cast(s[1]->Output())->HasSameAsInputPolicy()); EXPECT_EQ(finish->id(), s.ToVreg(s[1]->Output())); + EXPECT_TRUE(s.IsReference(finish->id())); } @@ -212,7 +213,7 @@ typedef InstructionSelectorTestWithParam InstructionSelectorPhiTest; -TARGET_TEST_P(InstructionSelectorPhiTest, PropagateDoubleness) { +TARGET_TEST_P(InstructionSelectorPhiTest, Doubleness) { const MachineType type = GetParam(); StreamBuilder m(this, type, type, type); Node* param0 = m.Parameter(0); @@ -224,7 +225,7 @@ TARGET_TEST_P(InstructionSelectorPhiTest, PropagateDoubleness) { m.Bind(&b); m.Goto(&c); m.Bind(&c); - Node* phi = m.Phi(param0, param1); + Node* phi = m.Phi(type, param0, param1); m.Return(phi); Stream s = m.Build(kAllInstructions); EXPECT_EQ(s.IsDouble(phi->id()), s.IsDouble(param0->id())); @@ -232,7 +233,7 @@ TARGET_TEST_P(InstructionSelectorPhiTest, PropagateDoubleness) { } -TARGET_TEST_P(InstructionSelectorPhiTest, PropagateReferenceness) { +TARGET_TEST_P(InstructionSelectorPhiTest, Referenceness) { const MachineType type = GetParam(); StreamBuilder m(this, type, type, type); Node* param0 = m.Parameter(0); @@ -244,7 +245,7 @@ TARGET_TEST_P(InstructionSelectorPhiTest, PropagateReferenceness) { m.Bind(&b); m.Goto(&c); m.Bind(&c); - Node* phi = m.Phi(param0, param1); + Node* phi = m.Phi(type, param0, param1); m.Return(phi); Stream s = m.Build(kAllInstructions); EXPECT_EQ(s.IsReference(phi->id()), s.IsReference(param0->id())); diff --git a/src/compiler/instruction-selector.cc b/src/compiler/instruction-selector.cc index 4b5552d9e7..2e0b29c05b 100644 --- a/src/compiler/instruction-selector.cc +++ b/src/compiler/instruction-selector.cc @@ -198,19 +198,6 @@ void InstructionSelector::MarkAsDouble(Node* node) { DCHECK_NOT_NULL(node); DCHECK(!IsReference(node)); sequence()->MarkAsDouble(node->id()); - - // Propagate "doubleness" throughout Phi nodes. - for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) { - Node* user = *i; - switch (user->opcode()) { - case IrOpcode::kPhi: - if (IsDouble(user)) continue; - MarkAsDouble(user); - break; - default: - break; - } - } } @@ -224,19 +211,6 @@ void InstructionSelector::MarkAsReference(Node* node) { DCHECK_NOT_NULL(node); DCHECK(!IsDouble(node)); sequence()->MarkAsReference(node->id()); - - // Propagate "referenceness" throughout Phi nodes. - for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) { - Node* user = *i; - switch (user->opcode()) { - case IrOpcode::kPhi: - if (IsReference(user)) continue; - MarkAsReference(user); - break; - default: - break; - } - } } @@ -491,8 +465,11 @@ void InstructionSelector::VisitNode(Node* node) { MarkAsRepresentation(type, node); return VisitParameter(node); } - case IrOpcode::kPhi: + case IrOpcode::kPhi: { + MachineType type = OpParameter(node); + MarkAsRepresentation(type, node); return VisitPhi(node); + } case IrOpcode::kProjection: return VisitProjection(node); case IrOpcode::kInt32Constant: @@ -845,10 +822,10 @@ void InstructionSelector::VisitProjection(Node* node) { switch (value->opcode()) { case IrOpcode::kInt32AddWithOverflow: case IrOpcode::kInt32SubWithOverflow: - if (OpParameter(node) == 0) { + if (OpParameter(node) == 0) { Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value)); } else { - DCHECK_EQ(1, OpParameter(node)); + DCHECK_EQ(1, OpParameter(node)); MarkAsUsed(value); } break; @@ -956,7 +933,7 @@ void InstructionSelector::VisitBranch(Node* branch, BasicBlock* tbranch, case IrOpcode::kProjection: // Check if this is the overflow output projection of an // WithOverflow node. - if (OpParameter(value) == 1) { + if (OpParameter(value) == 1) { // We cannot combine the WithOverflow with this branch // unless the 0th projection (the use of the actual value of the // is either NULL, which means there's no use of the diff --git a/src/compiler/js-inlining.cc b/src/compiler/js-inlining.cc index d9551484be..655a4b0aa5 100644 --- a/src/compiler/js-inlining.cc +++ b/src/compiler/js-inlining.cc @@ -120,7 +120,7 @@ void Inlinee::UnifyReturn() { int predecessors = OperatorProperties::GetControlInputCount(final_merge->op()); - Operator* op_phi = jsgraph_->common()->Phi(predecessors); + Operator* op_phi = jsgraph_->common()->Phi(kMachAnyTagged, predecessors); Operator* op_ephi = jsgraph_->common()->EffectPhi(predecessors); NodeVector values(jsgraph_->zone()); diff --git a/src/compiler/raw-machine-assembler.h b/src/compiler/raw-machine-assembler.h index 2fd1a006d4..a74253ada0 100644 --- a/src/compiler/raw-machine-assembler.h +++ b/src/compiler/raw-machine-assembler.h @@ -409,12 +409,14 @@ class RawMachineAssembler : public GraphBuilder { void Deoptimize(Node* state); // Variables. - Node* Phi(Node* n1, Node* n2) { return NewNode(common()->Phi(2), n1, n2); } - Node* Phi(Node* n1, Node* n2, Node* n3) { - return NewNode(common()->Phi(3), n1, n2, n3); + Node* Phi(MachineType type, Node* n1, Node* n2) { + return NewNode(common()->Phi(type, 2), n1, n2); } - Node* Phi(Node* n1, Node* n2, Node* n3, Node* n4) { - return NewNode(common()->Phi(4), n1, n2, n3, n4); + Node* Phi(MachineType type, Node* n1, Node* n2, Node* n3) { + return NewNode(common()->Phi(type, 3), n1, n2, n3); + } + Node* Phi(MachineType type, Node* n1, Node* n2, Node* n3, Node* n4) { + return NewNode(common()->Phi(type, 4), n1, n2, n3, n4); } // MachineAssembler is invalid after export. diff --git a/src/compiler/simplified-lowering.cc b/src/compiler/simplified-lowering.cc index 960c93aaba..a635f98314 100644 --- a/src/compiler/simplified-lowering.cc +++ b/src/compiler/simplified-lowering.cc @@ -267,7 +267,8 @@ class RepresentationSelector { void VisitUint64Cmp(Node* node) { VisitBinop(node, kMachUint64, kRepBit); } // Helper for handling phis. - void VisitPhi(Node* node, MachineTypeUnion use) { + void VisitPhi(Node* node, MachineTypeUnion use, + SimplifiedLowering* lowering) { // First, propagate the usage information to inputs of the phi. if (!lower()) { int values = OperatorProperties::GetValueInputCount(node->op()); @@ -318,6 +319,13 @@ class RepresentationSelector { if (lower()) { int values = OperatorProperties::GetValueInputCount(node->op()); + + // Update the phi operator. + MachineType type = static_cast(output_type); + if (type != OpParameter(node)) { + node->set_op(lowering->common()->Phi(type, values)); + } + // Convert inputs to the output representation of this phi. Node::Inputs inputs = node->inputs(); for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end(); @@ -384,7 +392,7 @@ class RepresentationSelector { Enqueue(NodeProperties::GetControlInput(node, 0)); break; case IrOpcode::kPhi: - return VisitPhi(node, use); + return VisitPhi(node, use, lowering); //------------------------------------------------------------------ // JavaScript operators. diff --git a/test/cctest/compiler/test-phi-reducer.cc b/test/cctest/compiler/test-phi-reducer.cc index a0550f061f..7d2fab6727 100644 --- a/test/cctest/compiler/test-phi-reducer.cc +++ b/test/cctest/compiler/test-phi-reducer.cc @@ -53,27 +53,32 @@ class PhiReducerTester : HandleAndZoneScope { } Node* Phi(Node* a) { - return SetSelfReferences(graph.NewNode(common.Phi(1), a)); + return SetSelfReferences(graph.NewNode(common.Phi(kMachAnyTagged, 1), a)); } Node* Phi(Node* a, Node* b) { - return SetSelfReferences(graph.NewNode(common.Phi(2), a, b)); + return SetSelfReferences( + graph.NewNode(common.Phi(kMachAnyTagged, 2), a, b)); } Node* Phi(Node* a, Node* b, Node* c) { - return SetSelfReferences(graph.NewNode(common.Phi(3), a, b, c)); + return SetSelfReferences( + graph.NewNode(common.Phi(kMachAnyTagged, 3), a, b, c)); } Node* Phi(Node* a, Node* b, Node* c, Node* d) { - return SetSelfReferences(graph.NewNode(common.Phi(4), a, b, c, d)); + return SetSelfReferences( + graph.NewNode(common.Phi(kMachAnyTagged, 4), a, b, c, d)); } Node* PhiWithControl(Node* a, Node* control) { - return SetSelfReferences(graph.NewNode(common.Phi(1), a, control)); + return SetSelfReferences( + graph.NewNode(common.Phi(kMachAnyTagged, 1), a, control)); } Node* PhiWithControl(Node* a, Node* b, Node* control) { - return SetSelfReferences(graph.NewNode(common.Phi(2), a, b, control)); + return SetSelfReferences( + graph.NewNode(common.Phi(kMachAnyTagged, 2), a, b, control)); } Node* SetSelfReferences(Node* node) { diff --git a/test/cctest/compiler/test-run-machops.cc b/test/cctest/compiler/test-run-machops.cc index f0555b55c5..4841bbb1b6 100644 --- a/test/cctest/compiler/test-run-machops.cc +++ b/test/cctest/compiler/test-run-machops.cc @@ -209,7 +209,8 @@ TEST(RunLoop) { template static void BuildDiamondPhi(RawMachineAssemblerTester* m, Node* cond_node, - Node* true_node, Node* false_node) { + MachineType type, Node* true_node, + Node* false_node) { MLabel blocka, blockb; MLabel* end = m->Exit(); m->Branch(cond_node, &blocka, &blockb); @@ -219,7 +220,7 @@ static void BuildDiamondPhi(RawMachineAssemblerTester* m, Node* cond_node, m->Goto(end); m->Bind(end); - Node* phi = m->Phi(true_node, false_node); + Node* phi = m->Phi(type, true_node, false_node); m->Return(phi); } @@ -230,7 +231,7 @@ TEST(RunDiamondPhiConst) { int true_val = 0x00DDD; Node* true_node = m.Int32Constant(true_val); Node* false_node = m.Int32Constant(false_val); - BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node); + BuildDiamondPhi(&m, m.Parameter(0), kMachInt32, true_node, false_node); CHECK_EQ(false_val, m.Call(0)); CHECK_EQ(true_val, m.Call(1)); } @@ -242,7 +243,7 @@ TEST(RunDiamondPhiNumber) { double true_val = 200.1; Node* true_node = m.NumberConstant(true_val); Node* false_node = m.NumberConstant(false_val); - BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node); + BuildDiamondPhi(&m, m.Parameter(0), kMachAnyTagged, true_node, false_node); m.CheckNumber(false_val, m.Call(0)); m.CheckNumber(true_val, m.Call(1)); } @@ -254,7 +255,7 @@ TEST(RunDiamondPhiString) { const char* true_val = "true"; Node* true_node = m.StringConstant(true_val); Node* false_node = m.StringConstant(false_val); - BuildDiamondPhi(&m, m.Parameter(0), true_node, false_node); + BuildDiamondPhi(&m, m.Parameter(0), kMachAnyTagged, true_node, false_node); m.CheckString(false_val, m.Call(0)); m.CheckString(true_val, m.Call(1)); } @@ -262,7 +263,8 @@ TEST(RunDiamondPhiString) { TEST(RunDiamondPhiParam) { RawMachineAssemblerTester m(kMachInt32, kMachInt32, kMachInt32); - BuildDiamondPhi(&m, m.Parameter(0), m.Parameter(1), m.Parameter(2)); + BuildDiamondPhi(&m, m.Parameter(0), kMachInt32, m.Parameter(1), + m.Parameter(2)); int32_t c1 = 0x260cb75a; int32_t c2 = 0xcd3e9c8b; int result = m.Call(0, c1, c2); @@ -287,7 +289,7 @@ TEST(RunLoopPhiConst) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(false_node, true_node); + Node* phi = m.Phi(kMachInt32, false_node, true_node); m.Branch(cond_node, &body, end); m.Bind(&body); m.Goto(&header); @@ -307,8 +309,8 @@ TEST(RunLoopPhiParam) { m.Goto(&blocka); m.Bind(&blocka); - Node* phi = m.Phi(m.Parameter(1), m.Parameter(2)); - Node* cond = m.Phi(m.Parameter(0), m.Int32Constant(0)); + Node* phi = m.Phi(kMachInt32, m.Parameter(1), m.Parameter(2)); + Node* cond = m.Phi(kMachInt32, m.Parameter(0), m.Int32Constant(0)); m.Branch(cond, &blockb, end); m.Bind(&blockb); @@ -339,7 +341,7 @@ TEST(RunLoopPhiInduction) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(false_node, false_node); + Node* phi = m.Phi(kMachInt32, false_node, false_node); m.Branch(m.Int32Constant(0), &body, end); m.Bind(&body); @@ -366,7 +368,7 @@ TEST(RunLoopIncrement) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(zero, zero); + Node* phi = m.Phi(kMachInt32, zero, zero); m.Branch(m.WordXor(phi, bt.param0), &body, end); m.Bind(&body); @@ -394,7 +396,7 @@ TEST(RunLoopIncrement2) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(zero, zero); + Node* phi = m.Phi(kMachInt32, zero, zero); m.Branch(m.Int32LessThan(phi, bt.param0), &body, end); m.Bind(&body); @@ -423,7 +425,7 @@ TEST(RunLoopIncrement3) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(zero, zero); + Node* phi = m.Phi(kMachInt32, zero, zero); m.Branch(m.Uint32LessThan(phi, bt.param0), &body, end); m.Bind(&body); @@ -451,7 +453,7 @@ TEST(RunLoopDecrement) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(bt.param0, m.Int32Constant(0)); + Node* phi = m.Phi(kMachInt32, bt.param0, m.Int32Constant(0)); m.Branch(phi, &body, end); m.Bind(&body); @@ -479,7 +481,7 @@ TEST(RunLoopIncrementFloat64) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(minus_3, ten); + Node* phi = m.Phi(kMachFloat64, minus_3, ten); m.Branch(m.Float64LessThan(phi, ten), &body, end); m.Bind(&body); @@ -3251,7 +3253,7 @@ TEST(RunLoopPhiInduction2) { Node* false_node = m.Int32Constant(false_val); m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(false_node, false_node); + Node* phi = m.Phi(kMachInt32, false_node, false_node); m.Branch(m.Int32Constant(0), &body, &end); m.Bind(&body); Node* add = m.Int32Add(phi, m.Int32Constant(1)); @@ -3280,7 +3282,7 @@ TEST(RunDoubleDiamond) { m.Bind(&blockb); m.Goto(&end); m.Bind(&end); - Node* phi = m.Phi(k2, k1); + Node* phi = m.Phi(kMachFloat64, k2, k1); m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi); m.Return(m.Int32Constant(magic)); @@ -3306,7 +3308,7 @@ TEST(RunRefDiamond) { m.Bind(&blockb); m.Goto(&end); m.Bind(&end); - Node* phi = m.Phi(k2, k1); + Node* phi = m.Phi(kMachAnyTagged, k2, k1); m.Store(kMachAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi); m.Return(m.Int32Constant(magic)); @@ -3336,8 +3338,8 @@ TEST(RunDoubleRefDiamond) { m.Bind(&blockb); m.Goto(&end); m.Bind(&end); - Node* dphi = m.Phi(d2, d1); - Node* rphi = m.Phi(r2, r1); + Node* dphi = m.Phi(kMachFloat64, d2, d1); + Node* rphi = m.Phi(kMachAnyTagged, r2, r1); m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi); m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0), rphi); @@ -3370,8 +3372,8 @@ TEST(RunDoubleRefDoubleDiamond) { m.Bind(&blockb); m.Goto(&mid); m.Bind(&mid); - Node* dphi1 = m.Phi(d2, d1); - Node* rphi1 = m.Phi(r2, r1); + Node* dphi1 = m.Phi(kMachFloat64, d2, d1); + Node* rphi1 = m.Phi(kMachAnyTagged, r2, r1); m.Branch(m.Int32Constant(0), &blockd, &blocke); m.Bind(&blockd); @@ -3379,8 +3381,8 @@ TEST(RunDoubleRefDoubleDiamond) { m.Bind(&blocke); m.Goto(&end); m.Bind(&end); - Node* dphi2 = m.Phi(d1, dphi1); - Node* rphi2 = m.Phi(r1, rphi1); + Node* dphi2 = m.Phi(kMachFloat64, d1, dphi1); + Node* rphi2 = m.Phi(kMachAnyTagged, r1, rphi1); m.Store(kMachFloat64, m.PointerConstant(&dbuffer), m.Int32Constant(0), dphi2); m.Store(kMachAnyTagged, m.PointerConstant(&rbuffer), m.Int32Constant(0), @@ -3406,7 +3408,7 @@ TEST(RunDoubleLoopPhi) { m.Goto(&header); m.Bind(&header); - Node* phi = m.Phi(dk, dk); + Node* phi = m.Phi(kMachFloat64, dk, dk); phi->ReplaceInput(1, phi); m.Branch(zero, &body, &end); m.Bind(&body); @@ -3431,8 +3433,8 @@ TEST(RunCountToTenAccRaw) { m.Goto(&header); m.Bind(&header); - Node* i = m.Phi(zero, zero); - Node* j = m.Phi(zero, zero); + Node* i = m.Phi(kMachInt32, zero, zero); + Node* j = m.Phi(kMachInt32, zero, zero); m.Goto(&body); m.Bind(&body); @@ -3464,9 +3466,9 @@ TEST(RunCountToTenAccRaw2) { m.Goto(&header); m.Bind(&header); - Node* i = m.Phi(zero, zero); - Node* j = m.Phi(zero, zero); - Node* k = m.Phi(zero, zero); + Node* i = m.Phi(kMachInt32, zero, zero); + Node* j = m.Phi(kMachInt32, zero, zero); + Node* k = m.Phi(kMachInt32, zero, zero); m.Goto(&body); m.Bind(&body); @@ -3973,7 +3975,7 @@ TEST(RunNewSpaceConstantsInPhi) { m.Goto(&end); m.Bind(&end); - Node* phi = m.Phi(true_node, false_node); + Node* phi = m.Phi(kMachAnyTagged, true_node, false_node); m.Return(phi); CHECK_EQ(*false_val, m.Call(0)); diff --git a/test/cctest/compiler/test-scheduler.cc b/test/cctest/compiler/test-scheduler.cc index 34dfad815b..bd7ffc9d1b 100644 --- a/test/cctest/compiler/test-scheduler.cc +++ b/test/cctest/compiler/test-scheduler.cc @@ -844,7 +844,7 @@ TEST(BuildScheduleSimpleLoop) { op = common_builder.Return(); Node* n19 = graph.NewNode(op, nil, nil, nil); USE(n19); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n8 = graph.NewNode(op, nil, nil, nil); USE(n8); op = common_builder.Parameter(0); @@ -866,7 +866,7 @@ TEST(BuildScheduleSimpleLoop) { Node* n12 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n12); n12->ReplaceInput(0, n8); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n9 = graph.NewNode(op, nil, nil, nil); USE(n9); op = common_builder.Parameter(0); @@ -891,7 +891,7 @@ TEST(BuildScheduleSimpleLoop) { n9->ReplaceInput(2, n6); n12->ReplaceInput(1, n9); n12->ReplaceInput(2, n5); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n10 = graph.NewNode(op, nil, nil, nil); USE(n10); n10->ReplaceInput(0, n0); @@ -962,17 +962,17 @@ TEST(BuildScheduleComplexLoops) { op = common_builder.Return(); Node* n45 = graph.NewNode(op, nil, nil, nil); USE(n45); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n35 = graph.NewNode(op, nil, nil, nil); USE(n35); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n9 = graph.NewNode(op, nil, nil, nil); USE(n9); op = common_builder.Parameter(0); Node* n2 = graph.NewNode(op, n0); USE(n2); n9->ReplaceInput(0, n2); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n23 = graph.NewNode(op, nil, nil, nil); USE(n23); op = js_builder.Add(); @@ -990,14 +990,14 @@ TEST(BuildScheduleComplexLoops) { Node* n14 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n14); n14->ReplaceInput(0, n9); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n10 = graph.NewNode(op, nil, nil, nil); USE(n10); op = common_builder.Parameter(0); Node* n3 = graph.NewNode(op, n0); USE(n3); n10->ReplaceInput(0, n3); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n24 = graph.NewNode(op, nil, nil, nil); USE(n24); n24->ReplaceInput(0, n10); @@ -1025,10 +1025,10 @@ TEST(BuildScheduleComplexLoops) { op = js_builder.LessThan(); Node* n27 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n27); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n25 = graph.NewNode(op, nil, nil, nil); USE(n25); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n11 = graph.NewNode(op, nil, nil, nil); USE(n11); op = common_builder.Parameter(0); @@ -1065,7 +1065,7 @@ TEST(BuildScheduleComplexLoops) { n27->ReplaceInput(0, n25); n27->ReplaceInput(1, n24); n27->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n26 = graph.NewNode(op, nil, nil, nil); USE(n26); n26->ReplaceInput(0, n20); @@ -1086,7 +1086,7 @@ TEST(BuildScheduleComplexLoops) { n10->ReplaceInput(2, n7); n14->ReplaceInput(1, n10); n14->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n12 = graph.NewNode(op, nil, nil, nil); USE(n12); n12->ReplaceInput(0, n0); @@ -1120,7 +1120,7 @@ TEST(BuildScheduleComplexLoops) { Node* n39 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n39); n39->ReplaceInput(0, n35); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n36 = graph.NewNode(op, nil, nil, nil); USE(n36); n36->ReplaceInput(0, n10); @@ -1146,7 +1146,7 @@ TEST(BuildScheduleComplexLoops) { n36->ReplaceInput(2, n33); n39->ReplaceInput(1, n36); n39->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n38 = graph.NewNode(op, nil, nil, nil); USE(n38); n38->ReplaceInput(0, n14); @@ -1214,14 +1214,14 @@ TEST(BuildScheduleBreakAndContinue) { op = js_builder.Add(); Node* n56 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n56); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n10 = graph.NewNode(op, nil, nil, nil); USE(n10); op = common_builder.Parameter(0); Node* n2 = graph.NewNode(op, n0); USE(n2); n10->ReplaceInput(0, n2); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n25 = graph.NewNode(op, nil, nil, nil); USE(n25); op = js_builder.Add(); @@ -1239,14 +1239,14 @@ TEST(BuildScheduleBreakAndContinue) { Node* n16 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n16); n16->ReplaceInput(0, n10); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n11 = graph.NewNode(op, nil, nil, nil); USE(n11); op = common_builder.Parameter(0); Node* n3 = graph.NewNode(op, n0); USE(n3); n11->ReplaceInput(0, n3); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n26 = graph.NewNode(op, nil, nil, nil); USE(n26); n26->ReplaceInput(0, n11); @@ -1283,23 +1283,23 @@ TEST(BuildScheduleBreakAndContinue) { USE(n46); n47->ReplaceInput(1, n46); n47->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n42 = graph.NewNode(op, nil, nil, nil); USE(n42); op = js_builder.LessThan(); Node* n30 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n30); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n27 = graph.NewNode(op, nil, nil, nil); USE(n27); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n12 = graph.NewNode(op, nil, nil, nil); USE(n12); op = common_builder.Parameter(0); Node* n4 = graph.NewNode(op, n0); USE(n4); n12->ReplaceInput(0, n4); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n41 = graph.NewNode(op, nil, nil, nil); USE(n41); n41->ReplaceInput(0, n27); @@ -1348,17 +1348,17 @@ TEST(BuildScheduleBreakAndContinue) { op = js_builder.Equal(); Node* n37 = graph.NewNode(op, nil, nil, nil, nil, nil); USE(n37); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n28 = graph.NewNode(op, nil, nil, nil); USE(n28); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n13 = graph.NewNode(op, nil, nil, nil); USE(n13); op = common_builder.NumberConstant(0); Node* n7 = graph.NewNode(op); USE(n7); n13->ReplaceInput(0, n7); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n54 = graph.NewNode(op, nil, nil, nil); USE(n54); n54->ReplaceInput(0, n28); @@ -1409,7 +1409,7 @@ TEST(BuildScheduleBreakAndContinue) { n30->ReplaceInput(0, n27); n30->ReplaceInput(1, n26); n30->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n29 = graph.NewNode(op, nil, nil, nil); USE(n29); n29->ReplaceInput(0, n22); @@ -1456,11 +1456,11 @@ TEST(BuildScheduleBreakAndContinue) { n11->ReplaceInput(2, n8); n16->ReplaceInput(1, n11); n16->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n14 = graph.NewNode(op, nil, nil, nil); USE(n14); n14->ReplaceInput(0, n0); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n55 = graph.NewNode(op, nil, nil, nil); USE(n55); n55->ReplaceInput(0, n47); @@ -1533,7 +1533,7 @@ TEST(BuildScheduleSimpleLoopWithCodeMotion) { op = common_builder.Return(); Node* n21 = graph.NewNode(op, nil, nil, nil); USE(n21); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n9 = graph.NewNode(op, nil, nil, nil); USE(n9); op = common_builder.Parameter(0); @@ -1547,7 +1547,7 @@ TEST(BuildScheduleSimpleLoopWithCodeMotion) { op = machine_builder.Int32Add(); Node* n19 = graph.NewNode(op, nil, nil); USE(n19); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n10 = graph.NewNode(op, nil, nil, nil); USE(n10); op = common_builder.Parameter(0); @@ -1577,7 +1577,7 @@ TEST(BuildScheduleSimpleLoopWithCodeMotion) { Node* n6 = graph.NewNode(op); USE(n6); n14->ReplaceInput(2, n6); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n12 = graph.NewNode(op, nil, nil, nil); USE(n12); n12->ReplaceInput(0, n0); @@ -1595,7 +1595,7 @@ TEST(BuildScheduleSimpleLoopWithCodeMotion) { n7->ReplaceInput(1, n17); n10->ReplaceInput(2, n7); n19->ReplaceInput(0, n2); - op = common_builder.Phi(2); + op = common_builder.Phi(kMachAnyTagged, 2); Node* n11 = graph.NewNode(op, nil, nil, nil); USE(n11); op = common_builder.Parameter(0); @@ -1640,7 +1640,7 @@ static Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common, Node* t = graph->NewNode(common->IfTrue(), br); Node* f = graph->NewNode(common->IfFalse(), br); Node* m = graph->NewNode(common->Merge(2), t, f); - Node* phi = graph->NewNode(common->Phi(2), tv, fv, m); + Node* phi = graph->NewNode(common->Phi(kMachAnyTagged, 2), tv, fv, m); return phi; } diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc index 6627807bf4..dc32a2ac15 100644 --- a/test/cctest/compiler/test-simplified-lowering.cc +++ b/test/cctest/compiler/test-simplified-lowering.cc @@ -1420,3 +1420,28 @@ TEST(InsertChangeForStoreField) { CHECK_EQ(t.p0, store->InputAt(0)); CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2)); } + + +TEST(UpdatePhi) { + TestingGraph t(Type::Any(), Type::Signed32()); + static const MachineType kMachineTypes[] = {kMachInt32, kMachUint32, + kMachFloat64}; + + for (size_t i = 0; i < arraysize(kMachineTypes); i++) { + FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, + Handle::null(), Type::Any(), kMachineTypes[i]}; + + Node* load0 = + t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start); + Node* load1 = + t.graph()->NewNode(t.simplified()->LoadField(access), t.p1, t.start); + Node* phi = t.graph()->NewNode(t.common()->Phi(kMachAnyTagged, 2), load0, + load1, t.start); + t.Return(t.Use(phi, kMachineTypes[i])); + t.Lower(); + + CHECK_EQ(IrOpcode::kPhi, phi->opcode()); + CHECK_EQ(RepresentationOf(kMachineTypes[i]), + RepresentationOf(OpParameter(phi))); + } +}