[turbofan] Split ConstraintBuilder off of LiveRangeBuilder.

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/base/adapters.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/register-allocator.h"
 #include "src/string-stream.h"
 
 namespace v8 {
@@ skipping 51 matching lines @@
 }
 
 
 bool IsBlockBoundary(const InstructionSequence* code, LifetimePosition pos) {
   return pos.IsFullStart() &&
          code->GetInstructionBlock(pos.ToInstructionIndex())->code_start() ==
              pos.ToInstructionIndex();
 }
 
 
+Instruction* GetLastInstruction(InstructionSequence* code,
+                                const InstructionBlock* block) {
+  return code->InstructionAt(block->last_instruction_index());
+}
+
 }  // namespace
 
 
 UsePosition::UsePosition(LifetimePosition pos, InstructionOperand* operand,
                          InstructionOperand* hint)
     : operand_(operand), hint_(hint), pos_(pos), next_(nullptr), flags_(0) {
   bool register_beneficial = true;
   UsePositionType type = UsePositionType::kAny;
   if (operand_ != nullptr && operand_->IsUnallocated()) {
     const UnallocatedOperand* unalloc = UnallocatedOperand::cast(operand_);
@@ skipping 744 matching lines @@
     assigned_registers_->Add(reg);
   }
   range->set_assigned_register(reg);
   auto assignment = range->GetAssignedOperand();
   // TODO(dcarney): stop aliasing hint operands.
   range->ConvertUsesToOperand(assignment, nullptr);
   if (range->is_phi()) AssignPhiInput(range, assignment);
 }
 
 
-LiveRangeBuilder::LiveRangeBuilder(RegisterAllocationData* data)
+ConstraintBuilder::ConstraintBuilder(RegisterAllocationData* data)
     : data_(data) {}
 
 
