Refactor BasicBlock, no inheritance from GenericNode

src/compiler/instruction.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/compiler/instruction.h"
 
 #include "src/compiler/common-operator.h"
+#include "src/compiler/generic-node-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 OStream& operator<<(OStream& os, const InstructionOperand& op) {
   switch (op.kind()) {
     case InstructionOperand::INVALID:
       return os << "(0)";
     case InstructionOperand::UNALLOCATED: {
@@ skipping 295 matching lines @@
   return os;
 }
 
 
 Label* InstructionSequence::GetLabel(BasicBlock* block) {
   return GetBlockStart(block)->label();
 }
 
 
 BlockStartInstruction* InstructionSequence::GetBlockStart(BasicBlock* block) {
-  return BlockStartInstruction::cast(InstructionAt(block->code_start_));
+  return BlockStartInstruction::cast(InstructionAt(block->code_start()));
 }
 
 
 void InstructionSequence::StartBlock(BasicBlock* block) {
-  block->code_start_ = static_cast<int>(instructions_.size());
+  block->set_code_start(static_cast<int>(instructions_.size()));
   BlockStartInstruction* block_start =
       BlockStartInstruction::New(zone(), block);
   AddInstruction(block_start, block);
 }
 
 
 void InstructionSequence::EndBlock(BasicBlock* block) {
   int end = static_cast<int>(instructions_.size());
-  DCHECK(block->code_start_ >= 0 && block->code_start_ < end);
-  block->code_end_ = end;
+  DCHECK(block->code_start() >= 0 && block->code_start() < end);
+  block->set_code_end(end);
 }
 
 
 int InstructionSequence::AddInstruction(Instruction* instr, BasicBlock* block) {
   // TODO(titzer): the order of these gaps is a holdover from Lithium.
   GapInstruction* gap = GapInstruction::New(zone());
   if (instr->IsControl()) instructions_.push_back(gap);
   int index = static_cast<int>(instructions_.size());
   instructions_.push_back(instr);
   if (!instr->IsControl()) instructions_.push_back(gap);
@@ skipping 71 matching lines @@
     os << "IMM#" << i << ": " << constant << "\n";
   }
   int i = 0;
   for (ConstantMap::const_iterator it = code.constants_.begin();
        it != code.constants_.end(); ++i, ++it) {
     os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
   }
   for (int i = 0; i < code.BasicBlockCount(); i++) {
     BasicBlock* block = code.BlockAt(i);
 
-    int bid = block->id();
-    os << "RPO#" << block->rpo_number_ << ": B" << bid;
-    CHECK(block->rpo_number_ == i);
+    os << "RPO#" << block->rpo_number() << ": B" << block->id();
+    CHECK(block->rpo_number() == i);
     if (block->IsLoopHeader()) {
-      os << " loop blocks: [" << block->rpo_number_ << ", " << block->loop_end_
-         << ")";
+      os << " loop blocks: [" << block->rpo_number() << ", "
+         << block->loop_end() << ")";
     }
-    os << "  instructions: [" << block->code_start_ << ", " << block->code_end_
-       << ")\n  predecessors:";
+    os << "  instructions: [" << block->code_start() << ", "
+       << block->code_end() << ")\n  predecessors:";
 
-    BasicBlock::Predecessors predecessors = block->predecessors();
-    for (BasicBlock::Predecessors::iterator iter = predecessors.begin();
-         iter != predecessors.end(); ++iter) {
+    for (BasicBlock::Predecessors::iterator iter = block->predecessors_begin();
+         iter != block->predecessors_end(); ++iter) {
       os << " B" << (*iter)->id();
     }
     os << "\n";
 
     for (BasicBlock::const_iterator j = block->begin(); j != block->end();
          ++j) {
       Node* phi = *j;
       if (phi->opcode() != IrOpcode::kPhi) continue;
       os << "     phi: v" << phi->id() << " =";
       Node::Inputs inputs = phi->inputs();
       for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
            ++iter) {
         os << " v" << (*iter)->id();
       }
       os << "\n";
     }
 
     ScopedVector<char> buf(32);
     for (int j = block->first_instruction_index();
          j <= block->last_instruction_index(); j++) {
       // TODO(svenpanne) Add some basic formatting to our streams.
       SNPrintF(buf, "%5d", j);
       os << "   " << buf.start() << ": " << *code.InstructionAt(j);
     }
 
-    os << "  " << block->control_;
+    os << "  " << block->control();
 
-    if (block->control_input_ != NULL) {
-      os << " v" << block->control_input_->id();
+    if (block->control_input() != NULL) {
+      os << " v" << block->control_input()->id();
     }
 
-    BasicBlock::Successors successors = block->successors();
-    for (BasicBlock::Successors::iterator iter = successors.begin();
-         iter != successors.end(); ++iter) {
+    for (BasicBlock::Successors::iterator iter = block->successors_begin();
+         iter != block->successors_end(); ++iter) {
       os << " B" << (*iter)->id();
     }
     os << "\n";
   }
   return os;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8