Refactor BasicBlock, no inheritance from GenericNode

test/cctest/compiler/test-scheduler.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 "src/v8.h"
 #include "test/cctest/cctest.h"
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/generic-node-inl.h"
 #include "src/compiler/generic-node.h"
@@ skipping 26 matching lines @@
   loop->nodes = new BasicBlock* [count];
   for (int i = 0; i < count; i++) {
     loop->nodes[i] = schedule->NewBasicBlock();
     if (i > 0) schedule->AddSuccessor(loop->nodes[i - 1], loop->nodes[i]);
   }
   schedule->AddSuccessor(loop->nodes[count - 1], loop->nodes[0]);
   return loop;
 }
 
 
-static void CheckRPONumbers(BasicBlockVector* order, int expected,
+static void CheckRPONumbers(BasicBlockVector* order, size_t expected,
                             bool loops_allowed) {
-  CHECK_EQ(expected, static_cast<int>(order->size()));
+  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) CHECK_LT(order->at(i)->loop_end_, 0);
+    CHECK(order->at(i)->rpo_number() == i);
+    if (!loops_allowed) CHECK_LT(order->at(i)->loop_end(), 0);
   }
 }
 
 
 static void CheckLoopContains(BasicBlock** blocks, int body_size) {
   BasicBlock* header = blocks[0];
-  CHECK_GT(header->loop_end_, 0);
-  CHECK_EQ(body_size, (header->loop_end_ - header->rpo_number_));
+  CHECK_GT(header->loop_end(), 0);
+  CHECK_EQ(body_size, (header->loop_end() - header->rpo_number()));
   for (int i = 0; i < body_size; i++) {
-    int num = blocks[i]->rpo_number_;
-    CHECK(num >= header->rpo_number_ && num < header->loop_end_);
+    int num = blocks[i]->rpo_number();
+    CHECK(num >= header->rpo_number() && num < header->loop_end());
     CHECK(header->LoopContains(blocks[i]));
-    CHECK(header->IsLoopHeader() || blocks[i]->loop_header_ == header);
+    CHECK(header->IsLoopHeader() || blocks[i]->loop_header() == header);
   }
 }
 
 
 static int GetScheduledNodeCount(Schedule* schedule) {
   int node_count = 0;
   for (BasicBlockVectorIter i = schedule->rpo_order()->begin();
        i != schedule->rpo_order()->end(); ++i) {
     BasicBlock* block = *i;
     for (BasicBlock::const_iterator j = block->begin(); j != block->end();
          ++j) {
       ++node_count;
     }
-    BasicBlock::Control control = block->control_;
+    BasicBlock::Control control = block->control();
     if (control != BasicBlock::kNone) {
       ++node_count;
     }
   }
   return node_count;
 }
 
 
 static Schedule* ComputeAndVerifySchedule(int expected, Graph* graph) {
   if (FLAG_trace_turbo) {
@@ skipping 43 matching lines @@
 
     BasicBlock* last = schedule.start();
     for (int j = 0; j < i; j++) {
       BasicBlock* block = schedule.NewBasicBlock();
       schedule.AddGoto(last, block);
       last = block;
     }
     BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
     CheckRPONumbers(order, 1 + i, false);
 
-    Schedule::BasicBlocks blocks(schedule.all_blocks());
-    for (Schedule::BasicBlocks::iterator iter = blocks.begin();
-         iter != blocks.end(); ++iter) {
-      BasicBlock* block = *iter;
-      if (block->rpo_number_ >= 0 && block->SuccessorCount() == 1) {
-        CHECK(block->rpo_number_ + 1 == block->SuccessorAt(0)->rpo_number_);
+    for (size_t i = 0; i < schedule.BasicBlockCount(); i++) {
+      BasicBlock* block = schedule.GetBlockById(BasicBlock::Id::FromSize(i));
+      if (block->rpo_number() >= 0 && block->SuccessorCount() == 1) {
+        CHECK(block->rpo_number() + 1 == block->SuccessorAt(0)->rpo_number());
       }
     }
   }
 }
 
 
 TEST(RPOSelfLoop) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
   schedule.AddSuccessor(schedule.start(), schedule.start());
@@ skipping 49 matching lines @@
   BasicBlock* D = schedule.end();
 
   schedule.AddSuccessor(A, B);
   schedule.AddSuccessor(A, C);
   schedule.AddSuccessor(B, D);
   schedule.AddSuccessor(C, D);
 
   BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
   CheckRPONumbers(order, 4, false);
 
-  CHECK_EQ(0, A->rpo_number_);
-  CHECK((B->rpo_number_ == 1 && C->rpo_number_ == 2) ||
-        (B->rpo_number_ == 2 && C->rpo_number_ == 1));
-  CHECK_EQ(3, D->rpo_number_);
+  CHECK_EQ(0, A->rpo_number());
+  CHECK((B->rpo_number() == 1 && C->rpo_number() == 2) ||
+        (B->rpo_number() == 2 && C->rpo_number() == 1));
+  CHECK_EQ(3, D->rpo_number());
 }
 
 
 TEST(RPOLoop1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
 
   BasicBlock* A = schedule.start();
   BasicBlock* B = schedule.NewBasicBlock();
   BasicBlock* C = schedule.NewBasicBlock();
@@ skipping 153 matching lines @@
   BasicBlock* E = schedule.end();
 
   schedule.AddSuccessor(A, loop1->header());
   schedule.AddSuccessor(loop1->header(), loop2->header());
   schedule.AddSuccessor(loop2->last(), E);
 
   BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
-  CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
+  CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+           static_cast<int>(order->size()));
   CheckLoopContains(loop1->nodes, loop1->count);
   CheckLoopContains(loop2->nodes, loop2->count);
 }
 
 
 TEST(RPOLoopFollow2) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
 
   SmartPointer<TestLoop> loop1(CreateLoop(&schedule, 1));
   SmartPointer<TestLoop> loop2(CreateLoop(&schedule, 1));
 
   BasicBlock* A = schedule.start();
   BasicBlock* S = schedule.NewBasicBlock();
   BasicBlock* E = schedule.end();
 
   schedule.AddSuccessor(A, loop1->header());
   schedule.AddSuccessor(loop1->header(), S);
   schedule.AddSuccessor(S, loop2->header());
   schedule.AddSuccessor(loop2->last(), E);
 
   BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
