[turbofan] Refactor the InstructionSelector tests.

Also fix some issues and improve test coverage.

TEST=compiler-unittests
BUG=v8:3489
LOG=y
R=jarin@chromium.org

Review URL: https://codereview.chromium.org/469743002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23111 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/compiler/arm/instruction-selector-arm.cc

@@ -141,11 +141,22 @@ static bool TryMatchROR(InstructionSelector* selector,
   if (value != mshl.left().node()) return false;
   Node* shift = mshr.right().node();
   Int32Matcher mshift(shift);
-  if (mshift.IsInRange(1, 31) && mshl.right().Is(32 - mshift.Value())) {
-    *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ROR_I);
-    *value_return = g.UseRegister(value);
-    *shift_return = g.UseImmediate(shift);
-    return true;
+  if (mshift.IsInRange(1, 31)) {
+    if (mshl.right().Is(32 - mshift.Value())) {
+      *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ROR_I);
+      *value_return = g.UseRegister(value);
+      *shift_return = g.UseImmediate(shift);
+      return true;
+    }
+    if (mshl.right().IsInt32Sub()) {
+      Int32BinopMatcher mshlright(mshl.right().node());
+      if (mshlright.left().Is(32) && mshlright.right().Is(mshift.Value())) {
+        *opcode_return |= AddressingModeField::encode(kMode_Operand2_R_ROR_I);
+        *value_return = g.UseRegister(value);
+        *shift_return = g.UseImmediate(shift);
+        return true;
+      }
+    }
   }
   if (mshl.right().IsInt32Sub()) {
     Int32BinopMatcher mshlright(mshl.right().node());

src/compiler/machine-node-factory.h

@@ -118,6 +118,13 @@ class MachineNodeFactory {
   Node* WordSar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordSar(), a, b);
   }
+  Node* WordRor(Node* a, Node* b) {
+    if (MACHINE()->is32()) {
+      return Word32Ror(a, b);
+    } else {
+      return Word64Ror(a, b);
+    }
+  }
   Node* WordEqual(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->WordEqual(), a, b);
   }
@@ -157,6 +164,10 @@ class MachineNodeFactory {
   Node* Word32Sar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Sar(), a, b);
   }
+  Node* Word32Ror(Node* a, Node* b) {
+    return Word32Or(Word32Shl(a, Int32Sub(Int32Constant(32), b)),
+                    Word32Shr(a, b));
+  }
   Node* Word32Equal(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word32Equal(), a, b);
   }
@@ -184,6 +195,10 @@ class MachineNodeFactory {
   Node* Word64Sar(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Sar(), a, b);
   }
+  Node* Word64Ror(Node* a, Node* b) {
+    return Word64Or(Word64Shl(a, Int64Sub(Int64Constant(64), b)),
+                    Word64Shr(a, b));
+  }
   Node* Word64Equal(Node* a, Node* b) {
     return NEW_NODE_2(MACHINE()->Word64Equal(), a, b);
   }

test/cctest/cctest.gyp

@@ -57,7 +57,6 @@
         'compiler/test-codegen-deopt.cc',
         'compiler/test-gap-resolver.cc',
         'compiler/test-graph-reducer.cc',
-        'compiler/test-instruction-selector.cc',
         'compiler/test-instruction.cc',
         'compiler/test-js-context-specialization.cc',
         'compiler/test-js-constant-cache.cc',
