[turbofan] Add MachineType to Phi.

test/cctest/compiler/test-scheduler.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/generic-node.h"
@@ skipping 826 matching lines @@
   op = common_builder.Start(0);
   Node* n0 = graph.NewNode(op);
   USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n20 = graph.NewNode(op, nil);
   USE(n20);
   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);
   Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n8->ReplaceInput(0, n2);
   op = js_builder.Add();
   Node* n18 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n18);
   op = js_builder.ToNumber();
   Node* n16 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n16);
   n16->ReplaceInput(0, n8);
   op = common_builder.HeapConstant(unique_constant);
   Node* n5 = graph.NewNode(op);
   USE(n5);
   n16->ReplaceInput(1, n5);
   op = js_builder.LessThan();
   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);
   Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n9->ReplaceInput(0, n3);
   n9->ReplaceInput(1, n9);
   op = common_builder.Loop(2);
   Node* n6 = graph.NewNode(op, nil, nil);
   USE(n6);
   n6->ReplaceInput(0, n0);
   op = common_builder.IfTrue();
   Node* n14 = graph.NewNode(op, nil);
   USE(n14);
   op = common_builder.Branch();
   Node* n13 = graph.NewNode(op, nil, nil);
   USE(n13);
   n13->ReplaceInput(0, n12);
   n13->ReplaceInput(1, n6);
   n14->ReplaceInput(0, n13);
   n6->ReplaceInput(1, n14);
   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);
   n10->ReplaceInput(1, n18);
   n10->ReplaceInput(2, n6);
   n12->ReplaceInput(3, n10);
   n12->ReplaceInput(4, n6);
   n16->ReplaceInput(2, n12);
   n16->ReplaceInput(3, n14);
   n18->ReplaceInput(0, n16);
@@ skipping 50 matching lines @@
   op = common_builder.Start(0);
   Node* n0 = graph.NewNode(op);
   USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n46 = graph.NewNode(op, nil);
   USE(n46);
   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();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n20);
   op = js_builder.ToNumber();
   Node* n18 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n18);
   n18->ReplaceInput(0, n9);
   op = common_builder.HeapConstant(unique_constant);
   Node* n6 = graph.NewNode(op);
   USE(n6);
   n18->ReplaceInput(1, n6);
   op = js_builder.LessThan();
   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);
   n24->ReplaceInput(1, n24);
   op = common_builder.Loop(2);
   Node* n21 = graph.NewNode(op, nil, nil);
   USE(n21);
   op = common_builder.IfTrue();
   Node* n16 = graph.NewNode(op, nil);
   USE(n16);
   op = common_builder.Branch();
   Node* n15 = graph.NewNode(op, nil, nil);
   USE(n15);
   n15->ReplaceInput(0, n14);
   op = common_builder.Loop(2);
   Node* n7 = graph.NewNode(op, nil, nil);
   USE(n7);
   n7->ReplaceInput(0, n0);
   op = common_builder.IfFalse();
   Node* n30 = graph.NewNode(op, nil);
   USE(n30);
   op = common_builder.Branch();
   Node* n28 = graph.NewNode(op, nil, nil);
   USE(n28);
   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);
   Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n11->ReplaceInput(0, n4);
   n11->ReplaceInput(1, n25);
   n11->ReplaceInput(2, n7);
   n25->ReplaceInput(0, n11);
   op = js_builder.Add();
@@ skipping 16 matching lines @@
   USE(n19);
   n32->ReplaceInput(1, n19);
   n32->ReplaceInput(2, n6);
   n32->ReplaceInput(3, n31);
   n32->ReplaceInput(4, n29);
   n25->ReplaceInput(1, n32);
   n25->ReplaceInput(2, n21);
   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);
   n26->ReplaceInput(1, n32);
   n26->ReplaceInput(2, n21);
   n27->ReplaceInput(3, n26);
   n27->ReplaceInput(4, n21);
   n28->ReplaceInput(0, n27);
   n28->ReplaceInput(1, n21);
   n30->ReplaceInput(0, n28);
   n7->ReplaceInput(1, n30);
   n15->ReplaceInput(1, n7);
   n16->ReplaceInput(0, n15);
   n21->ReplaceInput(0, n16);
   n21->ReplaceInput(1, n29);
   n24->ReplaceInput(2, n21);
   n10->ReplaceInput(1, n24);
   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);
   n12->ReplaceInput(1, n27);
   n12->ReplaceInput(2, n7);
   n14->ReplaceInput(3, n12);
   n14->ReplaceInput(4, n7);
   n18->ReplaceInput(2, n14);
   n18->ReplaceInput(3, n16);
   n20->ReplaceInput(0, n18);
