[turbofan] Some cleanup for scheduler unittests.

test/unittests/compiler/scheduler-unittest.cc

-// Copyright 2014 the V8 project authors. All rights reserved.
+// Copyright 2015 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 "src/v8.h"
-
 #include "src/compiler/access-builder.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/graph-visualizer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/node.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 #include "src/compiler/schedule.h"
 #include "src/compiler/scheduler.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/verifier.h"
+#include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/test-utils.h"
 
-using namespace v8::internal;
-using namespace v8::internal::compiler;
+namespace v8 {
+namespace internal {
+namespace compiler {
 
-namespace {
-
-class SchedulerTest : public virtual TestWithZone {
+class SchedulerTest : public TestWithZone {
  public:
   SchedulerTest()
-      : TestWithZone(),
-        graph_(zone()),
-        common_(zone()),
-        simplified_(zone()),
-        js_(zone()) {}
+      : graph_(zone()), common_(zone()), simplified_(zone()), js_(zone()) {}
 
   static Schedule* ComputeAndVerifySchedule(int expected, Graph* graph) {
     if (FLAG_trace_turbo) {
       OFStream os(stdout);
       os << AsDOT(*graph);
     }
 
     Schedule* schedule = Scheduler::ComputeSchedule(graph->zone(), graph);
 
     if (FLAG_trace_turbo_scheduler) {
@@ skipping 19 matching lines @@
   SimplifiedOperatorBuilder* simplified() { return &simplified_; }
   JSOperatorBuilder* js() { return &js_; }
 
  private:
   Graph graph_;
   CommonOperatorBuilder common_;
   SimplifiedOperatorBuilder simplified_;
   JSOperatorBuilder js_;
 };
 
-class SchedulerRPOTest : public virtual SchedulerTest {
+
+class SchedulerRPOTest : public SchedulerTest {
  public:
   SchedulerRPOTest() {}
 
   // TODO(titzer): pull RPO tests out to their own file.
   static void CheckRPONumbers(BasicBlockVector* order, size_t expected,
                               bool loops_allowed) {
     CHECK(expected == order->size());
     for (int i = 0; i < static_cast<int>(order->size()); i++) {
       CHECK(order->at(i)->rpo_number() == i);
       if (!loops_allowed) {
@@ skipping 42 matching lines @@
       loop->nodes[i] = schedule->NewBasicBlock();
       if (i > 0) {
         schedule->AddSuccessorForTesting(loop->nodes[i - 1], loop->nodes[i]);
       }
     }
     schedule->AddSuccessorForTesting(loop->nodes[count - 1], loop->nodes[0]);
     return loop;
   }
 };
 
-class SchedulerTestWithIsolate : public virtual SchedulerTest,
-                                 public virtual TestWithIsolate {
+
+class SchedulerTestWithIsolate : public SchedulerTest, public TestWithIsolate {
  public:
   SchedulerTestWithIsolate() {}
 
   Unique<HeapObject> GetUniqueUndefined() {
     Handle<HeapObject> object =
         Handle<HeapObject>(isolate()->heap()->undefined_value(), isolate());
     return Unique<HeapObject>::CreateUninitialized(object);
   }
 };
 
-Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0, 0, 1,
-                 0, 0);
+namespace {
+
+const Operator kIntAdd(IrOpcode::kInt32Add, Operator::kPure, "Int32Add", 2, 0,
+                       0, 1, 0, 0);
 
 }  // namespace
 
 
 TEST_F(SchedulerTest, BuildScheduleEmpty) {
   graph()->SetStart(graph()->NewNode(common()->Start(0)));
   graph()->SetEnd(graph()->NewNode(common()->End(), graph()->start()));
   USE(Scheduler::ComputeSchedule(zone(), graph()));
 }
 
@@ skipping 1425 matching lines @@
   graph()->SetStart(n0);
   graph()->SetEnd(n22);
 
   Schedule* schedule = ComputeAndVerifySchedule(19, graph());
   // Make sure the integer-only add gets hoisted to a different block that the
   // JSAdd.
   CHECK(schedule->block(n19) != schedule->block(n20));
 }
 
 
-#if V8_TURBOFAN_TARGET
+namespace {
 
-static Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common,
-                           Node* cond) {
+Node* CreateDiamond(Graph* graph, CommonOperatorBuilder* common, Node* cond) {
   Node* tv = graph->NewNode(common->Int32Constant(6));
   Node* fv = graph->NewNode(common->Int32Constant(7));
   Node* br = graph->NewNode(common->Branch(), cond, graph->start());
   Node* t = graph->NewNode(common->IfTrue(), br);
   Node* f = graph->NewNode(common->IfFalse(), br);
   Node* m = graph->NewNode(common->Merge(2), t, f);
   Node* phi = graph->NewNode(common->Phi(kMachAnyTagged, 2), tv, fv, m);
   return phi;
 }
 
+}  // namespace
 
-TEST_F(SchedulerTest, FloatingDiamond1) {
+
+TARGET_TEST_F(SchedulerTest, FloatingDiamond1) {
   Node* start = graph()->NewNode(common()->Start(1));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* d1 = CreateDiamond(graph(), common(), p0);
   Node* ret = graph()->NewNode(common()->Return(), d1, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(13, graph());
 }
 
 
-TEST_F(SchedulerTest, FloatingDiamond2) {
+TARGET_TEST_F(SchedulerTest, FloatingDiamond2) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* p1 = graph()->NewNode(common()->Parameter(1), start);
   Node* d1 = CreateDiamond(graph(), common(), p0);
   Node* d2 = CreateDiamond(graph(), common(), p1);
   Node* add = graph()->NewNode(&kIntAdd, d1, d2);
   Node* ret = graph()->NewNode(common()->Return(), add, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(24, graph());
 }
 
 
-TEST_F(SchedulerTest, FloatingDiamond3) {
+TARGET_TEST_F(SchedulerTest, FloatingDiamond3) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* p1 = graph()->NewNode(common()->Parameter(1), start);
   Node* d1 = CreateDiamond(graph(), common(), p0);
   Node* d2 = CreateDiamond(graph(), common(), p1);
   Node* add = graph()->NewNode(&kIntAdd, d1, d2);
   Node* d3 = CreateDiamond(graph(), common(), add);
   Node* ret = graph()->NewNode(common()->Return(), d3, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(33, graph());
 }
 
 
-TEST_F(SchedulerTest, NestedFloatingDiamonds) {
+TARGET_TEST_F(SchedulerTest, NestedFloatingDiamonds) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
 
   Node* fv = graph()->NewNode(common()->Int32Constant(7));
   Node* br = graph()->NewNode(common()->Branch(), p0, graph()->start());
   Node* t = graph()->NewNode(common()->IfTrue(), br);
   Node* f = graph()->NewNode(common()->IfFalse(), br);
 
@@ skipping 16 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), phi, ephi1, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(23, graph());
 }
 
 
-TEST_F(SchedulerTest, NestedFloatingDiamondWithChain) {
+TARGET_TEST_F(SchedulerTest, NestedFloatingDiamondWithChain) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* p1 = graph()->NewNode(common()->Parameter(1), start);
   Node* c = graph()->NewNode(common()->Int32Constant(7));
 
   Node* brA1 = graph()->NewNode(common()->Branch(), p0, graph()->start());
   Node* tA1 = graph()->NewNode(common()->IfTrue(), brA1);
   Node* fA1 = graph()->NewNode(common()->IfFalse(), brA1);
@@ skipping 23 matching lines @@
   Node* add = graph()->NewNode(&kIntAdd, phiA2, phiB2);
   Node* ret = graph()->NewNode(common()->Return(), add, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(35, graph());
 }
 
 
-TEST_F(SchedulerTest, NestedFloatingDiamondWithLoop) {
+TARGET_TEST_F(SchedulerTest, NestedFloatingDiamondWithLoop) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
 
   Node* fv = graph()->NewNode(common()->Int32Constant(7));
   Node* br = graph()->NewNode(common()->Branch(), p0, graph()->start());
   Node* t = graph()->NewNode(common()->IfTrue(), br);
   Node* f = graph()->NewNode(common()->IfFalse(), br);
 
@@ skipping 13 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), phi, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(20, graph());
 }
 
 
-TEST_F(SchedulerTest, LoopedFloatingDiamond1) {
+TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond1) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
 
   Node* c = graph()->NewNode(common()->Int32Constant(7));
   Node* loop = graph()->NewNode(common()->Loop(2), start, start);
   Node* ind = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), p0, p0, loop);
   Node* add = graph()->NewNode(&kIntAdd, ind, c);
 
@@ skipping 12 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), ind, start, f);
   Node* end = graph()->NewNode(common()->End(), ret, f);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(20, graph());
 }
 
 
-TEST_F(SchedulerTest, LoopedFloatingDiamond2) {
+TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond2) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
 
   Node* c = graph()->NewNode(common()->Int32Constant(7));
   Node* loop = graph()->NewNode(common()->Loop(2), start, start);
   Node* ind = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), p0, p0, loop);
 
   Node* br1 = graph()->NewNode(common()->Branch(), p0, graph()->start());
@@ skipping 13 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), ind, start, f);
   Node* end = graph()->NewNode(common()->End(), ret, f);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(20, graph());
 }
 
 
-TEST_F(SchedulerTest, LoopedFloatingDiamond3) {
+TARGET_TEST_F(SchedulerTest, LoopedFloatingDiamond3) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
 
   Node* c = graph()->NewNode(common()->Int32Constant(7));
   Node* loop = graph()->NewNode(common()->Loop(2), start, start);
   Node* ind = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), p0, p0, loop);
 
   Node* br1 = graph()->NewNode(common()->Branch(), p0, graph()->start());