-BitVector* LiveRangeBuilder::ComputeLiveOut(const InstructionBlock* block) {
-  // Compute live out for the given block, except not including backward
-  // successor edges.
-  auto live_out = new (allocation_zone())
-      BitVector(code()->VirtualRegisterCount(), allocation_zone());
-
-  // Process all successor blocks.
-  for (auto succ : block->successors()) {
-    // Add values live on entry to the successor. Note the successor's
-    // live_in will not be computed yet for backwards edges.
-    auto live_in = live_in_sets()[succ.ToSize()];
-    if (live_in != nullptr) live_out->Union(*live_in);
-
-    // All phi input operands corresponding to this successor edge are live
-    // out from this block.
-    auto successor = code()->InstructionBlockAt(succ);
-    size_t index = successor->PredecessorIndexOf(block->rpo_number());
-    DCHECK(index < successor->PredecessorCount());
-    for (auto phi : successor->phis()) {
-      live_out->Add(phi->operands()[index]);
-    }
-  }
-  return live_out;
-}
-
-
-void LiveRangeBuilder::AddInitialIntervals(const InstructionBlock* block,
-                                           BitVector* live_out) {
-  // Add an interval that includes the entire block to the live range for
-  // each live_out value.
-  auto start = LifetimePosition::GapFromInstructionIndex(
-      block->first_instruction_index());
-  auto end = LifetimePosition::InstructionFromInstructionIndex(
-                 block->last_instruction_index()).NextStart();
-  BitVector::Iterator iterator(live_out);
-  while (!iterator.Done()) {
-    int operand_index = iterator.Current();
-    auto range = LiveRangeFor(operand_index);
-    range->AddUseInterval(start, end, allocation_zone());
-    iterator.Advance();
-  }
-}
-
-
-Instruction* LiveRangeBuilder::GetLastInstruction(
-    const InstructionBlock* block) {
-  return code()->InstructionAt(block->last_instruction_index());
-}
-
-
-int LiveRangeBuilder::FixedDoubleLiveRangeID(int index) {
-  return -index - 1 - config()->num_general_registers();
-}
-
-
-InstructionOperand* LiveRangeBuilder::AllocateFixed(UnallocatedOperand* operand,
-                                                    int pos, bool is_tagged) {
+InstructionOperand* ConstraintBuilder::AllocateFixed(
+    UnallocatedOperand* operand, int pos, bool is_tagged) {
   TRACE("Allocating fixed reg for op %d\n", operand->virtual_register());
   DCHECK(operand->HasFixedPolicy());
   InstructionOperand allocated;
   if (operand->HasFixedSlotPolicy()) {
     allocated = AllocatedOperand(AllocatedOperand::STACK_SLOT,
                                  operand->fixed_slot_index());
   } else if (operand->HasFixedRegisterPolicy()) {
     allocated = AllocatedOperand(AllocatedOperand::REGISTER,
                                  operand->fixed_register_index());
   } else if (operand->HasFixedDoubleRegisterPolicy()) {
     allocated = AllocatedOperand(AllocatedOperand::DOUBLE_REGISTER,
                                  operand->fixed_register_index());
   } else {
     UNREACHABLE();
   }
   InstructionOperand::ReplaceWith(operand, &allocated);
   if (is_tagged) {
     TRACE("Fixed reg is tagged at %d\n", pos);
     auto instr = InstructionAt(pos);
     if (instr->HasReferenceMap()) {
       instr->reference_map()->RecordReference(*operand);
     }
   }
   return operand;
 }
 
 
-LiveRange* LiveRangeBuilder::FixedLiveRangeFor(int index) {
-  DCHECK(index < config()->num_general_registers());
-  auto result = fixed_live_ranges()[index];
-  if (result == nullptr) {
-    result = data()->NewLiveRange(FixedLiveRangeID(index));
-    DCHECK(result->IsFixed());
-    result->set_kind(GENERAL_REGISTERS);
-    data()->SetLiveRangeAssignedRegister(result, index);
-    fixed_live_ranges()[index] = result;
-  }
-  return result;
-}
-
-
-LiveRange* LiveRangeBuilder::FixedDoubleLiveRangeFor(int index) {
-  DCHECK(index < config()->num_aliased_double_registers());
-  auto result = fixed_double_live_ranges()[index];
-  if (result == nullptr) {
-    result = data()->NewLiveRange(FixedDoubleLiveRangeID(index));
-    DCHECK(result->IsFixed());
-    result->set_kind(DOUBLE_REGISTERS);
-    data()->SetLiveRangeAssignedRegister(result, index);
-    fixed_double_live_ranges()[index] = result;
-  }
-  return result;
-}
-
-
-LiveRange* LiveRangeBuilder::LiveRangeFor(InstructionOperand* operand) {
-  if (operand->IsUnallocated()) {
-    return LiveRangeFor(UnallocatedOperand::cast(operand)->virtual_register());
-  } else if (operand->IsConstant()) {
-    return LiveRangeFor(ConstantOperand::cast(operand)->virtual_register());
-  } else if (operand->IsRegister()) {
-    return FixedLiveRangeFor(RegisterOperand::cast(operand)->index());
-  } else if (operand->IsDoubleRegister()) {
-    return FixedDoubleLiveRangeFor(
-        DoubleRegisterOperand::cast(operand)->index());
-  } else {
-    return nullptr;
+void ConstraintBuilder::MeetRegisterConstraints() {
+  for (auto block : code()->instruction_blocks()) {
+    MeetRegisterConstraints(block);
   }
 }
 
 
-void LiveRangeBuilder::Define(LifetimePosition position,
-                              InstructionOperand* operand,
-                              InstructionOperand* hint) {
-  auto range = LiveRangeFor(operand);
-  if (range == nullptr) return;
-
-  if (range->IsEmpty() || range->Start().Value() > position.Value()) {
-    // Can happen if there is a definition without use.
-    range->AddUseInterval(position, position.NextStart(), allocation_zone());
-    range->AddUsePosition(position.NextStart(), nullptr, nullptr,
-                          allocation_zone());
-  } else {
-    range->ShortenTo(position);
-  }
-
-  if (operand->IsUnallocated()) {
-    auto unalloc_operand = UnallocatedOperand::cast(operand);
-    range->AddUsePosition(position, unalloc_operand, hint, allocation_zone());
-  }
-}
-
-
-void LiveRangeBuilder::Use(LifetimePosition block_start,
-                           LifetimePosition position,
-                           InstructionOperand* operand,
-                           InstructionOperand* hint) {
-  auto range = LiveRangeFor(operand);
-  if (range == nullptr) return;
-  if (operand->IsUnallocated()) {
-    UnallocatedOperand* unalloc_operand = UnallocatedOperand::cast(operand);
-    range->AddUsePosition(position, unalloc_operand, hint, allocation_zone());
-  }
-  range->AddUseInterval(block_start, position, allocation_zone());
-}
-
-
-void LiveRangeBuilder::MeetRegisterConstraints(const InstructionBlock* block) {
+void ConstraintBuilder::MeetRegisterConstraints(const InstructionBlock* block) {
   int start = block->first_instruction_index();
   int end = block->last_instruction_index();
   DCHECK_NE(-1, start);
   for (int i = start; i <= end; ++i) {
     MeetConstraintsBefore(i);
     if (i != end) MeetConstraintsAfter(i);
   }
   // Meet register constraints for the instruction in the end.
   MeetRegisterConstraintsForLastInstructionInBlock(block);
 }
 
 
-void LiveRangeBuilder::MeetRegisterConstraintsForLastInstructionInBlock(
+void ConstraintBuilder::MeetRegisterConstraintsForLastInstructionInBlock(
     const InstructionBlock* block) {
   int end = block->last_instruction_index();
   auto last_instruction = InstructionAt(end);
   for (size_t i = 0; i < last_instruction->OutputCount(); i++) {
     auto output_operand = last_instruction->OutputAt(i);
     DCHECK(!output_operand->IsConstant());
     auto output = UnallocatedOperand::cast(output_operand);
     int output_vreg = output->virtual_register();
     auto range = LiveRangeFor(output_vreg);
     bool assigned = false;
@@ skipping 25 matching lines @@
         DCHECK(successor->PredecessorCount() == 1);
         int gap_index = successor->first_instruction_index();
         range->SpillAtDefinition(allocation_zone(), gap_index, output);
         range->SetSpillStartIndex(gap_index);
       }
     }
   }
 }
 
 
-void LiveRangeBuilder::MeetConstraintsAfter(int instr_index) {
+void ConstraintBuilder::MeetConstraintsAfter(int instr_index) {
   auto first = InstructionAt(instr_index);
   // Handle fixed temporaries.
   for (size_t i = 0; i < first->TempCount(); i++) {
     auto temp = UnallocatedOperand::cast(first->TempAt(i));
     if (temp->HasFixedPolicy()) AllocateFixed(temp, instr_index, false);
   }
   // Handle constant/fixed output operands.
   for (size_t i = 0; i < first->OutputCount(); i++) {
     InstructionOperand* output = first->OutputAt(i);
     if (output->IsConstant()) {
@@ skipping 27 matching lines @@
     // so already).
     if (!assigned) {
       range->SpillAtDefinition(allocation_zone(), instr_index + 1,
                                first_output);
       range->SetSpillStartIndex(instr_index + 1);
     }
   }
 }
 
 
-void LiveRangeBuilder::MeetConstraintsBefore(int instr_index) {
+void ConstraintBuilder::MeetConstraintsBefore(int instr_index) {
   auto second = InstructionAt(instr_index);
   // Handle fixed input operands of second instruction.
   for (size_t i = 0; i < second->InputCount(); i++) {
     auto input = second->InputAt(i);
     if (input->IsImmediate()) continue;  // Ignore immediates.
     auto cur_input = UnallocatedOperand::cast(input);
     if (cur_input->HasFixedPolicy()) {
       int input_vreg = cur_input->virtual_register();
       UnallocatedOperand input_copy(UnallocatedOperand::ANY, input_vreg);
       bool is_tagged = IsReference(input_vreg);
@@ skipping 24 matching lines @@
       // before the pointer map can be used. I.e. the pointer map at the
       // instruction will include the output operand (whose value at the
       // beginning of the instruction is equal to the input operand). If
       // this is not desired, then the pointer map at this instruction needs
       // to be adjusted manually.
     }
   }
 }
 
 
+void ConstraintBuilder::ResolvePhis() {
+  // Process the blocks in reverse order.
+  for (InstructionBlock* block : base::Reversed(code()->instruction_blocks())) {
+    ResolvePhis(block);
+  }
+}
+
+
+void ConstraintBuilder::ResolvePhis(const InstructionBlock* block) {
+  for (auto phi : block->phis()) {
+    int phi_vreg = phi->virtual_register();
+    auto map_value = new (allocation_zone())
+        RegisterAllocationData::PhiMapValue(phi, block, allocation_zone());
+    auto res = data()->phi_map().insert(std::make_pair(phi_vreg, map_value));
+    DCHECK(res.second);
+    USE(res);
+    auto& output = phi->output();
+    for (size_t i = 0; i < phi->operands().size(); ++i) {
+      InstructionBlock* cur_block =
+          code()->InstructionBlockAt(block->predecessors()[i]);
+      UnallocatedOperand input(UnallocatedOperand::ANY, phi->operands()[i]);
+      auto move = data()->AddGapMove(cur_block->last_instruction_index(),
+                                     Instruction::END, input, output);
+      map_value->incoming_moves.push_back(move);
+      DCHECK(!InstructionAt(cur_block->last_instruction_index())
+                  ->HasReferenceMap());
+    }
+    auto live_range = LiveRangeFor(phi_vreg);
+    int gap_index = block->first_instruction_index();
+    live_range->SpillAtDefinition(allocation_zone(), gap_index, &output);
+    live_range->SetSpillStartIndex(gap_index);
+    // We use the phi-ness of some nodes in some later heuristics.
+    live_range->set_is_phi(true);
+    live_range->set_is_non_loop_phi(!block->IsLoopHeader());
+  }
+}
+
+
+LiveRangeBuilder::LiveRangeBuilder(RegisterAllocationData* data)
+    : data_(data) {}
+
+
+BitVector* LiveRangeBuilder::ComputeLiveOut(const InstructionBlock* block) {
+  // Compute live out for the given block, except not including backward
+  // successor edges.
+  auto live_out = new (allocation_zone())
+      BitVector(code()->VirtualRegisterCount(), allocation_zone());
+
+  // Process all successor blocks.
+  for (auto succ : block->successors()) {
+    // Add values live on entry to the successor. Note the successor's
+    // live_in will not be computed yet for backwards edges.
+    auto live_in = live_in_sets()[succ.ToSize()];
+    if (live_in != nullptr) live_out->Union(*live_in);
+
+    // All phi input operands corresponding to this successor edge are live
+    // out from this block.
+    auto successor = code()->InstructionBlockAt(succ);
+    size_t index = successor->PredecessorIndexOf(block->rpo_number());
+    DCHECK(index < successor->PredecessorCount());
+    for (auto phi : successor->phis()) {
+      live_out->Add(phi->operands()[index]);
+    }
+  }
+  return live_out;
+}
+
+
+void LiveRangeBuilder::AddInitialIntervals(const InstructionBlock* block,
+                                           BitVector* live_out) {
+  // Add an interval that includes the entire block to the live range for
+  // each live_out value.
+  auto start = LifetimePosition::GapFromInstructionIndex(
+      block->first_instruction_index());
+  auto end = LifetimePosition::InstructionFromInstructionIndex(
+                 block->last_instruction_index()).NextStart();
+  BitVector::Iterator iterator(live_out);
+  while (!iterator.Done()) {
+    int operand_index = iterator.Current();
+    auto range = LiveRangeFor(operand_index);
+    range->AddUseInterval(start, end, allocation_zone());
+    iterator.Advance();
+  }
+}
+
+
+int LiveRangeBuilder::FixedDoubleLiveRangeID(int index) {
+  return -index - 1 - config()->num_general_registers();
+}
+
+
+LiveRange* LiveRangeBuilder::FixedLiveRangeFor(int index) {
+  DCHECK(index < config()->num_general_registers());
+  auto result = data()->fixed_live_ranges()[index];
+  if (result == nullptr) {
+    result = data()->NewLiveRange(FixedLiveRangeID(index));
+    DCHECK(result->IsFixed());
+    result->set_kind(GENERAL_REGISTERS);
+    data()->SetLiveRangeAssignedRegister(result, index);
+    data()->fixed_live_ranges()[index] = result;
+  }
+  return result;
+}
+
+
+LiveRange* LiveRangeBuilder::FixedDoubleLiveRangeFor(int index) {
+  DCHECK(index < config()->num_aliased_double_registers());
+  auto result = data()->fixed_double_live_ranges()[index];
+  if (result == nullptr) {
+    result = data()->NewLiveRange(FixedDoubleLiveRangeID(index));
+    DCHECK(result->IsFixed());
+    result->set_kind(DOUBLE_REGISTERS);
+    data()->SetLiveRangeAssignedRegister(result, index);
+    data()->fixed_double_live_ranges()[index] = result;
+  }
+  return result;
+}
+
+
+LiveRange* LiveRangeBuilder::LiveRangeFor(InstructionOperand* operand) {
+  if (operand->IsUnallocated()) {
+    return LiveRangeFor(UnallocatedOperand::cast(operand)->virtual_register());
+  } else if (operand->IsConstant()) {
+    return LiveRangeFor(ConstantOperand::cast(operand)->virtual_register());
+  } else if (operand->IsRegister()) {
+    return FixedLiveRangeFor(RegisterOperand::cast(operand)->index());
+  } else if (operand->IsDoubleRegister()) {
+    return FixedDoubleLiveRangeFor(
+        DoubleRegisterOperand::cast(operand)->index());
+  } else {
+    return nullptr;
+  }
+}
+
+
+void LiveRangeBuilder::Define(LifetimePosition position,
+                              InstructionOperand* operand,
+                              InstructionOperand* hint) {
+  auto range = LiveRangeFor(operand);
+  if (range == nullptr) return;
+
+  if (range->IsEmpty() || range->Start().Value() > position.Value()) {
+    // Can happen if there is a definition without use.
+    range->AddUseInterval(position, position.NextStart(), allocation_zone());
+    range->AddUsePosition(position.NextStart(), nullptr, nullptr,
+                          allocation_zone());
+  } else {
+    range->ShortenTo(position);
+  }
+
+  if (operand->IsUnallocated()) {
+    auto unalloc_operand = UnallocatedOperand::cast(operand);
+    range->AddUsePosition(position, unalloc_operand, hint, allocation_zone());
+  }
+}
+
+
+void LiveRangeBuilder::Use(LifetimePosition block_start,
+                           LifetimePosition position,
+                           InstructionOperand* operand,
+                           InstructionOperand* hint) {
+  auto range = LiveRangeFor(operand);
+  if (range == nullptr) return;
+  if (operand->IsUnallocated()) {
+    UnallocatedOperand* unalloc_operand = UnallocatedOperand::cast(operand);
+    range->AddUsePosition(position, unalloc_operand, hint, allocation_zone());
+  }
+  range->AddUseInterval(block_start, position, allocation_zone());
+}
+
+
 bool LiveRangeBuilder::IsOutputRegisterOf(Instruction* instr, int index) {
   for (size_t i = 0; i < instr->OutputCount(); i++) {
     auto output = instr->OutputAt(i);
     if (output->IsRegister() && RegisterOperand::cast(output)->index() == index)
       return true;
   }
   return false;
 }
 
 
@@ skipping 11 matching lines @@
 void LiveRangeBuilder::ProcessInstructions(const InstructionBlock* block,
                                            BitVector* live) {
   int block_start = block->first_instruction_index();
   auto block_start_position =
       LifetimePosition::GapFromInstructionIndex(block_start);
 
   for (int index = block->last_instruction_index(); index >= block_start;
        index--) {
     auto curr_position =
         LifetimePosition::InstructionFromInstructionIndex(index);
-    auto instr = InstructionAt(index);
+    auto instr = code()->InstructionAt(index);
     DCHECK(instr != nullptr);
     DCHECK(curr_position.IsInstructionPosition());
     // Process output, inputs, and temps of this instruction.
     for (size_t i = 0; i < instr->OutputCount(); i++) {
       auto output = instr->OutputAt(i);
       if (output->IsUnallocated()) {
         // Unsupported.
         DCHECK(!UnallocatedOperand::cast(output)->HasSlotPolicy());
         int out_vreg = UnallocatedOperand::cast(output)->virtual_register();
         live->Remove(out_vreg);
@@ skipping 103 matching lines @@
         Use(block_start_position, curr_position, &from, hint);
         if (from.IsUnallocated()) {
           live->Add(UnallocatedOperand::cast(from).virtual_register());
         }
       }
     }
   }
 }
 
 
-void LiveRangeBuilder::ResolvePhis(const InstructionBlock* block) {
-  for (auto phi : block->phis()) {
-    int phi_vreg = phi->virtual_register();
-    auto map_value = new (allocation_zone())
-        RegisterAllocationData::PhiMapValue(phi, block, allocation_zone());
-    auto res = phi_map().insert(std::make_pair(phi_vreg, map_value));
-    DCHECK(res.second);
-    USE(res);
-    auto& output = phi->output();
-    for (size_t i = 0; i < phi->operands().size(); ++i) {
-      InstructionBlock* cur_block =
-          code()->InstructionBlockAt(block->predecessors()[i]);
-      UnallocatedOperand input(UnallocatedOperand::ANY, phi->operands()[i]);
-      auto move = data()->AddGapMove(cur_block->last_instruction_index(),
-                                     Instruction::END, input, output);
-      map_value->incoming_moves.push_back(move);
-      DCHECK(!InstructionAt(cur_block->last_instruction_index())
-                  ->HasReferenceMap());
-    }
-    auto live_range = LiveRangeFor(phi_vreg);
-    int gap_index = block->first_instruction_index();
-    live_range->SpillAtDefinition(allocation_zone(), gap_index, &output);
-    live_range->SetSpillStartIndex(gap_index);
-    // We use the phi-ness of some nodes in some later heuristics.
-    live_range->set_is_phi(true);
-    live_range->set_is_non_loop_phi(!block->IsLoopHeader());
-  }
-}
-
-
-void LiveRangeBuilder::MeetRegisterConstraints() {
-  for (auto block : code()->instruction_blocks()) {
-    MeetRegisterConstraints(block);
-  }
-}
-
-
-void LiveRangeBuilder::ResolvePhis() {
-  // Process the blocks in reverse order.
-  for (InstructionBlock* block : base::Reversed(code()->instruction_blocks())) {
-    ResolvePhis(block);
-  }
-}
-
-
 void LiveRangeBuilder::BuildLiveRanges() {
   // Process the blocks in reverse order.
   for (int block_id = code()->InstructionBlockCount() - 1; block_id >= 0;
        --block_id) {
     auto block = code()->InstructionBlockAt(RpoNumber::FromInt(block_id));
     auto live = ComputeLiveOut(block);
     // Initially consider all live_out values live for the entire block. We
     // will shorten these intervals if necessary.
     AddInitialIntervals(block, live);
 
     // Process the instructions in reverse order, generating and killing
     // live values.
     ProcessInstructions(block, live);
     // All phi output operands are killed by this block.
     for (auto phi : block->phis()) {
       // The live range interval already ends at the first instruction of the
       // block.
       int phi_vreg = phi->virtual_register();
       live->Remove(phi_vreg);
       InstructionOperand* hint = nullptr;
       auto instr = GetLastInstruction(
-          code()->InstructionBlockAt(block->predecessors()[0]));
+          code(), code()->InstructionBlockAt(block->predecessors()[0]));
       for (auto move : *instr->GetParallelMove(Instruction::END)) {
         auto& to = move->destination();
         if (to.IsUnallocated() &&
             UnallocatedOperand::cast(to).virtual_register() == phi_vreg) {
           hint = &move->source();
           break;
         }
       }
       DCHECK(hint != nullptr);
       auto block_start = LifetimePosition::GapFromInstructionIndex(
@@ skipping 20 matching lines @@
         iterator.Advance();
       }
       // Insert all values into the live in sets of all blocks in the loop.
       for (int i = block->rpo_number().ToInt() + 1;
            i < block->loop_end().ToInt(); ++i) {
         live_in_sets()[i]->Union(*live);
       }
     }
   }
 
-  for (auto range : live_ranges()) {
+  for (auto range : data()->live_ranges()) {
     if (range == nullptr) continue;
     range->set_kind(RequiredRegisterKind(range->id()));
     // Give slots to all ranges with a non fixed slot use.
     if (range->has_slot_use() && range->HasNoSpillType()) {
       data()->AssignSpillRangeToLiveRange(range);
     }
     // TODO(bmeurer): This is a horrible hack to make sure that for constant
     // live ranges, every use requires the constant to be in a register.
     // Without this hack, all uses with "any" policy would get the constant
     // operand assigned.
@@ skipping 38 matching lines @@
       unhandled_live_ranges_(local_zone),
       active_live_ranges_(local_zone),
       inactive_live_ranges_(local_zone) {
   unhandled_live_ranges().reserve(
       static_cast<size_t>(code()->VirtualRegisterCount() * 2));
   active_live_ranges().reserve(8);
   inactive_live_ranges().reserve(8);
   // TryAllocateFreeReg and AllocateBlockedReg assume this
   // when allocating local arrays.
   DCHECK(RegisterConfiguration::kMaxDoubleRegisters >=
-         config()->num_general_registers());
+         this->data()->config()->num_general_registers());
 }
 
 
 void LinearScanAllocator::AllocateRegisters() {
   DCHECK(unhandled_live_ranges().empty());
+  DCHECK(active_live_ranges().empty());
+  DCHECK(inactive_live_ranges().empty());
 
-  for (auto range : live_ranges()) {
+  for (auto range : data()->live_ranges()) {
     if (range == nullptr) continue;
     if (range->Kind() == mode_) {
       AddToUnhandledUnsorted(range);
     }
   }
   SortUnhandled();
   DCHECK(UnhandledIsSorted());
 
-  DCHECK(active_live_ranges().empty());
-  DCHECK(inactive_live_ranges().empty());
-
   auto& fixed_ranges = GetFixedRegisters(data(), mode_);
   for (auto current : fixed_ranges) {
     if (current != nullptr) {
       DCHECK_EQ(mode_, current->Kind());
       AddToInactive(current);
     }
   }
 
   while (!unhandled_live_ranges().empty()) {
     DCHECK(UnhandledIsSorted());
@@ skipping 52 matching lines @@
     }
 
     DCHECK(!current->HasRegisterAssigned() && !current->IsSpilled());
 
     bool result = TryAllocateFreeReg(current);
     if (!result) AllocateBlockedReg(current);
     if (current->HasRegisterAssigned()) {
       AddToActive(current);
     }
   }
-
-  active_live_ranges().clear();
-  inactive_live_ranges().clear();
 }
 
 
 const char* LinearScanAllocator::RegisterName(int allocation_index) const {
   if (mode_ == GENERAL_REGISTERS) {
-    return config()->general_register_name(allocation_index);
+    return data()->config()->general_register_name(allocation_index);
   } else {
-    return config()->double_register_name(allocation_index);
+    return data()->config()->double_register_name(allocation_index);
   }
 }
 
 
 void LinearScanAllocator::AddToActive(LiveRange* range) {
   TRACE("Add live range %d to active\n", range->id());
   active_live_ranges().push_back(range);
 }
 
 
@@ skipping 314 matching lines @@
       }
     }
   }
 }
 
 
 bool LinearScanAllocator::TryReuseSpillForPhi(LiveRange* range) {
   if (range->IsChild() || !range->is_phi()) return false;
   DCHECK(!range->HasSpillOperand());
 
-  auto lookup = phi_map().find(range->id());
-  DCHECK(lookup != phi_map().end());
+  auto lookup = data()->phi_map().find(range->id());
+  DCHECK(lookup != data()->phi_map().end());
   auto phi = lookup->second->phi;
   auto block = lookup->second->block;
   // Count the number of spilled operands.
   size_t spilled_count = 0;
   LiveRange* first_op = nullptr;
   for (size_t i = 0; i < phi->operands().size(); i++) {
     int op = phi->operands()[i];
     LiveRange* op_range = LiveRangeFor(op);
     if (!op_range->HasSpillRange()) continue;
     auto pred = code()->InstructionBlockAt(block->predecessors()[i]);
@@ skipping 258 matching lines @@
   // Iterate over all safe point positions and record a pointer
   // for all spilled live ranges at this point.
   int last_range_start = 0;
   auto reference_maps = data()->code()->reference_maps();
   ReferenceMapDeque::const_iterator first_it = reference_maps->begin();
   for (LiveRange* range : data()->live_ranges()) {
     if (range == nullptr) continue;
     // Iterate over the first parts of multi-part live ranges.
     if (range->IsChild()) continue;
     // Skip non-reference values.
-    if (!IsReference(range->id())) continue;
+    if (!data()->IsReference(range->id())) continue;
     // Skip empty live ranges.
     if (range->IsEmpty()) continue;
 
     // Find the extent of the range and its children.
     int start = range->Start().ToInstructionIndex();
     int end = 0;
     for (auto cur = range; cur != nullptr; cur = cur->next()) {
       auto this_end = cur->End();
       if (this_end.ToInstructionIndex() > end)
         end = this_end.ToInstructionIndex();
@@ skipping 233 matching lines @@
                                             const InstructionBlock* pred,
                                             const InstructionOperand& pred_op) {
   DCHECK(pred_op != cur_op);
   int gap_index;
   Instruction::GapPosition position;
   if (block->PredecessorCount() == 1) {
     gap_index = block->first_instruction_index();
     position = Instruction::START;
   } else {
     DCHECK(pred->SuccessorCount() == 1);
-    DCHECK(!data()
+    DCHECK(!code()
                 ->InstructionAt(pred->last_instruction_index())
                 ->HasReferenceMap());
     gap_index = pred->last_instruction_index();
     position = Instruction::END;
   }
   data()->AddGapMove(gap_index, position, pred_op, cur_op);
 }
 
 
 void LiveRangeConnector::ConnectRanges(Zone* local_zone) {
@@ skipping 65 matching lines @@
     auto move = new (code_zone()) MoveOperands(it->first.second, it->second);
     auto eliminate = moves->PrepareInsertAfter(move);
     to_insert.push_back(move);
     if (eliminate != nullptr) to_eliminate.push_back(eliminate);
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8