Move RMA::Label out of the class, so it can be forward declared.

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.
 
 // TODO(jochen): Remove this after the setting is turned on globally.
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/codegen.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/codegen-tester.h"
 #include "test/cctest/compiler/graph-builder-tester.h"
 #include "test/cctest/compiler/value-helper.h"
 
 using namespace v8::base;
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-typedef RawMachineAssembler::Label MLabel;
-
 
 TEST(RunInt32Add) {
   RawMachineAssemblerTester<int32_t> m;
   Node* add = m.Int32Add(m.Int32Constant(0), m.Int32Constant(1));
   m.Return(add);
   CHECK_EQ(1, m.Call());
 }
 
 
 TEST(RunWord32Ctz) {
@@ skipping 382 matching lines @@
 
 
 // TODO(titzer): add tests that run 64-bit integer operations.
 #endif  // V8_TARGET_ARCH_64_BIT
 
 
 TEST(RunGoto) {
   RawMachineAssemblerTester<int32_t> m;
   int constant = 99999;
 
-  MLabel next;
+  RawMachineLabel next;
   m.Goto(&next);
   m.Bind(&next);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunGotoMultiple) {
   RawMachineAssemblerTester<int32_t> m;
   int constant = 9999977;
 
-  MLabel labels[10];
+  RawMachineLabel labels[10];
   for (size_t i = 0; i < arraysize(labels); i++) {
     m.Goto(&labels[i]);
     m.Bind(&labels[i]);
   }
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunBranch) {
   RawMachineAssemblerTester<int32_t> m;
   int constant = 999777;
 
-  MLabel blocka, blockb;
+  RawMachineLabel blocka, blockb;
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Return(m.Int32Constant(0 - constant));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunDiamond2) {
   RawMachineAssemblerTester<int32_t> m;
 
   int constant = 995666;
 
-  MLabel blocka, blockb, end;
+  RawMachineLabel blocka, blockb, end;
   m.Branch(m.Int32Constant(0), &blocka, &blockb);
   m.Bind(&blocka);
   m.Goto(&end);
   m.Bind(&blockb);
   m.Goto(&end);
   m.Bind(&end);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunLoop) {
   RawMachineAssemblerTester<int32_t> m;
   int constant = 999555;
 
-  MLabel header, body, exit;
+  RawMachineLabel header, body, exit;
   m.Goto(&header);
   m.Bind(&header);
   m.Branch(m.Int32Constant(0), &body, &exit);
   m.Bind(&body);
   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,
                             MachineType type, Node* true_node,
                             Node* false_node) {
-  MLabel blocka, blockb, end;
+  RawMachineLabel blocka, blockb, end;
   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(type, true_node, false_node);
   m->Return(phi);
 }
@@ skipping 51 matching lines @@
 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, end;
+  RawMachineLabel body, header, end;
 
   m.Goto(&header);
   m.Bind(&header);
   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, end;
+  RawMachineLabel blocka, blockb, end;
 
   m.Goto(&blocka);
 
   m.Bind(&blocka);
   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;
   int result = m.Call(0, c1, c2);
   CHECK_EQ(c1, result);
   result = m.Call(1, c1, c2);
   CHECK_EQ(c2, result);
 }
 
 
 TEST(RunLoopPhiInduction) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
-  MLabel header, body, end;
+  RawMachineLabel header, body, end;
   Node* false_node = m.Int32Constant(false_val);
 
   m.Goto(&header);
 
   m.Bind(&header);
   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, end;
+  RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
   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, end;
+  RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
   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, end;
+  RawMachineLabel header, body, end;
   Node* zero = m.Int32Constant(0);
 
   m.Goto(&header);
 
   m.Bind(&header);
   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, end;
