[turbofan] Add MachineType to Phi.

test/cctest/compiler/test-run-machops.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 <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/compiler/generic-node-inl.h"
 #include "test/cctest/cctest.h"
@@ skipping 191 matching lines @@
   m.Goto(&header);
   m.Bind(&exit);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 template <typename R>
 static void BuildDiamondPhi(RawMachineAssemblerTester<R>* 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);
   m->Bind(&blocka);
   m->Goto(end);
   m->Bind(&blockb);
   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);
 }
 
 
 TEST(RunDiamondPhiConst) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
   int false_val = 0xFF666;
   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));
 }
 
 
 TEST(RunDiamondPhiNumber) {
   RawMachineAssemblerTester<Object*> m(kMachInt32);
   double false_val = -11.1;
   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));
 }
 
 
 TEST(RunDiamondPhiString) {
   RawMachineAssemblerTester<Object*> m(kMachInt32);
   const char* false_val = "false";
   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));
 }
 
 
 TEST(RunDiamondPhiParam) {
   RawMachineAssemblerTester<int32_t> 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);
   CHECK_EQ(c2, result);
   result = m.Call(1, c1, c2);
   CHECK_EQ(c1, result);
 }
 
 
 TEST(RunLoopPhiConst) {
   RawMachineAssemblerTester<int32_t> m;
   int true_val = 0x44000;
   int false_val = 0x00888;
 
   Node* cond_node = m.Int32Constant(0);
   Node* true_node = m.Int32Constant(true_val);
   Node* false_node = m.Int32Constant(false_val);
 
   // x = false_val; while(false) { x = true_val; } return x;
   MLabel body, header;
   MLabel* end = m.Exit();
 
   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);
   m.Bind(end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunLoopPhiParam) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32, kMachInt32, kMachInt32);
 
   MLabel blocka, blockb;
   MLabel* end = m.Exit();
 
   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);
   m.Goto(&blocka);
 
   m.Bind(end);
   m.Return(phi);
 
   int32_t c1 = 0xa81903b4;
   int32_t c2 = 0x5a1207da;
@@ skipping 10 matching lines @@
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
   MLabel header, body;
   MLabel* end = m.Exit();
   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));
   phi->ReplaceInput(1, add);
   m.Goto(&header);
 
   m.Bind(end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunLoopIncrement) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x ^ param) { x++; } return x;
   MLabel header, body;
   MLabel* end = m.Exit();
   Node* zero = m.Int32Constant(0);
 
   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);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
 }
 
 
 TEST(RunLoopIncrement2) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x < param) { x++; } return x;
   MLabel header, body;
   MLabel* end = m.Exit();
   Node* zero = m.Int32Constant(0);
 
   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);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
   CHECK_EQ(0, bt.call(-200, 0));
 }
 
 
 TEST(RunLoopIncrement3) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = 0; while(x < param) { x++; } return x;
   MLabel header, body;
   MLabel* end = m.Exit();
   Node* zero = m.Int32Constant(0);
 
   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);
   phi->ReplaceInput(1, m.Int32Add(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(end);
   bt.AddReturn(phi);
 
   CHECK_EQ(11, bt.call(11, 0));
   CHECK_EQ(110, bt.call(110, 0));
   CHECK_EQ(176, bt.call(176, 0));
   CHECK_EQ(200, bt.call(200, 0));
 }
 
 
 TEST(RunLoopDecrement) {
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
 
   // x = param; while(x) { x--; } return x;
   MLabel header, body;
   MLabel* end = m.Exit();
 
   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);
   phi->ReplaceInput(1, m.Int32Sub(phi, m.Int32Constant(1)));
   m.Goto(&header);
 
   m.Bind(end);
   bt.AddReturn(phi);
 
   CHECK_EQ(0, bt.call(11, 0));
   CHECK_EQ(0, bt.call(110, 0));
   CHECK_EQ(0, bt.call(197, 0));
 }
 
 
 TEST(RunLoopIncrementFloat64) {
   RawMachineAssemblerTester<int32_t> m;
 
   // x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x;
   MLabel header, body;
   MLabel* end = m.Exit();
   Node* minus_3 = m.Float64Constant(-3.0);
   Node* ten = m.Float64Constant(10.0);
 
   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);
   phi->ReplaceInput(1, m.Float64Add(phi, m.Float64Constant(0.5)));
   m.Goto(&header);
 
   m.Bind(end);
   m.Return(m.ChangeFloat64ToInt32(phi));
 
   CHECK_EQ(10, m.Call());