@@ skipping 13 matching lines @@
   n44->ReplaceInput(0, n35);
   op = common_builder.NumberConstant(0);
   Node* n43 = graph.NewNode(op);
   USE(n43);
   n44->ReplaceInput(1, n43);
   n44->ReplaceInput(2, n6);
   op = js_builder.LessThan();
   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);
   n36->ReplaceInput(1, n36);
   op = common_builder.Loop(2);
   Node* n33 = graph.NewNode(op, nil, nil);
   USE(n33);
   op = common_builder.IfFalse();
   Node* n17 = graph.NewNode(op, nil);
   USE(n17);
   n17->ReplaceInput(0, n15);
   n33->ReplaceInput(0, n17);
   op = common_builder.IfTrue();
   Node* n41 = graph.NewNode(op, nil);
   USE(n41);
   op = common_builder.Branch();
   Node* n40 = graph.NewNode(op, nil, nil);
   USE(n40);
   n40->ReplaceInput(0, n39);
   n40->ReplaceInput(1, n33);
   n41->ReplaceInput(0, n40);
   n33->ReplaceInput(1, n41);
   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);
   n38->ReplaceInput(1, n44);
   n38->ReplaceInput(2, n33);
   n39->ReplaceInput(3, n38);
   n39->ReplaceInput(4, n33);
   n44->ReplaceInput(3, n39);
   n44->ReplaceInput(4, n41);
   n35->ReplaceInput(1, n44);
@@ skipping 47 matching lines @@
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n58 = graph.NewNode(op, nil);
   USE(n58);
   op = common_builder.Return();
   Node* n57 = graph.NewNode(op, nil, nil, nil);
   USE(n57);
   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();
   Node* n22 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n22);
   op = js_builder.ToNumber();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n20);
   n20->ReplaceInput(0, n10);
   op = common_builder.HeapConstant(unique_constant);
   Node* n6 = graph.NewNode(op);
   USE(n6);
   n20->ReplaceInput(1, n6);
   op = js_builder.LessThan();
   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);
   n26->ReplaceInput(1, n26);
   op = common_builder.Loop(2);
   Node* n23 = graph.NewNode(op, nil, nil);
   USE(n23);
   op = common_builder.IfTrue();
   Node* n18 = graph.NewNode(op, nil);
   USE(n18);
@@ skipping 16 matching lines @@
   USE(n48);
   op = js_builder.Equal();
   Node* n47 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n47);
   n47->ReplaceInput(0, n25);
   op = common_builder.NumberConstant(0);
   Node* n46 = graph.NewNode(op);
   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);
   op = js_builder.Add();
   Node* n35 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n35);
   op = js_builder.ToNumber();
   Node* n34 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n34);
   n34->ReplaceInput(0, n27);
@@ skipping 28 matching lines @@
   n40->ReplaceInput(0, n33);
   op = common_builder.IfTrue();
   Node* n39 = graph.NewNode(op, nil);
   USE(n39);
   op = common_builder.Branch();
   Node* n38 = graph.NewNode(op, nil, nil);
   USE(n38);
   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);
   op = js_builder.Add();
   Node* n52 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n52);
   op = js_builder.ToNumber();
   Node* n51 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n51);
   n51->ReplaceInput(0, n28);
@@ skipping 30 matching lines @@
   n40->ReplaceInput(1, n39);
   n41->ReplaceInput(2, n40);
   n12->ReplaceInput(1, n41);
   n12->ReplaceInput(2, n8);
   n27->ReplaceInput(0, n12);
   n27->ReplaceInput(1, n35);
   n27->ReplaceInput(2, n23);
   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);
   op = js_builder.Add();
   Node* n45 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n45);
   op = js_builder.ToNumber();
   Node* n44 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n44);
   n44->ReplaceInput(0, n25);