+  RawMachineLabel header, body, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
   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(RunLoopIncrementFloat32) {
   RawMachineAssemblerTester<int32_t> m;
 
   // x = -3.0f; while(x < 10f) { x = x + 0.5f; } return (int) (double) x;
-  MLabel header, body, end;
+  RawMachineLabel header, body, end;
   Node* minus_3 = m.Float32Constant(-3.0f);
   Node* ten = m.Float32Constant(10.0f);
 
   m.Goto(&header);
 
   m.Bind(&header);
   Node* phi = m.Phi(kMachFloat32, minus_3, ten);
   m.Branch(m.Float32LessThan(phi, ten), &body, &end);
 
   m.Bind(&body);
   phi->ReplaceInput(1, m.Float32Add(phi, m.Float32Constant(0.5f)));
   m.Goto(&header);
 
   m.Bind(&end);
   m.Return(m.ChangeFloat64ToInt32(m.ChangeFloat32ToFloat64(phi)));
 
   CHECK_EQ(10, m.Call());
 }
 
 
 TEST(RunLoopIncrementFloat64) {
   RawMachineAssemblerTester<int32_t> m;
 
   // x = -3.0; while(x < 10) { x = x + 0.5; } return (int) x;
-  MLabel header, body, end;
+  RawMachineLabel header, body, end;
   Node* minus_3 = m.Float64Constant(-3.0);
   Node* ten = m.Float64Constant(10.0);
 
   m.Goto(&header);
 
   m.Bind(&header);
   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());
 }
 
 
 TEST(RunSwitch1) {
   RawMachineAssemblerTester<int32_t> m;
 
   int constant = 11223344;
 
-  MLabel block0, block1, def, end;
-  MLabel* case_labels[] = {&block0, &block1};
+  RawMachineLabel block0, block1, def, end;
+  RawMachineLabel* case_labels[] = {&block0, &block1};
   int32_t case_values[] = {0, 1};
   m.Switch(m.Int32Constant(0), &def, case_values, case_labels,
            arraysize(case_labels));
   m.Bind(&block0);
   m.Goto(&end);
   m.Bind(&block1);
   m.Goto(&end);
   m.Bind(&def);
   m.Goto(&end);
   m.Bind(&end);
   m.Return(m.Int32Constant(constant));
 
   CHECK_EQ(constant, m.Call());
 }
 
 
 TEST(RunSwitch2) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
 
-  MLabel blocka, blockb, blockc;
-  MLabel* case_labels[] = {&blocka, &blockb};
+  RawMachineLabel blocka, blockb, blockc;
+  RawMachineLabel* case_labels[] = {&blocka, &blockb};
   int32_t case_values[] = {std::numeric_limits<int32_t>::min(),
                            std::numeric_limits<int32_t>::max()};
   m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
            arraysize(case_labels));
   m.Bind(&blocka);
   m.Return(m.Int32Constant(-1));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockc);
   m.Return(m.Int32Constant(0));
 
   CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::max()));
   CHECK_EQ(-1, m.Call(std::numeric_limits<int32_t>::min()));
   for (int i = -100; i < 100; i += 25) {
     CHECK_EQ(0, m.Call(i));
   }
 }
 
 
 TEST(RunSwitch3) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
 