@@ skipping 2751 matching lines @@
 TEST(RunLoopPhiInduction2) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
   MLabel header, body, end;
   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));
   phi->ReplaceInput(1, add);
   m.Goto(&header);
   m.Bind(&end);
   m.Return(phi);
 
   CHECK_EQ(false_val, m.Call());
 }
 
 
 TEST(RunDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99645;
   double buffer = 0.1;
   double constant = 99.99;
 
   MLabel blocka, blockb, end;
   Node* k1 = m.Float64Constant(constant);
   Node* k2 = m.Float64Constant(0 - constant);
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   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));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(constant, buffer);
 }
 
 
 TEST(RunRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99644;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("A");
   String* buffer;
 
   MLabel blocka, blockb, end;
   Node* k1 = m.StringConstant("A");
   Node* k2 = m.StringConstant("B");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   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));
 
   CHECK_EQ(magic, m.Call());
   CHECK(rexpected->SameValue(buffer));
 }
 
 
 TEST(RunDoubleRefDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99648;
   double dbuffer = 0.1;
   double dconstant = 99.99;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("AX");
   String* rbuffer;
 
   MLabel blocka, blockb, end;
   Node* d1 = m.Float64Constant(dconstant);
   Node* d2 = m.Float64Constant(0 - dconstant);
   Node* r1 = m.StringConstant("AX");
   Node* r2 = m.StringConstant("BX");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   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);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
@@ skipping 12 matching lines @@
   Node* d1 = m.Float64Constant(dconstant);
   Node* d2 = m.Float64Constant(0 - dconstant);
   Node* r1 = m.StringConstant("AD");
   Node* r2 = m.StringConstant("BD");
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&mid);
   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);
   m.Goto(&end);
   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),
           rphi2);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK_EQ(dconstant, dbuffer);
   CHECK(rexpected->SameValue(rbuffer));
 }
 
 
 TEST(RunDoubleLoopPhi) {
   RawMachineAssemblerTester<int32_t> m;
   MLabel header, body, end;
 
   int magic = 99773;
   double buffer = 0.99;
   double dconstant = 777.1;
 
   Node* zero = m.Int32Constant(0);
   Node* dk = m.Float64Constant(dconstant);
 
   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);
   m.Goto(&header);
   m.Bind(&end);
   m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunCountToTenAccRaw) {
   RawMachineAssemblerTester<int32_t> m;
 
   Node* zero = m.Int32Constant(0);
   Node* ten = m.Int32Constant(10);
   Node* one = m.Int32Constant(1);
 
   MLabel header, body, body_cont, end;
 
   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);
   Node* next_i = m.Int32Add(i, one);
   Node* next_j = m.Int32Add(j, one);
   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
 
   m.Bind(&body_cont);
   i->ReplaceInput(1, next_i);
   j->ReplaceInput(1, next_j);
@@ skipping 11 matching lines @@
 
   Node* zero = m.Int32Constant(0);
   Node* ten = m.Int32Constant(10);
   Node* one = m.Int32Constant(1);
 
   MLabel header, body, body_cont, end;
 
   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);
   Node* next_i = m.Int32Add(i, one);
   Node* next_j = m.Int32Add(j, one);
   Node* next_k = m.Int32Add(j, one);
   m.Branch(m.Word32Equal(next_i, ten), &end, &body_cont);
 
   m.Bind(&body_cont);
   i->ReplaceInput(1, next_i);
@@ skipping 486 matching lines @@
   Node* false_node = m.HeapConstant(false_val);
 
   MLabel blocka, blockb, end;
   m.Branch(m.Parameter(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   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));
   CHECK_EQ(*true_val, m.Call(1));
 }
 
 
 #if MACHINE_ASSEMBLER_SUPPORTS_CALL_C
 
 TEST(RunSpillLotsOfThingsWithCall) {
@@ skipping 325 matching lines @@
   RawMachineAssemblerTester<int32_t> m;
   m.Return(m.TruncateFloat64ToInt32(m.LoadFromPointer(&input, kMachFloat64)));
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     input = kValues[i].from;
     uint64_t expected = static_cast<int64_t>(kValues[i].raw);
     CHECK_EQ(static_cast<int>(expected), m.Call());
   }
 }
 
 #endif  // V8_TURBOFAN_TARGET