@@ skipping 26 matching lines @@
   n8->ReplaceInput(1, n53);
   n17->ReplaceInput(1, n8);
   n18->ReplaceInput(0, n17);
   n23->ReplaceInput(0, n18);
   n23->ReplaceInput(1, n43);
   n26->ReplaceInput(2, n23);
   n11->ReplaceInput(1, n26);
   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);
   n55->ReplaceInput(1, n52);
   n55->ReplaceInput(2, n53);
   n14->ReplaceInput(1, n55);
   n14->ReplaceInput(2, n8);
   n16->ReplaceInput(3, n14);
   n16->ReplaceInput(4, n8);
   n20->ReplaceInput(2, n16);
@@ skipping 52 matching lines @@
   op = common_builder.Start(0);
   Node* n0 = graph.NewNode(op);
   USE(n0);
   Node* nil = graph.NewNode(common_builder.Dead());
   op = common_builder.End();
   Node* n22 = graph.NewNode(op, nil);
   USE(n22);
   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);
   Node* n2 = graph.NewNode(op, n0);
   USE(n2);
   n9->ReplaceInput(0, n2);
   op = js_builder.Add();
   Node* n20 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n20);
   n20->ReplaceInput(0, n9);
   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);
   Node* n3 = graph.NewNode(op, n0);
   USE(n3);
   n10->ReplaceInput(0, n3);
   n10->ReplaceInput(1, n10);
   op = common_builder.Loop(2);
   Node* n7 = graph.NewNode(op, nil, nil);
   USE(n7);
   n7->ReplaceInput(0, n0);
   op = common_builder.IfTrue();
   Node* n17 = graph.NewNode(op, nil);
   USE(n17);
   op = common_builder.Branch();
   Node* n16 = graph.NewNode(op, nil, nil);
   USE(n16);
   op = js_builder.ToBoolean();
   Node* n15 = graph.NewNode(op, nil, nil, nil, nil);
   USE(n15);
   op = js_builder.LessThan();
   Node* n14 = graph.NewNode(op, nil, nil, nil, nil, nil);
   USE(n14);
   n14->ReplaceInput(0, n9);
   n14->ReplaceInput(1, n10);
   op = common_builder.HeapConstant(unique_constant);
   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);
   n12->ReplaceInput(1, n20);
   n12->ReplaceInput(2, n7);
   n14->ReplaceInput(3, n12);
   n14->ReplaceInput(4, n7);
   n15->ReplaceInput(0, n14);
   n15->ReplaceInput(1, n6);
   n15->ReplaceInput(2, n14);
   n15->ReplaceInput(3, n7);
   n16->ReplaceInput(0, n15);
   n16->ReplaceInput(1, n7);
   n17->ReplaceInput(0, n16);
   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);
   Node* n4 = graph.NewNode(op, n0);
   USE(n4);
   n11->ReplaceInput(0, n4);
   n11->ReplaceInput(1, n11);
   n11->ReplaceInput(2, n7);
   n19->ReplaceInput(1, n3);
   n20->ReplaceInput(1, n19);
@@ skipping 24 matching lines @@
 #if V8_TURBOFAN_TARGET
 
 static Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common,
                            Node* cond) {
   Node* tv = graph->NewNode(common->Int32Constant(6));
   Node* fv = graph->NewNode(common->Int32Constant(7));
   Node* br = graph->NewNode(common->Branch(), cond, graph->start());
   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;
 }
 
 
 TEST(FloatingDiamond1) {
   HandleAndZoneScope scope;
   Graph graph(scope.main_zone());
   CommonOperatorBuilder common(scope.main_zone());
 
   Node* start = graph.NewNode(common.Start(1));
@@ skipping 50 matching lines @@
   Node* d3 = CreateDiamond(&graph, &common, add);
   Node* ret = graph.NewNode(common.Return(), d3, start, start);
   Node* end = graph.NewNode(common.End(), ret, start);
 
   graph.SetEnd(end);
 
   ComputeAndVerifySchedule(33, &graph);
 }
 
 #endif