-  MLabel blocka, blockb, blockc;
-  MLabel* case_labels[] = {&blocka, &blockb};
+  RawMachineLabel blocka, blockb, blockc;
+  RawMachineLabel* case_labels[] = {&blocka, &blockb};
   int32_t case_values[] = {std::numeric_limits<int32_t>::min() + 0,
                            std::numeric_limits<int32_t>::min() + 1};
   m.Switch(m.Parameter(0), &blockc, case_values, case_labels,
            arraysize(case_labels));
   m.Bind(&blocka);
   m.Return(m.Int32Constant(0));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockc);
   m.Return(m.Int32Constant(2));
 
   CHECK_EQ(0, m.Call(std::numeric_limits<int32_t>::min() + 0));
   CHECK_EQ(1, m.Call(std::numeric_limits<int32_t>::min() + 1));
   for (int i = -100; i < 100; i += 25) {
     CHECK_EQ(2, m.Call(i));
   }
 }
 
 
 TEST(RunSwitch4) {
   RawMachineAssemblerTester<int32_t> m(kMachInt32);
 
   const size_t kNumCases = 512;
   const size_t kNumValues = kNumCases + 1;
   int32_t values[kNumValues];
   m.main_isolate()->random_number_generator()->NextBytes(values,
                                                          sizeof(values));
-  MLabel end, def;
+  RawMachineLabel end, def;
   int32_t case_values[kNumCases];
-  MLabel* case_labels[kNumCases];
+  RawMachineLabel* case_labels[kNumCases];
   Node* results[kNumValues];
   for (size_t i = 0; i < kNumCases; ++i) {
     case_values[i] = static_cast<int32_t>(i);
-    case_labels[i] = new (m.main_zone()->New(sizeof(MLabel))) MLabel;
+    case_labels[i] =
+        new (m.main_zone()->New(sizeof(RawMachineLabel))) RawMachineLabel;
   }
   m.Switch(m.Parameter(0), &def, case_values, case_labels,
            arraysize(case_labels));
   for (size_t i = 0; i < kNumCases; ++i) {
     m.Bind(case_labels[i]);
     results[i] = m.Int32Constant(values[i]);
     m.Goto(&end);
   }
   m.Bind(&def);
   results[kNumCases] = m.Int32Constant(values[kNumCases]);
@@ skipping 344 matching lines @@
     }
   }
 }
 
 
 TEST(RunInt32AddInBranch) {
   static const int32_t constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Int32Add(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i + *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Int32Add(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i + *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
                                            kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Add(m.Parameter(0),
                                         m.AddNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
@@ skipping 241 matching lines @@
     }
   }
 }
 
 
 TEST(RunInt32SubInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Int32Sub(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i - *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Int32Sub(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i - *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
                                            kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Int32Sub(m.Parameter(0),
                                         m.AddNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
@@ skipping 572 matching lines @@
     }
   }
 }
 
 
 TEST(RunWord32AndInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32And(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(
           m.Word32NotEqual(m.Word32And(m.Int32Constant(*i), m.Parameter(0)),
                            m.Int32Constant(0)),
           &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         int32_t expected = (*i & *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
                                            kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32And(m.Parameter(0),
                                          m.AddNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
@@ skipping 132 matching lines @@
     }
   }
 }
 
 
 TEST(RunWord32OrInBranch) {
   static const int constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Int32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32Or(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_INT32_INPUTS(i) {
       FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_INT32_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m(kMachInt32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_INT32_INPUTS(i) {
       RawMachineAssemblerTester<int32_t> m(kMachInt32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32NotEqual(m.Word32Or(m.Int32Constant(*i), m.Parameter(0)),
                                 m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_INT32_INPUTS(j) {
         int32_t expected = (*i | *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
                                            kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Or(m.Parameter(0),
                                         m.AddNode(shops[n], m.Parameter(1),
                                                   m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
@@ skipping 128 matching lines @@
     }
   }
 }
 
 
 TEST(RunWord32XorInBranch) {
   static const uint32_t constant = 987654321;
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32Equal(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     RawMachineAssemblerTester<int32_t> m;
     Uint32BinopTester bt(&m);
-    MLabel blocka, blockb;
+    RawMachineLabel blocka, blockb;
     m.Branch(
         m.Word32NotEqual(m.Word32Xor(bt.param0, bt.param1), m.Int32Constant(0)),
         &blocka, &blockb);
     m.Bind(&blocka);
     bt.AddReturn(m.Int32Constant(constant));
     m.Bind(&blockb);
     bt.AddReturn(m.Int32Constant(0 - constant));
     FOR_UINT32_INPUTS(i) {
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, bt.call(*i, *j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i ^ *j) == 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     FOR_UINT32_INPUTS(i) {
       RawMachineAssemblerTester<uint32_t> m(kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(
           m.Word32NotEqual(m.Word32Xor(m.Int32Constant(*i), m.Parameter(0)),
                            m.Int32Constant(0)),
           &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(j) {
         uint32_t expected = (*i ^ *j) != 0 ? constant : 0 - constant;
         CHECK_EQ(expected, m.Call(*j));
       }
     }
   }
   {
     RawMachineAssemblerTester<void> m;
     const Operator* shops[] = {m.machine()->Word32Sar(),
                                m.machine()->Word32Shl(),
                                m.machine()->Word32Shr()};
     for (size_t n = 0; n < arraysize(shops); n++) {
       RawMachineAssemblerTester<int32_t> m(kMachUint32, kMachInt32,
                                            kMachUint32);
-      MLabel blocka, blockb;
+      RawMachineLabel blocka, blockb;
       m.Branch(m.Word32Equal(m.Word32Xor(m.Parameter(0),
                                          m.AddNode(shops[n], m.Parameter(1),
                                                    m.Parameter(2))),
                              m.Int32Constant(0)),
                &blocka, &blockb);
       m.Bind(&blocka);
       m.Return(m.Int32Constant(constant));
       m.Bind(&blockb);
       m.Return(m.Int32Constant(0 - constant));
       FOR_UINT32_INPUTS(i) {
@@ skipping 1157 matching lines @@
   CHECK_EQ(magic, m.Call());
 }
 
 
 TEST(RunLoopPhiInduction2) {
   RawMachineAssemblerTester<int32_t> m;
 
   int false_val = 0x10777;
 
   // x = false_val; while(false) { x++; } return x;
-  MLabel header, body, end;
+  RawMachineLabel header, body, end;
   Node* false_node = m.Int32Constant(false_val);
   m.Goto(&header);
   m.Bind(&header);
   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(RunFloatDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99645;
   float buffer = 0.1f;
   float constant = 99.99f;
 
-  MLabel blocka, blockb, end;
+  RawMachineLabel blocka, blockb, end;
   Node* k1 = m.Float32Constant(constant);
   Node* k2 = m.Float32Constant(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(kMachFloat32, k2, k1);
   m.Store(kMachFloat32, m.PointerConstant(&buffer), m.IntPtrConstant(0), phi,
           kNoWriteBarrier);
   m.Return(m.Int32Constant(magic));
 
   CHECK_EQ(magic, m.Call());
   CHECK(constant == buffer);
 }
 
 
 TEST(RunDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99645;
   double buffer = 0.1;
   double constant = 99.99;
 
-  MLabel blocka, blockb, end;
+  RawMachineLabel 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(kMachFloat64, k2, k1);
   m.Store(kMachFloat64, m.PointerConstant(&buffer), m.Int32Constant(0), phi,
           kNoWriteBarrier);
   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;
+  RawMachineLabel 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(kMachAnyTagged, k2, k1);
   m.Store(kMachAnyTagged, m.PointerConstant(&buffer), m.Int32Constant(0), phi,
           kNoWriteBarrier);
   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;
+  RawMachineLabel 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);
@@ skipping 14 matching lines @@
 TEST(RunDoubleRefDoubleDiamond) {
   RawMachineAssemblerTester<int32_t> m;
 
   const int magic = 99649;
   double dbuffer = 0.1;
   double dconstant = 99.997;
   Handle<String> rexpected =
       CcTest::i_isolate()->factory()->InternalizeUtf8String("AD");
   String* rbuffer;
 
-  MLabel blocka, blockb, mid, blockd, blocke, end;
+  RawMachineLabel blocka, blockb, mid, blockd, blocke, end;
   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);
@@ skipping 16 matching lines @@
   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;
+  RawMachineLabel 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);
@@ skipping 11 matching lines @@
 }
 
 
 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;
+  RawMachineLabel header, body, body_cont, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
   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);
@@ skipping 12 matching lines @@
 }
 
 
 TEST(RunCountToTenAccRaw2) {
   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;
+  RawMachineLabel header, body, body_cont, end;
 
   m.Goto(&header);
 
   m.Bind(&header);
   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);
@@ skipping 409 matching lines @@
 
 TEST(RunNewSpaceConstantsInPhi) {
   RawMachineAssemblerTester<Object*> m(kMachInt32);
 
   Isolate* isolate = CcTest::i_isolate();
   Handle<HeapNumber> true_val = isolate->factory()->NewHeapNumber(11.2);
   Handle<HeapNumber> false_val = isolate->factory()->NewHeapNumber(11.3);
   Node* true_node = m.HeapConstant(true_val);
   Node* false_node = m.HeapConstant(false_val);
 
-  MLabel blocka, blockb, end;
+  RawMachineLabel 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(kMachAnyTagged, true_node, false_node);
   m.Return(phi);
 
@@ skipping 62 matching lines @@
       int expected_ovf = bits::SignedAddOverflow32(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32AddWithOverflowInBranchP) {
   int constant = 911777;
-  MLabel blocka, blockb;
+  RawMachineLabel blocka, blockb;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* add = m.Int32AddWithOverflow(bt.param0, bt.param1);
   Node* ovf = m.Projection(1, add);
   m.Branch(ovf, &blocka, &blockb);
   m.Bind(&blocka);
   bt.AddReturn(m.Int32Constant(constant));
   m.Bind(&blockb);
   Node* val = m.Projection(0, add);
   bt.AddReturn(val);
@@ skipping 67 matching lines @@
       int expected_ovf = bits::SignedSubOverflow32(*i, *j, &expected_val);
       CHECK_EQ(expected_ovf, m.Call());
       CHECK_EQ(expected_val, actual_val);
     }
   }
 }
 
 
 TEST(RunInt32SubWithOverflowInBranchP) {
   int constant = 911999;
-  MLabel blocka, blockb;
+  RawMachineLabel blocka, blockb;
   RawMachineAssemblerTester<int32_t> m;
   Int32BinopTester bt(&m);
   Node* sub = m.Int32SubWithOverflow(bt.param0, bt.param1);
   Node* ovf = m.Projection(1, sub);
   m.Branch(ovf, &blocka, &blockb);
   m.Bind(&blocka);
   bt.AddReturn(m.Int32Constant(constant));
   m.Bind(&blockb);
   Node* val = m.Projection(0, sub);
   bt.AddReturn(val);
   FOR_INT32_INPUTS(i) {
     FOR_INT32_INPUTS(j) {
       int32_t expected;
       if (bits::SignedSubOverflow32(*i, *j, &expected)) expected = constant;
       CHECK_EQ(expected, bt.call(*i, *j));
     }
   }
 }
 
 
 TEST(RunWord64EqualInBranchP) {
   int64_t input;
-  MLabel blocka, blockb;
+  RawMachineLabel blocka, blockb;
   RawMachineAssemblerTester<int64_t> m;
   if (!m.machine()->Is64()) return;
   Node* value = m.LoadFromPointer(&input, kMachInt64);
   m.Branch(m.Word64Equal(value, m.Int64Constant(0)), &blocka, &blockb);
   m.Bind(&blocka);
   m.Return(m.Int32Constant(1));
   m.Bind(&blockb);
   m.Return(m.Int32Constant(2));
   input = V8_INT64_C(0);
   CHECK_EQ(1, m.Call());
@@ skipping 822 matching lines @@
   a.Return(a.Int32Constant(33));
   a.End();
   Handle<Code> code_a = a.GetCode();
 
   GraphBuilderTester<int32_t> b;
   b.Return(b.Int32Constant(44));
   b.End();
   Handle<Code> code_b = b.GetCode();
 
   RawMachineAssemblerTester<int32_t> r(kMachInt32);
-  RawMachineAssembler::Label tlabel;
-  RawMachineAssembler::Label flabel;
-  RawMachineAssembler::Label merge;
+  RawMachineLabel tlabel;
+  RawMachineLabel flabel;
+  RawMachineLabel merge;
   r.Branch(r.Parameter(0), &tlabel, &flabel);
   r.Bind(&tlabel);
   Node* fa = r.HeapConstant(code_a);
   r.Goto(&merge);
   r.Bind(&flabel);
   Node* fb = r.HeapConstant(code_b);
   r.Goto(&merge);
   r.Bind(&merge);
   Node* phi = r.Phi(kMachInt32, fa, fb);
 
@@ skipping 18 matching lines @@
   Node* call = r.AddNode(r.common()->Call(desc), phi);
   r.Return(call);
 
   CHECK_EQ(33, r.Call(1));
   CHECK_EQ(44, r.Call(0));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8