@@ -167,7 +166,6 @@
       'conditions': [
         ['v8_target_arch=="ia32"', {
           'sources': [  ### gcmole(arch:ia32) ###
-            'compiler/test-instruction-selector-ia32.cc',
             'test-assembler-ia32.cc',
             'test-code-stubs.cc',
             'test-code-stubs-ia32.cc',
@@ -188,7 +186,6 @@
         }],
         ['v8_target_arch=="arm"', {
           'sources': [  ### gcmole(arch:arm) ###
-            'compiler/test-instruction-selector-arm.cc',
             'test-assembler-arm.cc',
             'test-code-stubs.cc',
             'test-code-stubs-arm.cc',
@@ -198,7 +195,6 @@
         }],
         ['v8_target_arch=="arm64"', {
           'sources': [  ### gcmole(arch:arm64) ###
-            'compiler/test-instruction-selector-arm64.cc',
             'test-utils-arm64.cc',
             'test-assembler-arm64.cc',
             'test-code-stubs.cc',

test/cctest/compiler/test-instruction-selector-arm64.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 <list>
-
-#include "test/cctest/compiler/instruction-selector-tester.h"
-
-using namespace v8::internal;
-using namespace v8::internal::compiler;
-
-namespace {
-
-struct DPI {
-  Operator* op;
-  ArchOpcode arch_opcode;
-};
-
-
-// ARM64 Logical instructions.
-class LogicalInstructions V8_FINAL : public std::list<DPI>,
-                                     private HandleAndZoneScope {
- public:
-  LogicalInstructions() {
-    MachineOperatorBuilder machine(main_zone());
-    DPI and32 = {machine.Word32And(), kArm64And32};
-    push_back(and32);
-    DPI and64 = {machine.Word64And(), kArm64And};
-    push_back(and64);
-    DPI or32 = {machine.Word32Or(), kArm64Or32};
-    push_back(or32);
-    DPI or64 = {machine.Word64Or(), kArm64Or};
-    push_back(or64);
-    DPI xor32 = {machine.Word32Xor(), kArm64Xor32};
-    push_back(xor32);
-    DPI xor64 = {machine.Word64Xor(), kArm64Xor};
-    push_back(xor64);
-  }
-};
-
-
-// ARM64 Arithmetic instructions.
-class AddSubInstructions V8_FINAL : public std::list<DPI>,
-                                    private HandleAndZoneScope {
- public:
-  AddSubInstructions() {
-    MachineOperatorBuilder machine(main_zone());
-    DPI add32 = {machine.Int32Add(), kArm64Add32};
-    push_back(add32);
-    DPI add64 = {machine.Int64Add(), kArm64Add};
-    push_back(add64);
-    DPI sub32 = {machine.Int32Sub(), kArm64Sub32};
-    push_back(sub32);
-    DPI sub64 = {machine.Int64Sub(), kArm64Sub};
-    push_back(sub64);
-  }
-};
-
-
-// ARM64 Add/Sub immediates.
-class AddSubImmediates V8_FINAL : public std::list<int32_t> {
- public:
-  AddSubImmediates() {
-    for (int32_t imm12 = 0; imm12 < 4096; ++imm12) {
-      CHECK(Assembler::IsImmAddSub(imm12));
-      CHECK(Assembler::IsImmAddSub(imm12 << 12));
-      push_back(imm12);
-      push_back(imm12 << 12);
-    }
-  }
-};
-
-
-// ARM64 Arithmetic instructions.
-class MulDivInstructions V8_FINAL : public std::list<DPI>,
-                                    private HandleAndZoneScope {
- public:
-  MulDivInstructions() {
-    MachineOperatorBuilder machine(main_zone());
-    DPI mul32 = {machine.Int32Mul(), kArm64Mul32};
-    push_back(mul32);
-    DPI mul64 = {machine.Int64Mul(), kArm64Mul};
-    push_back(mul64);
-    DPI sdiv32 = {machine.Int32Div(), kArm64Idiv32};
-    push_back(sdiv32);
-    DPI sdiv64 = {machine.Int64Div(), kArm64Idiv};
-    push_back(sdiv64);
-    DPI udiv32 = {machine.Int32UDiv(), kArm64Udiv32};
-    push_back(udiv32);
-    DPI udiv64 = {machine.Int64UDiv(), kArm64Udiv};
-    push_back(udiv64);
-  }
-};
-
-}  // namespace
-
-
-TEST(InstructionSelectorLogicalP) {
-  LogicalInstructions instructions;
-  for (LogicalInstructions::const_iterator i = instructions.begin();
-       i != instructions.end(); ++i) {
-    DPI dpi = *i;
-    InstructionSelectorTester m;
-    m.Return(m.NewNode(dpi.op, m.Parameter(0), m.Parameter(1)));
-    m.SelectInstructions();
-    CHECK_EQ(1, m.code.size());
-    CHECK_EQ(dpi.arch_opcode, m.code[0]->arch_opcode());
-  }
-}
-
-
-TEST(InstructionSelectorAddSubP) {
-  AddSubInstructions instructions;
-  for (AddSubInstructions::const_iterator i = instructions.begin();
-       i != instructions.end(); ++i) {
-    DPI dpi = *i;
-    InstructionSelectorTester m;
-    m.Return(m.NewNode(dpi.op, m.Parameter(0), m.Parameter(1)));
-    m.SelectInstructions();
-    CHECK_EQ(1, m.code.size());
-    CHECK_EQ(dpi.arch_opcode, m.code[0]->arch_opcode());
-  }
-}
-
-
-TEST(InstructionSelectorAddSubImm) {
-  AddSubInstructions instructions;
-  AddSubImmediates immediates;
-  for (AddSubInstructions::const_iterator i = instructions.begin();
-       i != instructions.end(); ++i) {
-    DPI dpi = *i;
-    for (AddSubImmediates::const_iterator j = immediates.begin();
-         j != immediates.end(); ++j) {
-      int32_t imm = *j;
-      InstructionSelectorTester m;
-      m.Return(m.NewNode(dpi.op, m.Parameter(0), m.Int32Constant(imm)));
-      m.SelectInstructions();
-      CHECK_EQ(1, m.code.size());
-      CHECK_EQ(dpi.arch_opcode, m.code[0]->arch_opcode());
-      CHECK(m.code[0]->InputAt(1)->IsImmediate());
-    }
-  }
-}
-
-
-TEST(InstructionSelectorMulDivP) {
-  MulDivInstructions instructions;
-  for (MulDivInstructions::const_iterator i = instructions.begin();
-       i != instructions.end(); ++i) {
-    DPI dpi = *i;
-    InstructionSelectorTester m;
-    m.Return(m.NewNode(dpi.op, m.Parameter(0), m.Parameter(1)));
-    m.SelectInstructions();
-    CHECK_EQ(1, m.code.size());
-    CHECK_EQ(dpi.arch_opcode, m.code[0]->arch_opcode());
-  }
-}

test/cctest/compiler/test-instruction-selector-ia32.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 "test/cctest/compiler/instruction-selector-tester.h"
-#include "test/cctest/compiler/value-helper.h"
-
-using namespace v8::internal;
-using namespace v8::internal::compiler;
-
-TEST(InstructionSelectorInt32AddP) {
-  InstructionSelectorTester m;
-  m.Return(m.Int32Add(m.Parameter(0), m.Parameter(1)));
-  m.SelectInstructions();
-  CHECK_EQ(1, m.code.size());
-  CHECK_EQ(kIA32Add, m.code[0]->arch_opcode());
-}
-
-
-TEST(InstructionSelectorInt32AddImm) {
-  FOR_INT32_INPUTS(i) {
-    int32_t imm = *i;
-    {
-      InstructionSelectorTester m;
-      m.Return(m.Int32Add(m.Parameter(0), m.Int32Constant(imm)));
-      m.SelectInstructions();
-      CHECK_EQ(1, m.code.size());
-      CHECK_EQ(kIA32Add, m.code[0]->arch_opcode());
-      CHECK_EQ(2, m.code[0]->InputCount());
-      CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-    }
-    {
-      InstructionSelectorTester m;
-      m.Return(m.Int32Add(m.Int32Constant(imm), m.Parameter(0)));
-      m.SelectInstructions();
-      CHECK_EQ(1, m.code.size());
-      CHECK_EQ(kIA32Add, m.code[0]->arch_opcode());
-      CHECK_EQ(2, m.code[0]->InputCount());
-      CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-    }
-  }
-}
-
-
-TEST(InstructionSelectorInt32SubP) {
-  InstructionSelectorTester m;
-  m.Return(m.Int32Sub(m.Parameter(0), m.Parameter(1)));
-  m.SelectInstructions();
-  CHECK_EQ(1, m.code.size());
-  CHECK_EQ(kIA32Sub, m.code[0]->arch_opcode());
-  CHECK_EQ(1, m.code[0]->OutputCount());
-}
-
-
-TEST(InstructionSelectorInt32SubImm) {
-  FOR_INT32_INPUTS(i) {
-    int32_t imm = *i;
-    InstructionSelectorTester m;
-    m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(imm)));
-    m.SelectInstructions();
-    CHECK_EQ(1, m.code.size());
-    CHECK_EQ(kIA32Sub, m.code[0]->arch_opcode());
-    CHECK_EQ(2, m.code[0]->InputCount());
-    CHECK_EQ(imm, m.ToInt32(m.code[0]->InputAt(1)));
-  }
-}

test/cctest/compiler/test-instruction-selector.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 "test/cctest/compiler/instruction-selector-tester.h"
-
-using namespace v8::internal;
-using namespace v8::internal::compiler;
-
-#if V8_TURBOFAN_TARGET
-
-TEST(InstructionSelectionReturnZero) {
-  InstructionSelectorTester m;
-  m.Return(m.Int32Constant(0));
-  m.SelectInstructions(InstructionSelectorTester::kInternalMode);
-  CHECK_EQ(2, static_cast<int>(m.code.size()));
-  CHECK_EQ(kArchNop, m.code[0]->opcode());
-  CHECK_EQ(kArchRet, m.code[1]->opcode());
-  CHECK_EQ(1, static_cast<int>(m.code[1]->InputCount()));
-}
-
-#endif  // !V8_TURBOFAN_TARGET

test/compiler-unittests/DEPS

 include_rules = [
   "+src",
   "+testing/gtest",
-  "+testing/gtest-type-names.h",
+  "+testing/gtest-support.h",
   "+testing/gmock",
 ]

test/compiler-unittests/arm64/instruction-selector-arm64-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 <list>
+
+#include "test/compiler-unittests/instruction-selector-unittest.h"
+
+#include "test/cctest/compiler/instruction-selector-tester.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+namespace {
+
+typedef Node* (RawMachineAssembler::*Constructor)(Node*, Node*);
+
+struct DPI {
+  Constructor constructor;
+  const char* constructor_name;
+  ArchOpcode arch_opcode;
+};
+
+
+std::ostream& operator<<(std::ostream& os, const DPI& dpi) {
+  return os << dpi.constructor_name;
+}
+
+
+// ARM64 Logical instructions.
+static const DPI kLogicalInstructions[] = {
+    {&RawMachineAssembler::Word32And, "Word32And", kArm64And32},
+    {&RawMachineAssembler::Word64And, "Word64And", kArm64And},
+    {&RawMachineAssembler::Word32Or, "Word32Or", kArm64Or32},
+    {&RawMachineAssembler::Word64Or, "Word64Or", kArm64Or},
+    {&RawMachineAssembler::Word32Xor, "Word32Xor", kArm64Xor32},
+    {&RawMachineAssembler::Word64Xor, "Word64Xor", kArm64Xor}};
+
+
+// ARM64 Arithmetic instructions.
+static const DPI kAddSubInstructions[] = {
+    {&RawMachineAssembler::Int32Add, "Int32Add", kArm64Add32},
+    {&RawMachineAssembler::Int64Add, "Int64Add", kArm64Add},
+    {&RawMachineAssembler::Int32Sub, "Int32Sub", kArm64Sub32},
+    {&RawMachineAssembler::Int64Sub, "Int64Sub", kArm64Sub}};
+
+
+// ARM64 Add/Sub immediates.
+// TODO(all): Test only a subset of the immediates, similar to what we do for
+// arm. Unit tests should be really fast!
+class AddSubImmediates V8_FINAL : public std::list<int32_t> {
+ public:
+  AddSubImmediates() {
+    for (int32_t imm12 = 0; imm12 < 4096; ++imm12) {
+      CHECK(Assembler::IsImmAddSub(imm12));
+      CHECK(Assembler::IsImmAddSub(imm12 << 12));
+      push_back(imm12);
+      push_back(imm12 << 12);
+    }
+  }
+};
+
+
+// ARM64 Mul/Div instructions.
+static const DPI kMulDivInstructions[] = {
+    {&RawMachineAssembler::Int32Mul, "Int32Mul", kArm64Mul32},
+    {&RawMachineAssembler::Int64Mul, "Int64Mul", kArm64Mul},
+    {&RawMachineAssembler::Int32Div, "Int32Div", kArm64Idiv32},
+    {&RawMachineAssembler::Int64Div, "Int64Div", kArm64Idiv},
+    {&RawMachineAssembler::Int32UDiv, "Int32UDiv", kArm64Udiv32},
+    {&RawMachineAssembler::Int64UDiv, "Int64UDiv", kArm64Udiv}};
+
+}  // namespace
+
+
+// TODO(all): Use TEST_P, see instruction-selector-arm-unittest.cc.
+TEST_F(InstructionSelectorTest, LogicalWithParameter) {
+  TRACED_FOREACH(DPI, dpi, kLogicalInstructions) {
+    StreamBuilder m(this, kMachineWord32, kMachineWord32, kMachineWord32);
+    m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+    Stream s = m.Build();
+    ASSERT_EQ(1U, s.size());
+    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+  }
+}
+
+
+// TODO(all): Use TEST_P, see instruction-selector-arm-unittest.cc.
+TEST_F(InstructionSelectorTest, AddSubWithParameter) {
+  TRACED_FOREACH(DPI, dpi, kAddSubInstructions) {
+    StreamBuilder m(this, kMachineWord32, kMachineWord32, kMachineWord32);
+    m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+    Stream s = m.Build();
+    ASSERT_EQ(1U, s.size());
+    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+  }
+}
+
+
+// TODO(all): Use TEST_P, see instruction-selector-arm-unittest.cc.
+TEST_F(InstructionSelectorTest, AddSubWithImmediate) {
+  AddSubImmediates immediates;
+  TRACED_FOREACH(DPI, dpi, kAddSubInstructions) {
+    for (AddSubImmediates::const_iterator j = immediates.begin();
+         j != immediates.end(); ++j) {
+      int32_t imm = *j;
+      SCOPED_TRACE(::testing::Message() << "imm = " << imm);
+      StreamBuilder m(this, kMachineWord32, kMachineWord32);
+      m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
+      Stream s = m.Build();
+      ASSERT_EQ(1U, s.size());
+      EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+      EXPECT_TRUE(s[0]->InputAt(1)->IsImmediate());
+    }
+  }
+}
+
+
+// TODO(all): Use TEST_P, see instruction-selector-arm-unittest.cc.
+TEST_F(InstructionSelectorTest, MulDivWithParameter) {
+  TRACED_FOREACH(DPI, dpi, kMulDivInstructions) {
+    StreamBuilder m(this, kMachineWord32, kMachineWord32, kMachineWord32);
+    m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
+    Stream s = m.Build();
+    ASSERT_EQ(1U, s.size());
+    EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
+  }
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

test/compiler-unittests/change-lowering-unittest.cc

@@ -10,7 +10,6 @@
 #include "src/factory.h"
 #include "test/compiler-unittests/compiler-unittests.h"
 #include "test/compiler-unittests/node-matchers.h"
-#include "testing/gtest-type-names.h"
 
 using testing::_;
 

test/compiler-unittests/compiler-unittests.gyp

@@ -32,6 +32,16 @@
             'arm/instruction-selector-arm-unittest.cc',
           ],
         }],
+        ['v8_target_arch=="arm64"', {
+          'sources': [  ### gcmole(arch:arm64) ###
+            'arm64/instruction-selector-arm64-unittest.cc',
+          ],
+        }],
+        ['v8_target_arch=="ia32"', {
+          'sources': [  ### gcmole(arch:ia32) ###
+            'ia32/instruction-selector-ia32-unittest.cc',
+          ],
+        }],
         ['component=="shared_library"', {
           # compiler-unittests can't be built against a shared library, so we
           # need to depend on the underlying static target in that case.

test/compiler-unittests/compiler-unittests.h

@@ -7,7 +7,7 @@
 
 #include "include/v8.h"
 #include "src/zone.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/gtest-support.h"
 
 namespace v8 {
 namespace internal {

test/compiler-unittests/ia32/instruction-selector-ia32-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 "test/compiler-unittests/instruction-selector-unittest.h"
+
+namespace v8 {
+namespace internal {
+namespace compiler {
+
+namespace {
+
+// Immediates (random subset).
+static const int32_t kImmediates[] = {
+    kMinInt, -42, -1, 0,  1,  2,    3,      4,          5,
+    6,       7,   8,  16, 42, 0xff, 0xffff, 0x0f0f0f0f, kMaxInt};
+
+}  // namespace
+
+
+TEST_F(InstructionSelectorTest, Int32AddWithParameter) {
+  StreamBuilder m(this, kMachineWord32, kMachineWord32, kMachineWord32);
+  m.Return(m.Int32Add(m.Parameter(0), m.Parameter(1)));
+  Stream s = m.Build();
+  ASSERT_EQ(1U, s.size());
+  EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
+}
+
+
+TEST_F(InstructionSelectorTest, Int32AddWithImmediate) {
+  TRACED_FOREACH(int32_t, imm, kImmediates) {
+    {
+      StreamBuilder m(this, kMachineWord32, kMachineWord32);
+      m.Return(m.Int32Add(m.Parameter(0), m.Int32Constant(imm)));
+      Stream s = m.Build();
+      ASSERT_EQ(1U, s.size());
+      EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
+      ASSERT_EQ(2U, s[0]->InputCount());
+      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+    }
+    {
+      StreamBuilder m(this, kMachineWord32, kMachineWord32);
+      m.Return(m.Int32Add(m.Int32Constant(imm), m.Parameter(0)));
+      Stream s = m.Build();
+      ASSERT_EQ(1U, s.size());
+      EXPECT_EQ(kIA32Add, s[0]->arch_opcode());
+      ASSERT_EQ(2U, s[0]->InputCount());
+      EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+    }
+  }
+}
+
+
+TEST_F(InstructionSelectorTest, Int32SubWithParameter) {
+  StreamBuilder m(this, kMachineWord32, kMachineWord32, kMachineWord32);
+  m.Return(m.Int32Sub(m.Parameter(0), m.Parameter(1)));
+  Stream s = m.Build();
+  ASSERT_EQ(1U, s.size());
+  EXPECT_EQ(kIA32Sub, s[0]->arch_opcode());
+  EXPECT_EQ(1U, s[0]->OutputCount());
+}
+
+
+TEST_F(InstructionSelectorTest, Int32SubWithImmediate) {
+  TRACED_FOREACH(int32_t, imm, kImmediates) {
+    StreamBuilder m(this, kMachineWord32, kMachineWord32);
+    m.Return(m.Int32Sub(m.Parameter(0), m.Int32Constant(imm)));
+    Stream s = m.Build();
+    ASSERT_EQ(1U, s.size());
+    EXPECT_EQ(kIA32Sub, s[0]->arch_opcode());
+    ASSERT_EQ(2U, s[0]->InputCount());
+    EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
+  }
+}
+
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8

test/compiler-unittests/instruction-selector-unittest.cc

@@ -4,14 +4,23 @@
 
 #include "test/compiler-unittests/instruction-selector-unittest.h"
 
+#include "src/flags.h"
+
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+InstructionSelectorTest::InstructionSelectorTest() : rng_(FLAG_random_seed) {}
+
+
 InstructionSelectorTest::Stream InstructionSelectorTest::StreamBuilder::Build(
     InstructionSelector::Features features,
     InstructionSelectorTest::StreamBuilderMode mode) {
   Schedule* schedule = Export();
+  if (FLAG_trace_turbo) {
+    OFStream out(stdout);
+    out << "=== Schedule before instruction selection ===" << endl << *schedule;
+  }
   EXPECT_NE(0, graph()->NodeCount());
   CompilationInfo info(test_->isolate(), test_->zone());
   Linkage linkage(&info, call_descriptor());
@@ -21,7 +30,7 @@ InstructionSelectorTest::Stream InstructionSelectorTest::StreamBuilder::Build(
   selector.SelectInstructions();
   if (FLAG_trace_turbo) {
     OFStream out(stdout);
-    out << "--- Code sequence after instruction selection ---" << endl
+    out << "=== Code sequence after instruction selection ===" << endl
         << sequence;
   }
   Stream s;
@@ -62,7 +71,7 @@ InstructionSelectorTest::Stream InstructionSelectorTest::StreamBuilder::Build(
 }
 
 
-TARGET_TEST_F(InstructionSelectorTest, ReturnP) {
+TARGET_TEST_F(InstructionSelectorTest, ReturnParameter) {
   StreamBuilder m(this, kMachineWord32, kMachineWord32);
   m.Return(m.Parameter(0));
   Stream s = m.Build(kAllInstructions);
@@ -74,7 +83,7 @@ TARGET_TEST_F(InstructionSelectorTest, ReturnP) {
 }
 
 
-TARGET_TEST_F(InstructionSelectorTest, ReturnImm) {
+TARGET_TEST_F(InstructionSelectorTest, ReturnZero) {
   StreamBuilder m(this, kMachineWord32);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build(kAllInstructions);

test/compiler-unittests/instruction-selector-unittest.h

@@ -6,7 +6,9 @@
 #define V8_COMPILER_UNITTESTS_INSTRUCTION_SELECTOR_UNITTEST_H_
 
 #include <deque>
+#include <ostream>  // NOLINT(readability/streams)
 
+#include "src/base/utils/random-number-generator.h"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "test/compiler-unittests/compiler-unittests.h"
@@ -17,9 +19,11 @@ namespace compiler {
 
 class InstructionSelectorTest : public CompilerTest {
  public:
-  InstructionSelectorTest() {}
+  InstructionSelectorTest();
   virtual ~InstructionSelectorTest() {}
 
+  base::RandomNumberGenerator* rng() { return &rng_; }
+
  protected:
   class Stream;
 
@@ -44,6 +48,14 @@ class InstructionSelectorTest : public CompilerTest {
               CallDescriptorBuilder(test->zone(), return_type, parameter0_type,
                                     parameter1_type)),
           test_(test) {}
+    StreamBuilder(InstructionSelectorTest* test, MachineType return_type,
+                  MachineType parameter0_type, MachineType parameter1_type,
+                  MachineType parameter2_type)
+        : RawMachineAssembler(
+              new (test->zone()) Graph(test->zone()),
+              CallDescriptorBuilder(test->zone(), return_type, parameter0_type,
+                                    parameter1_type, parameter2_type)),
+          test_(test) {}
 
     Stream Build(CpuFeature feature) {
       return Build(InstructionSelector::Features(feature));
@@ -81,6 +93,17 @@ class InstructionSelectorTest : public CompilerTest {
           MachineCallDescriptorBuilder(return_type, 2, parameter_types);
     }
 
+    MachineCallDescriptorBuilder* CallDescriptorBuilder(
+        Zone* zone, MachineType return_type, MachineType parameter0_type,
+        MachineType parameter1_type, MachineType parameter2_type) {
+      MachineType* parameter_types = zone->NewArray<MachineType>(3);
+      parameter_types[0] = parameter0_type;
+      parameter_types[1] = parameter1_type;
+      parameter_types[2] = parameter2_type;
+      return new (zone)
+          MachineCallDescriptorBuilder(return_type, 3, parameter_types);
+    }
+
    private:
     InstructionSelectorTest* test_;
   };
@@ -97,6 +120,11 @@ class InstructionSelectorTest : public CompilerTest {
       return ToConstant(operand).ToInt32();
     }
 
+    int ToVreg(const InstructionOperand* operand) const {
+      EXPECT_EQ(InstructionOperand::UNALLOCATED, operand->kind());
+      return UnallocatedOperand::cast(operand)->virtual_register();
+    }
+
    private:
     Constant ToConstant(const InstructionOperand* operand) const {
       ConstantMap::const_iterator i;
@@ -120,8 +148,16 @@ class InstructionSelectorTest : public CompilerTest {
     ConstantMap immediates_;
     std::deque<Instruction*> instructions_;
   };
+
+  base::RandomNumberGenerator rng_;
 };
 
+
+template <typename T>
+class InstructionSelectorTestWithParam
+    : public InstructionSelectorTest,
+      public ::testing::WithParamInterface<T> {};
+
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8

testing/gtest-support.h

+// 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.
+
+#ifndef V8_TESTING_GTEST_SUPPORT_H_
+#define V8_TESTING_GTEST_SUPPORT_H_
+
+#include "include/v8stdint.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace testing {
+namespace internal {
+
+#define GET_TYPE_NAME(type)                \
+  template <>                              \
+  inline std::string GetTypeName<type>() { \
+    return #type;                          \
+  }
+GET_TYPE_NAME(int8_t)
+GET_TYPE_NAME(uint8_t)
+GET_TYPE_NAME(int16_t)
+GET_TYPE_NAME(uint16_t)
+GET_TYPE_NAME(int32_t)
+GET_TYPE_NAME(uint32_t)
+GET_TYPE_NAME(int64_t)
+GET_TYPE_NAME(uint64_t)
+GET_TYPE_NAME(float)
+GET_TYPE_NAME(double)
+#undef GET_TYPE_NAME
+
+
+// TRACED_FOREACH(type, var, array) expands to a loop that assigns |var| every
+// item in the |array| and adds a SCOPED_TRACE() message for the |var| while
+// inside the loop body.
+// TODO(bmeurer): Migrate to C++11 once we're ready.
+#define TRACED_FOREACH(_type, _var, _array)                                \
+  for (size_t _i = 0; _i < ARRAY_SIZE(_array); ++_i)                       \
+    for (bool _done = false; !_done;)                                      \
+      for (const _type _var = _array[_i]; !_done;)                         \
+        for (SCOPED_TRACE(::testing::Message() << #_var << " = " << _var); \
+             !_done; _done = true)
+
+
+// TRACED_FORRANGE(type, var, low, high) expands to a loop that assigns |var|
+// every value in the range |low| to (including) |high| and adds a
+// SCOPED_TRACE() message for the |var| while inside the loop body.
+// TODO(bmeurer): Migrate to C++11 once we're ready.
+#define TRACED_FORRANGE(_type, _var, _low, _high)                          \
+  for (_type _i = _low; _i <= _high; ++_i)                                 \
+    for (bool _done = false; !_done;)                                      \
+      for (const _type _var = _i; !_done;)                                 \
+        for (SCOPED_TRACE(::testing::Message() << #_var << " = " << _var); \
+             !_done; _done = true)
+
+}  // namespace internal
+}  // namespace testing
+
+#endif  // V8_TESTING_GTEST_SUPPORT_H_

testing/gtest-type-names.h

-// 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.
-
-#ifndef V8_TESTING_GTEST_TYPE_NAMES_H_
-#define V8_TESTING_GTEST_TYPE_NAMES_H_
-
-#include "include/v8stdint.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace testing {
-namespace internal {
-
-#define GET_TYPE_NAME(type)         \
-  template <>                       \
-  std::string GetTypeName<type>() { \
-    return #type;                   \
-  }
-GET_TYPE_NAME(int8_t)
-GET_TYPE_NAME(uint8_t)
-GET_TYPE_NAME(int16_t)
-GET_TYPE_NAME(uint16_t)
-GET_TYPE_NAME(int32_t)
-GET_TYPE_NAME(uint32_t)
-GET_TYPE_NAME(int64_t)
-GET_TYPE_NAME(uint64_t)
-GET_TYPE_NAME(float)
-GET_TYPE_NAME(double)
-#undef GET_TYPE_NAME
-
-}  // namespace internal
-}  // namespace testing
-
-#endif  // V8_TESTING_GTEST_TYPE_NAMES_H_

testing/gtest.gyp

@@ -37,7 +37,7 @@
         'gtest/src/gtest-test-part.cc',
         'gtest/src/gtest-typed-test.cc',
         'gtest/src/gtest.cc',
-        'gtest-type-names.h',
+        'gtest-support.h',
       ],
       'sources!': [
         'gtest/src/gtest-all.cc',  # Not needed by our build.