Refactor BasicBlock, no inheritance from GenericNode

src/compiler/register-allocator.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/register-allocator.h"
 
+#include "src/compiler/generic-node-inl.h"
 #include "src/compiler/linkage.h"
 #include "src/hydrogen.h"
 #include "src/string-stream.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 static inline LifetimePosition Min(LifetimePosition a, LifetimePosition b) {
   return a.Value() < b.Value() ? a : b;
@@ skipping 506 matching lines @@
 }
 
 
 BitVector* RegisterAllocator::ComputeLiveOut(BasicBlock* block) {
   // Compute live out for the given block, except not including backward
   // successor edges.
   BitVector* live_out =
       new (zone()) BitVector(code()->VirtualRegisterCount(), zone());
 
   // Process all successor blocks.
-  BasicBlock::Successors successors = block->successors();
-  for (BasicBlock::Successors::iterator i = successors.begin();
-       i != successors.end(); ++i) {
+  for (BasicBlock::Successors::iterator i = block->successors_begin();
+       i != block->successors_end(); ++i) {
     // Add values live on entry to the successor. Note the successor's
     // live_in will not be computed yet for backwards edges.
     BasicBlock* successor = *i;
-    BitVector* live_in = live_in_sets_[successor->rpo_number_];
+    BitVector* live_in = live_in_sets_[successor->rpo_number()];
     if (live_in != NULL) live_out->Union(*live_in);
 
     // All phi input operands corresponding to this successor edge are live
     // out from this block.
-    int index = successor->PredecessorIndexOf(block);
-    DCHECK(index >= 0);
-    DCHECK(index < static_cast<int>(successor->PredecessorCount()));
+    size_t index = successor->PredecessorIndexOf(block);
+    DCHECK(index < successor->PredecessorCount());
     for (BasicBlock::const_iterator j = successor->begin();
          j != successor->end(); ++j) {
       Node* phi = *j;
       if (phi->opcode() != IrOpcode::kPhi) continue;
-      Node* input = phi->InputAt(index);
+      Node* input = phi->InputAt(static_cast<int>(index));
       live_out->Add(input->id());
     }
   }
 
   return live_out;
 }
 
 
 void RegisterAllocator::AddInitialIntervals(BasicBlock* block,
                                             BitVector* live_out) {
@@ skipping 203 matching lines @@
     bool assigned = false;
     if (output->HasFixedPolicy()) {
       AllocateFixed(output, -1, false);
       // This value is produced on the stack, we never need to spill it.
       if (output->IsStackSlot()) {
         range->SetSpillOperand(output);
         range->SetSpillStartIndex(end);
         assigned = true;
       }
 
-      BasicBlock::Successors successors = block->successors();
-      for (BasicBlock::Successors::iterator succ = successors.begin();
-           succ != successors.end(); ++succ) {
+      for (BasicBlock::Successors::iterator succ = block->successors_begin();
+           succ != block->successors_end(); ++succ) {
         DCHECK((*succ)->PredecessorCount() == 1);
         int gap_index = (*succ)->first_instruction_index() + 1;
         DCHECK(code()->IsGapAt(gap_index));
 
         // Create an unconstrained operand for the same virtual register
         // and insert a gap move from the fixed output to the operand.
         UnallocatedOperand* output_copy =
             new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY);
         output_copy->set_virtual_register(output_vreg);
 
         code()->AddGapMove(gap_index, output, output_copy);
       }
     }
 
     if (!assigned) {
-      BasicBlock::Successors successors = block->successors();
-      for (BasicBlock::Successors::iterator succ = successors.begin();
-           succ != successors.end(); ++succ) {
+      for (BasicBlock::Successors::iterator succ = block->successors_begin();
+           succ != block->successors_end(); ++succ) {
         DCHECK((*succ)->PredecessorCount() == 1);
         int gap_index = (*succ)->first_instruction_index() + 1;
         range->SetSpillStartIndex(gap_index);
 
         // This move to spill operand is not a real use. Liveness analysis
         // and splitting of live ranges do not account for it.
         // Thus it should be inserted to a lifetime position corresponding to
         // the instruction end.
         GapInstruction* gap = code()->GapAt(gap_index);
         ParallelMove* move =
@@ skipping 258 matching lines @@
 
 void RegisterAllocator::ResolvePhis(BasicBlock* block) {
   for (BasicBlock::const_iterator i = block->begin(); i != block->end(); ++i) {
     Node* phi = *i;
     if (phi->opcode() != IrOpcode::kPhi) continue;
 
     UnallocatedOperand* phi_operand =
         new (code_zone()) UnallocatedOperand(UnallocatedOperand::NONE);
     phi_operand->set_virtual_register(phi->id());
 
-    int j = 0;
+    size_t j = 0;
     Node::Inputs inputs = phi->inputs();
     for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
          ++iter, ++j) {
       Node* op = *iter;
       // TODO(mstarzinger): Use a ValueInputIterator instead.
       if (j >= block->PredecessorCount()) continue;
       UnallocatedOperand* operand =
           new (code_zone()) UnallocatedOperand(UnallocatedOperand::ANY);
       operand->set_virtual_register(op->id());
       BasicBlock* cur_block = block->PredecessorAt(j);
@@ skipping 161 matching lines @@
 
       first_range = second_range;
       second_range = second_range->next();
     }
   }
 }
 
 
 bool RegisterAllocator::CanEagerlyResolveControlFlow(BasicBlock* block) const {
   if (block->PredecessorCount() != 1) return false;
-  return block->PredecessorAt(0)->rpo_number_ == block->rpo_number_ - 1;
+  return block->PredecessorAt(0)->rpo_number() == block->rpo_number() - 1;
 }
 
 
 void RegisterAllocator::ResolveControlFlow() {
   RegisterAllocatorPhase phase("L_Resolve control flow", this);
   for (int block_id = 1; block_id < code()->BasicBlockCount(); ++block_id) {
     BasicBlock* block = code()->BlockAt(block_id);
     if (CanEagerlyResolveControlFlow(block)) continue;
-    BitVector* live = live_in_sets_[block->rpo_number_];
+    BitVector* live = live_in_sets_[block->rpo_number()];
     BitVector::Iterator iterator(live);
     while (!iterator.Done()) {
       int operand_index = iterator.Current();
-      BasicBlock::Predecessors predecessors = block->predecessors();
-      for (BasicBlock::Predecessors::iterator i = predecessors.begin();
-           i != predecessors.end(); ++i) {
+      for (BasicBlock::Predecessors::iterator i = block->predecessors_begin();
+           i != block->predecessors_end(); ++i) {
         BasicBlock* cur = *i;
         LiveRange* cur_range = LiveRangeFor(operand_index);
         ResolveControlFlow(cur_range, block, cur);
       }
       iterator.Advance();
     }
   }
 }
 
 
@@ skipping 49 matching lines @@
     // out on backward successor edges.
     live_in_sets_[block_id] = live;
 
     if (block->IsLoopHeader()) {
       // Add a live range stretching from the first loop instruction to the last
       // for each value live on entry to the header.
       BitVector::Iterator iterator(live);
       LifetimePosition start = LifetimePosition::FromInstructionIndex(
           block->first_instruction_index());
       int end_index =
-          code()->BlockAt(block->loop_end_)->last_instruction_index();
+          code()->BlockAt(block->loop_end())->last_instruction_index();
       LifetimePosition end =
           LifetimePosition::FromInstructionIndex(end_index).NextInstruction();
       while (!iterator.Done()) {
         int operand_index = iterator.Current();
         LiveRange* range = LiveRangeFor(operand_index);
         range->EnsureInterval(start, end, zone());
         iterator.Advance();
       }
 
       // Insert all values into the live in sets of all blocks in the loop.
-      for (int i = block->rpo_number_ + 1; i < block->loop_end_; ++i) {
+      for (int i = block->rpo_number() + 1; i < block->loop_end(); ++i) {
         live_in_sets_[i]->Union(*live);
       }
     }
 
 #ifdef DEBUG
     if (block_id == 0) {
       BitVector::Iterator iterator(live);
       bool found = false;
       while (!iterator.Done()) {
         found = true;
@@ skipping 728 matching lines @@
   if (end_block == start_block) {
     // The interval is split in the same basic block. Split at the latest
     // possible position.
     return end;
   }
 
   BasicBlock* block = end_block;
   // Find header of outermost loop.
   // TODO(titzer): fix redundancy below.
   while (code()->GetContainingLoop(block) != NULL &&
-         code()->GetContainingLoop(block)->rpo_number_ >
-             start_block->rpo_number_) {
+         code()->GetContainingLoop(block)->rpo_number() >
+             start_block->rpo_number()) {
     block = code()->GetContainingLoop(block);
   }
 
   // We did not find any suitable outer loop. Split at the latest possible
   // position unless end_block is a loop header itself.
   if (block == end_block && !end_block->IsLoopHeader()) return end;
 
   return LifetimePosition::FromInstructionIndex(
       block->first_instruction_index());
 }
@@ skipping 111 matching lines @@
                     allocator_zone_start_allocation_size_;
     isolate()->GetTStatistics()->SaveTiming(name(), base::TimeDelta(), size);
   }
 #ifdef DEBUG
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 }
 }
 }  // namespace v8::internal::compiler