-  CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
+  CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+           static_cast<int>(order->size()));
   CheckLoopContains(loop1->nodes, loop1->count);
   CheckLoopContains(loop2->nodes, loop2->count);
 }
 
 
 TEST(RPOLoopFollowN) {
   HandleAndZoneScope scope;
 
   for (int size = 1; size < 5; size++) {
     for (int exit = 0; exit < size; exit++) {
       Schedule schedule(scope.main_zone());
       SmartPointer<TestLoop> loop1(CreateLoop(&schedule, size));
       SmartPointer<TestLoop> loop2(CreateLoop(&schedule, size));
       BasicBlock* A = schedule.start();
       BasicBlock* E = schedule.end();
 
       schedule.AddSuccessor(A, loop1->header());
       schedule.AddSuccessor(loop1->nodes[exit], loop2->header());
       schedule.AddSuccessor(loop2->nodes[exit], E);
       BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
       CheckLoopContains(loop1->nodes, loop1->count);
 
-      CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
+      CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+               static_cast<int>(order->size()));
       CheckLoopContains(loop1->nodes, loop1->count);
       CheckLoopContains(loop2->nodes, loop2->count);
     }
   }
 }
 
 
 TEST(RPONestedLoopFollow1) {
   HandleAndZoneScope scope;
   Schedule schedule(scope.main_zone());
@@ skipping 10 matching lines @@
   schedule.AddSuccessor(B, loop1->header());
   schedule.AddSuccessor(loop1->header(), loop2->header());
   schedule.AddSuccessor(loop2->last(), C);
   schedule.AddSuccessor(C, E);
   schedule.AddSuccessor(C, B);
 
   BasicBlockVector* order = Scheduler::ComputeSpecialRPO(&schedule);
 
   CheckLoopContains(loop1->nodes, loop1->count);
 
-  CHECK_EQ(schedule.BasicBlockCount(), static_cast<int>(order->size()));
+  CHECK_EQ(static_cast<int>(schedule.BasicBlockCount()),
+           static_cast<int>(order->size()));
   CheckLoopContains(loop1->nodes, loop1->count);
   CheckLoopContains(loop2->nodes, loop2->count);
 
   BasicBlock* loop3[] = {B, loop1->nodes[0], loop2->nodes[0], C};
   CheckLoopContains(loop3, 4);
 }
 
 
 TEST(RPOLoopBackedges1) {
   HandleAndZoneScope scope;
@@ skipping 1218 matching lines @@
   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);
 }
 
 #endif