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

test/unittests/compiler/arm/instruction-selector-arm-unittest.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 <limits>
 
 #include "test/unittests/compiler/instruction-selector-unittest.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
-typedef RawMachineAssembler::Label MLabel;
 typedef Node* (RawMachineAssembler::*Constructor)(Node*, Node*);
 
 
 // Data processing instructions.
 struct DPI {
   Constructor constructor;
   const char* constructor_name;
   ArchOpcode arch_opcode;
   ArchOpcode reverse_arch_opcode;
   ArchOpcode test_arch_opcode;
@@ skipping 214 matching lines @@
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(1U, s[0]->OutputCount());
     }
   }
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)), &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotEqual, s[0]->flags_condition());
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)), &a,
              &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)), &a,
              &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchWithShiftByParameter) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch((m.*dpi.constructor)(
                  m.Parameter(0),
                  (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch((m.*dpi.constructor)(
                  (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
                  m.Parameter(2)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchWithShiftByImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-      MLabel a, b;
+      RawMachineLabel a, b;
       m.Branch((m.*dpi.constructor)(m.Parameter(0),
                                     (m.*shift.constructor)(
                                         m.Parameter(1), m.Int32Constant(imm))),
                &a, &b);
       m.Bind(&a);
       m.Return(m.Int32Constant(1));
       m.Bind(&b);
       m.Return(m.Int32Constant(0));
       Stream s = m.Build();
       ASSERT_EQ(1U, s.size());
       EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
       EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
       ASSERT_EQ(5U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
       EXPECT_EQ(kNotEqual, s[0]->flags_condition());
     }
   }
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-      MLabel a, b;
+      RawMachineLabel a, b;
       m.Branch((m.*dpi.constructor)(
                    (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                    m.Parameter(1)),
                &a, &b);
       m.Bind(&a);
       m.Return(m.Int32Constant(1));
       m.Bind(&b);
       m.Return(m.Int32Constant(0));
       Stream s = m.Build();
       ASSERT_EQ(1U, s.size());
       EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
       EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
       ASSERT_EQ(5U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
       EXPECT_EQ(kNotEqual, s[0]->flags_condition());
     }
   }
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchIfZeroWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   m.Branch(m.Word32Equal((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                          m.Int32Constant(0)),
            &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kEqual, s[0]->flags_condition());
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchIfNotZeroWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   m.Branch(
       m.Word32NotEqual((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                        m.Int32Constant(0)),
       &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotEqual, s[0]->flags_condition());
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchIfZeroWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch(m.Word32Equal(
                  (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch(m.Word32Equal(
                  (m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
 }
 
 
 TEST_P(InstructionSelectorDPITest, BranchIfNotZeroWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch(m.Word32NotEqual(
                  (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     m.Branch(m.Word32NotEqual(
                  (m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
@@ skipping 378 matching lines @@
       EXPECT_EQ(kFlags_set, s[0]->flags_mode());
       EXPECT_EQ(kOverflow, s[0]->flags_condition());
     }
   }
 }
 
 
 TEST_P(InstructionSelectorODPITest, BranchWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Projection(1, n), &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(0));
   m.Bind(&b);
   m.Return(m.Projection(0, n));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(4U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kOverflow, s[0]->flags_condition());
 }
 
 
 TEST_P(InstructionSelectorODPITest, BranchWithImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
     m.Branch(m.Projection(1, n), &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(0));
     m.Bind(&b);
     m.Return(m.Projection(0, n));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(4U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
-    MLabel a, b;
+    RawMachineLabel a, b;
     Node* n = (m.*odpi.constructor)(m.Int32Constant(imm), m.Parameter(0));
     m.Branch(m.Projection(1, n), &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(0));
     m.Bind(&b);
     m.Return(m.Projection(0, n));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(4U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
 TEST_P(InstructionSelectorODPITest, BranchIfZeroWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Word32Equal(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
   m.Bind(&a);
   m.Return(m.Projection(0, n));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(4U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotOverflow, s[0]->flags_condition());
 }
 
 
 TEST_P(InstructionSelectorODPITest, BranchIfNotZeroWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
-  MLabel a, b;
+  RawMachineLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Word32NotEqual(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
   m.Bind(&a);
   m.Return(m.Projection(0, n));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
@@ skipping 1789 matching lines @@
   EXPECT_EQ(kArmClz, s[0]->arch_opcode());
   ASSERT_EQ(1U, s[0]->InputCount());
   EXPECT_EQ(s.ToVreg(p0), s.ToVreg(s[0]->InputAt(0)));
   ASSERT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(s.ToVreg(n), s.ToVreg(s[0]->Output()));
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8