@@ skipping 25 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), ind, start, f);
   Node* end = graph()->NewNode(common()->End(), ret, f);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(28, graph());
 }
 
 
-TEST_F(SchedulerTest, PhisPushedDownToDifferentBranches) {
+TARGET_TEST_F(SchedulerTest, PhisPushedDownToDifferentBranches) {
   Node* start = graph()->NewNode(common()->Start(2));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* p1 = graph()->NewNode(common()->Parameter(1), start);
 
   Node* v1 = graph()->NewNode(common()->Int32Constant(1));
   Node* v2 = graph()->NewNode(common()->Int32Constant(2));
   Node* v3 = graph()->NewNode(common()->Int32Constant(3));
   Node* v4 = graph()->NewNode(common()->Int32Constant(4));
@@ skipping 13 matching lines @@
 
   Node* ret = graph()->NewNode(common()->Return(), phi3, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   ComputeAndVerifySchedule(24, graph());
 }
 
 
-TEST_F(SchedulerTest, BranchHintTrue) {
+TARGET_TEST_F(SchedulerTest, BranchHintTrue) {
   Node* start = graph()->NewNode(common()->Start(1));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* tv = graph()->NewNode(common()->Int32Constant(6));
   Node* fv = graph()->NewNode(common()->Int32Constant(7));
   Node* br = graph()->NewNode(common()->Branch(BranchHint::kTrue), p0, start);
   Node* t = graph()->NewNode(common()->IfTrue(), br);
   Node* f = graph()->NewNode(common()->IfFalse(), br);
   Node* m = graph()->NewNode(common()->Merge(2), t, f);
   Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), tv, fv, m);
   Node* ret = graph()->NewNode(common()->Return(), phi, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   Schedule* schedule = ComputeAndVerifySchedule(13, graph());
   // Make sure the false block is marked as deferred.
   CHECK(!schedule->block(t)->deferred());
   CHECK(schedule->block(f)->deferred());
 }
 
 
-TEST_F(SchedulerTest, BranchHintFalse) {
+TARGET_TEST_F(SchedulerTest, BranchHintFalse) {
   Node* start = graph()->NewNode(common()->Start(1));
   graph()->SetStart(start);
 
   Node* p0 = graph()->NewNode(common()->Parameter(0), start);
   Node* tv = graph()->NewNode(common()->Int32Constant(6));
   Node* fv = graph()->NewNode(common()->Int32Constant(7));
   Node* br = graph()->NewNode(common()->Branch(BranchHint::kFalse), p0, start);
   Node* t = graph()->NewNode(common()->IfTrue(), br);
   Node* f = graph()->NewNode(common()->IfFalse(), br);
   Node* m = graph()->NewNode(common()->Merge(2), t, f);
   Node* phi = graph()->NewNode(common()->Phi(kMachAnyTagged, 2), tv, fv, m);
   Node* ret = graph()->NewNode(common()->Return(), phi, start, start);
   Node* end = graph()->NewNode(common()->End(), ret, start);
 
   graph()->SetEnd(end);
 
   Schedule* schedule = ComputeAndVerifySchedule(13, graph());
   // Make sure the true block is marked as deferred.
   CHECK(schedule->block(t)->deferred());
   CHECK(!schedule->block(f)->deferred());
 }
 
 
-TEST_F(SchedulerTest, ScheduleTerminate) {
+TARGET_TEST_F(SchedulerTest, ScheduleTerminate) {
   Node* start = graph()->NewNode(common()->Start(1));
   graph()->SetStart(start);
 
   Node* loop = graph()->NewNode(common()->Loop(2), start, start);
   loop->ReplaceInput(1, loop);  // self loop, NTL.
 
   Node* effect = graph()->NewNode(common()->EffectPhi(1), start, loop);
   effect->ReplaceInput(0, effect);
 
   Node* terminate = graph()->NewNode(common()->Terminate(1), effect, loop);
   Node* end = graph()->NewNode(common()->End(), terminate);
 
   graph()->SetEnd(end);
 
   Schedule* schedule = ComputeAndVerifySchedule(6, graph());
   BasicBlock* block = schedule->block(loop);
   CHECK_NE(NULL, loop);
   CHECK_EQ(block, schedule->block(effect));
   CHECK_GE(block->rpo_number(), 0);
 }
 
-#endif
+}  // namespace compiler
+}  // namespace internal
+}  // namespace v8