AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

[turbofan] Refactor the InstructionSelector tests.

Browse Source 
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
This commit is contained in:
bmeurer@chromium.org 2014-08-14 06:33:50 +00:00
parent 76a49573f3
commit f4b5224ae9
19 changed files with 2069 additions and 2163 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
src/compiler/arm/instruction-selector-arm.cc
View File

@ -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());

15
src/compiler/machine-node-factory.h
View File

@ -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);
}

4
test/cctest/cctest.gyp
View File

@ -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',

1863
test/cctest/compiler/test-instruction-selector-arm.cc
View File

File diff suppressed because it is too large Load Diff

157
test/cctest/compiler/test-instruction-selector-arm64.cc
View File

@ -1,157 +0,0 @@
// 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());
}
}

66
test/cctest/compiler/test-instruction-selector-ia32.cc
View File

@ -1,66 +0,0 @@
// 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)));
}
}

22
test/cctest/compiler/test-instruction-selector.cc
View File

@ -1,22 +0,0 @@
// 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

2
test/compiler-unittests/DEPS
View File

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

1711
test/compiler-unittests/arm/instruction-selector-arm-unittest.cc
View File

File diff suppressed because it is too large Load Diff

133
test/compiler-unittests/arm64/instruction-selector-arm64-unittest.cc Normal file
View File

@ -0,0 +1,133 @@
// 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

1
test/compiler-unittests/change-lowering-unittest.cc
View File

@ -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::_;

10
test/compiler-unittests/compiler-unittests.gyp
View File

@ -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.

2
test/compiler-unittests/compiler-unittests.h
View File

@ -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 {

78
test/compiler-unittests/ia32/instruction-selector-ia32-unittest.cc Normal file
View File

@ -0,0 +1,78 @@
// 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

15
test/compiler-unittests/instruction-selector-unittest.cc
View File

@ -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);

38
test/compiler-unittests/instruction-selector-unittest.h
View File

@ -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

58
testing/gtest-support.h Normal file
View File

@ -0,0 +1,58 @@
// 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_

34
testing/gtest-type-names.h
View File

@ -1,34 +0,0 @@
// 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_

2
testing/gtest.gyp
View File

@ -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.