[turbofan] remove schedule from InstructionSequence

R=bmeurer@chromium.org

BUG=

Review URL: https://codereview.chromium.org/669613002

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24726 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/compiler/code-generator.h

@@ -29,7 +29,6 @@ class CodeGenerator FINAL : public GapResolver::Assembler {
   Frame* frame() const { return code()->frame(); }
   Isolate* isolate() const { return zone()->isolate(); }
   Linkage* linkage() const { return code()->linkage(); }
-  Schedule* schedule() const { return code()->schedule(); }
 
  private:
   MacroAssembler* masm() { return &masm_; }

src/compiler/graph-visualizer.cc

@@ -593,9 +593,11 @@ void GraphC1Visualizer::PrintSchedule(const char* phase,
 
     PrintIntProperty("loop_depth", current->loop_depth());
 
-    if (instructions->code_start(current) >= 0) {
-      int first_index = instructions->first_instruction_index(current);
-      int last_index = instructions->last_instruction_index(current);
+    const InstructionBlock* instruction_block =
+        instructions->InstructionBlockAt(current->GetRpoNumber());
+    if (instruction_block->code_start() >= 0) {
+      int first_index = instruction_block->first_instruction_index();
+      int last_index = instruction_block->last_instruction_index();
       PrintIntProperty("first_lir_id", LifetimePosition::FromInstructionIndex(
                                            first_index).Value());
       PrintIntProperty("last_lir_id", LifetimePosition::FromInstructionIndex(
@@ -674,8 +676,8 @@ void GraphC1Visualizer::PrintSchedule(const char* phase,
 
     if (instructions != NULL) {
       Tag LIR_tag(this, "LIR");
-      for (int j = instructions->first_instruction_index(current);
-           j <= instructions->last_instruction_index(current); j++) {
+      for (int j = instruction_block->first_instruction_index();
+           j <= instruction_block->last_instruction_index(); j++) {
         PrintIndent();
         os_ << j << " " << *instructions->InstructionAt(j) << " <|@\n";
       }

src/compiler/instruction-selector.cc

@@ -14,12 +14,14 @@ namespace internal {
 namespace compiler {
 
 InstructionSelector::InstructionSelector(InstructionSequence* sequence,
+                                         Schedule* schedule,
                                          SourcePositionTable* source_positions,
                                          Features features)
     : zone_(sequence->isolate()),
       sequence_(sequence),
       source_positions_(source_positions),
       features_(features),
+      schedule_(schedule),
       current_block_(NULL),
       instructions_(zone()),
       defined_(sequence->node_count(), false, zone()),
@@ -55,8 +57,10 @@ void InstructionSelector::SelectInstructions() {
   // Schedule the selected instructions.
   for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
     BasicBlock* block = *i;
-    size_t end = sequence()->code_end(block);
-    size_t start = sequence()->code_start(block);
+    InstructionBlock* instruction_block =
+        sequence()->InstructionBlockAt(block->GetRpoNumber());
+    size_t end = instruction_block->code_end();
+    size_t start = instruction_block->code_start();
     sequence()->StartBlock(block);
     while (start-- > end) {
       sequence()->AddInstruction(instructions_[start]);
@@ -383,8 +387,10 @@ void InstructionSelector::VisitBlock(BasicBlock* block) {
   }
 
   // We're done with the block.
-  sequence()->set_code_start(block, static_cast<int>(instructions_.size()));
-  sequence()->set_code_end(block, current_block_end);
+  InstructionBlock* instruction_block =
+      sequence()->InstructionBlockAt(block->GetRpoNumber());
+  instruction_block->set_code_start(static_cast<int>(instructions_.size()));
+  instruction_block->set_code_end(current_block_end);
 
   current_block_ = NULL;
 }
@@ -856,14 +862,12 @@ void InstructionSelector::VisitPhi(Node* node) {
   PhiInstruction* phi = new (instruction_zone())
       PhiInstruction(instruction_zone(), sequence()->GetVirtualRegister(node));
   sequence()->InstructionBlockAt(current_block_->GetRpoNumber())->AddPhi(phi);
-  Node::Inputs inputs = node->inputs();
-  size_t j = 0;
-  for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
-       ++iter, ++j) {
-    MarkAsUsed(*iter);
-    // TODO(mstarzinger): Use a ValueInputIterator instead.
-    if (j >= current_block_->PredecessorCount()) continue;
-    phi->operands().push_back(sequence()->GetVirtualRegister(*iter));
+  const int input_count = node->op()->InputCount();
+  phi->operands().reserve(static_cast<size_t>(input_count));
+  for (int i = 0; i < input_count; ++i) {
+    Node* const input = node->InputAt(i);
+    MarkAsUsed(input);
+    phi->operands().push_back(sequence()->GetVirtualRegister(input));
   }
 }
 

src/compiler/instruction-selector.h

@@ -25,7 +25,7 @@ class InstructionSelector FINAL {
   // Forward declarations.
   class Features;
 
-  InstructionSelector(InstructionSequence* sequence,
+  InstructionSelector(InstructionSequence* sequence, Schedule* schedule,
                       SourcePositionTable* source_positions,
                       Features features = SupportedFeatures());
 
@@ -184,7 +184,7 @@ class InstructionSelector FINAL {
   // ===========================================================================
 
   Linkage* linkage() const { return sequence()->linkage(); }
-  Schedule* schedule() const { return sequence()->schedule(); }
+  Schedule* schedule() const { return schedule_; }
   InstructionSequence* sequence() const { return sequence_; }
   Zone* instruction_zone() const { return sequence()->zone(); }
   Zone* zone() { return &zone_; }
@@ -195,6 +195,7 @@ class InstructionSelector FINAL {
   InstructionSequence* sequence_;
   SourcePositionTable* source_positions_;
   Features features_;
+  Schedule* schedule_;
   BasicBlock* current_block_;
   ZoneDeque<Instruction*> instructions_;
   BoolVector defined_;

src/compiler/instruction.cc

@@ -335,6 +335,7 @@ InstructionBlock::InstructionBlock(Zone* zone, const BasicBlock* block)
       predecessors_(static_cast<int>(block->PredecessorCount()),
                     BasicBlock::RpoNumber::Invalid(), zone),
       phis_(zone),
+      id_(block->id()),
       rpo_number_(block->GetRpoNumber()),
       loop_header_(GetRpo(block->loop_header())),
       loop_end_(GetLoopEndRpo(block)),
@@ -379,15 +380,14 @@ static void InitializeInstructionBlocks(Zone* zone, const Schedule* schedule,
 }
 
 
-InstructionSequence::InstructionSequence(Linkage* linkage, Graph* graph,
-                                         Schedule* schedule)
-    : zone_(schedule->zone()),  // TODO(dcarney): new zone.
+InstructionSequence::InstructionSequence(Linkage* linkage, const Graph* graph,
+                                         const Schedule* schedule)
+    : zone_(graph->zone()->isolate()),
       node_count_(graph->NodeCount()),
       node_map_(zone()->NewArray<int>(node_count_)),
       instruction_blocks_(static_cast<int>(schedule->rpo_order()->size()), NULL,
                           zone()),
       linkage_(linkage),
-      schedule_(schedule),
       constants_(ConstantMap::key_compare(),
                  ConstantMap::allocator_type(zone())),
       immediates_(zone()),
@@ -419,25 +419,28 @@ Label* InstructionSequence::GetLabel(BasicBlock::RpoNumber rpo) {
 
 BlockStartInstruction* InstructionSequence::GetBlockStart(
     BasicBlock::RpoNumber rpo) {
+  InstructionBlock* block = InstructionBlockAt(rpo);
   BlockStartInstruction* block_start =
-      BlockStartInstruction::cast(InstructionAt(code_start(rpo)));
+      BlockStartInstruction::cast(InstructionAt(block->code_start()));
   DCHECK_EQ(rpo.ToInt(), block_start->rpo_number().ToInt());
   return block_start;
 }
 
 
-void InstructionSequence::StartBlock(BasicBlock* block) {
-  set_code_start(block, static_cast<int>(instructions_.size()));
+void InstructionSequence::StartBlock(BasicBlock* basic_block) {
+  InstructionBlock* block = InstructionBlockAt(basic_block->GetRpoNumber());
+  block->set_code_start(static_cast<int>(instructions_.size()));
   BlockStartInstruction* block_start =
-      BlockStartInstruction::New(zone(), block);
+      BlockStartInstruction::New(zone(), basic_block);
   AddInstruction(block_start);
 }
 
 
-void InstructionSequence::EndBlock(BasicBlock* block) {
+void InstructionSequence::EndBlock(BasicBlock* basic_block) {
   int end = static_cast<int>(instructions_.size());
-  DCHECK(code_start(block) >= 0 && code_start(block) < end);
-  set_code_end(block, end);
+  InstructionBlock* block = InstructionBlockAt(basic_block->GetRpoNumber());
+  DCHECK(block->code_start() >= 0 && block->code_start() < end);
+  block->set_code_end(end);
 }
 
 
@@ -459,19 +462,6 @@ int InstructionSequence::AddInstruction(Instruction* instr) {
 }
 
 
-BasicBlock* InstructionSequence::GetBasicBlock(int instruction_index) {
-  // TODO(turbofan): Optimize this.
-  for (;;) {
-    DCHECK_LE(0, instruction_index);
-    Instruction* instruction = InstructionAt(instruction_index--);
-    if (instruction->IsBlockStart()) {
-      return schedule()->rpo_order()->at(
-          BlockStartInstruction::cast(instruction)->rpo_number().ToSize());
-    }
-  }
-}
-
-
 const InstructionBlock* InstructionSequence::GetInstructionBlock(
     int instruction_index) const {
   // TODO(turbofan): Optimize this.
@@ -614,53 +604,50 @@ std::ostream& operator<<(std::ostream& os, const InstructionSequence& code) {
     os << "CST#" << i << ": v" << it->first << " = " << it->second << "\n";
   }
   for (int i = 0; i < code.BasicBlockCount(); i++) {
-    BasicBlock* block = code.BlockAt(i);
+    BasicBlock::RpoNumber rpo = BasicBlock::RpoNumber::FromInt(i);
+    const InstructionBlock* block = code.InstructionBlockAt(rpo);
+    CHECK(block->rpo_number() == rpo);
 
     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 << "  instructions: [" << code.code_start(block) << ", "
-       << code.code_end(block) << ")\n  predecessors:";
+    os << "  instructions: [" << block->code_start() << ", "
+       << block->code_end() << ")\n  predecessors:";
 
-    for (BasicBlock::Predecessors::iterator iter = block->predecessors_begin();
-         iter != block->predecessors_end(); ++iter) {
-      os << " B" << (*iter)->id();
+    for (auto pred : block->predecessors()) {
+      const InstructionBlock* pred_block = code.InstructionBlockAt(pred);
+      os << " B" << pred_block->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();
+    for (auto phi : block->phis()) {
+      os << "     phi: v" << phi->virtual_register() << " =";
+      for (auto op_vreg : phi->operands()) {
+        os << " v" << op_vreg;
       }
       os << "\n";
     }
 
     ScopedVector<char> buf(32);
-    for (int j = code.first_instruction_index(block);
-         j <= code.last_instruction_index(block); j++) {
+    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) << "\n";
     }
 
-    os << "  " << block->control();
+    // TODO(dcarney): add this back somehow?
+    // 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();
+    // }
 
-    for (BasicBlock::Successors::iterator iter = block->successors_begin();
-         iter != block->successors_end(); ++iter) {
-      os << " B" << (*iter)->id();
+    for (auto succ : block->successors()) {
+      const InstructionBlock* succ_block = code.InstructionBlockAt(succ);
+      os << " B" << succ_block->id();
     }
     os << "\n";
   }

src/compiler/instruction.h

@@ -755,7 +755,7 @@ std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 
 // TODO(dcarney): this is a temporary hack.  turn into an actual instruction.
-class PhiInstruction : public ZoneObject {
+class PhiInstruction FINAL : public ZoneObject {
  public:
   PhiInstruction(Zone* zone, int virtual_register)
       : virtual_register_(virtual_register), operands_(zone) {}
@@ -771,7 +771,7 @@ class PhiInstruction : public ZoneObject {
 
 
 // Analogue of BasicBlock for Instructions instead of Nodes.
-class InstructionBlock : public ZoneObject {
+class InstructionBlock FINAL : public ZoneObject {
  public:
   explicit InstructionBlock(Zone* zone, const BasicBlock* block);
 
@@ -795,6 +795,7 @@ class InstructionBlock : public ZoneObject {
   int32_t code_end() const { return code_end_; }
   void set_code_end(int32_t end) { code_end_ = end; }
 
+  BasicBlock::Id id() const { return id_; }
   BasicBlock::RpoNumber rpo_number() const { return rpo_number_; }
   BasicBlock::RpoNumber loop_header() const { return loop_header_; }
   BasicBlock::RpoNumber loop_end() const {
@@ -820,6 +821,7 @@ class InstructionBlock : public ZoneObject {
   Successors successors_;
   Predecessors predecessors_;
   PhiInstructions phis_;
+  BasicBlock::Id id_;
   // TODO(dcarney): probably dont't need this.
   BasicBlock::RpoNumber rpo_number_;
   BasicBlock::RpoNumber loop_header_;
@@ -842,7 +844,8 @@ typedef ZoneVector<InstructionBlock*> InstructionBlocks;
 // TODO(titzer): s/IsDouble/IsFloat64/
 class InstructionSequence FINAL {
  public:
-  InstructionSequence(Linkage* linkage, Graph* graph, Schedule* schedule);
+  InstructionSequence(Linkage* linkage, const Graph* graph,
+                      const Schedule* schedule);
 
   int NextVirtualRegister() { return next_virtual_register_++; }
   int VirtualRegisterCount() const { return next_virtual_register_; }
@@ -853,17 +856,13 @@ class InstructionSequence FINAL {
     return static_cast<int>(instruction_blocks_.size());
   }
 
-  BasicBlock* BlockAt(int rpo_number) const {
-    return (*schedule_->rpo_order())[rpo_number];
-  }
-
   InstructionBlock* InstructionBlockAt(BasicBlock::RpoNumber rpo_number) {
-    return GetBlock(rpo_number);
+    return instruction_blocks_[rpo_number.ToSize()];
   }
 
   const InstructionBlock* InstructionBlockAt(
       BasicBlock::RpoNumber rpo_number) const {
-    return GetBlock(rpo_number);
+    return instruction_blocks_[rpo_number.ToSize()];
   }
 
   // TODO(dcarney): move to register allocator.
@@ -874,7 +873,6 @@ class InstructionSequence FINAL {
     return instruction_blocks_[index.ToInt()];
   }
 
-  BasicBlock* GetBasicBlock(int instruction_index);
   const InstructionBlock* GetInstructionBlock(int instruction_index) const;
 
   int GetVirtualRegister(const Node* node);
@@ -907,44 +905,15 @@ class InstructionSequence FINAL {
   }
 
   Frame* frame() { return &frame_; }
-  Isolate* isolate() const { return zone()->isolate(); }
+  Isolate* isolate() { return zone()->isolate(); }
   Linkage* linkage() const { return linkage_; }
-  Schedule* schedule() const { return schedule_; }
   const PointerMapDeque* pointer_maps() const { return &pointer_maps_; }
-  Zone* zone() const { return zone_; }
+  Zone* zone() { return &zone_; }
 
   // Used by the instruction selector while adding instructions.
   int AddInstruction(Instruction* instr);
   void StartBlock(BasicBlock* block);
   void EndBlock(BasicBlock* block);
-  void set_code_start(BasicBlock* block, int start) {
-    return GetBlock(block->GetRpoNumber())->set_code_start(start);
-  }
-  void set_code_end(BasicBlock* block, int end) {
-    return GetBlock(block->GetRpoNumber())->set_code_end(end);
-  }
-  // TODO(dcarney): use RpoNumber for all of the below.
-  int code_start(BasicBlock::RpoNumber rpo_number) const {
-    return GetBlock(rpo_number)->code_start();
-  }
-  int code_start(BasicBlock* block) const {
-    return GetBlock(block->GetRpoNumber())->code_start();
-  }
-  int code_end(BasicBlock* block) const {
-    return GetBlock(block->GetRpoNumber())->code_end();
-  }
-  int first_instruction_index(BasicBlock* block) const {
-    return GetBlock(block->GetRpoNumber())->first_instruction_index();
-  }
-  int last_instruction_index(BasicBlock* block) const {
-    return GetBlock(block->GetRpoNumber())->last_instruction_index();
-  }
-  int first_instruction_index(InstructionBlock* block) const {
-    return GetBlock(block->rpo_number())->first_instruction_index();
-  }
-  int last_instruction_index(InstructionBlock* block) const {
-    return GetBlock(block->rpo_number())->last_instruction_index();
-  }
 
   int AddConstant(Node* node, Constant constant) {
     int virtual_register = GetVirtualRegister(node);
@@ -988,21 +957,16 @@ class InstructionSequence FINAL {
   int GetFrameStateDescriptorCount();
 
  private:
-  InstructionBlock* GetBlock(BasicBlock::RpoNumber rpo_number) const {
-    return instruction_blocks_[rpo_number.ToSize()];
-  }
-
   friend std::ostream& operator<<(std::ostream& os,
                                   const InstructionSequence& code);
 
   typedef std::set<int, std::less<int>, ZoneIntAllocator> VirtualRegisterSet;
 
-  Zone* zone_;
+  Zone zone_;
   int node_count_;
   int* node_map_;
   InstructionBlocks instruction_blocks_;
   Linkage* linkage_;
-  Schedule* schedule_;
   ConstantMap constants_;
   ConstantDeque immediates_;
   InstructionDeque instructions_;

src/compiler/pipeline.cc

@@ -457,7 +457,7 @@ Handle<Code> Pipeline::GenerateCode(Linkage* linkage, Graph* graph,
 
   // Select and schedule instructions covering the scheduled graph.
   {
-    InstructionSelector selector(&sequence, source_positions);
+    InstructionSelector selector(&sequence, schedule, source_positions);
     selector.SelectInstructions();
   }
 

src/compiler/schedule.cc

@@ -105,6 +105,11 @@ std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id) {
 }
 
 
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo) {
+  return os << rpo.ToSize();
+}
+
+
 Schedule::Schedule(Zone* zone, size_t node_count_hint)
     : zone_(zone),
       all_blocks_(zone),

src/compiler/schedule.h

@@ -182,6 +182,7 @@ class BasicBlock FINAL : public ZoneObject {
 
 std::ostream& operator<<(std::ostream& os, const BasicBlock::Control& c);
 std::ostream& operator<<(std::ostream& os, const BasicBlock::Id& id);
+std::ostream& operator<<(std::ostream& os, const BasicBlock::RpoNumber& rpo);
 
 typedef ZoneVector<BasicBlock*> BasicBlockVector;
 typedef BasicBlockVector::iterator BasicBlockVectorIter;

test/cctest/compiler/test-codegen-deopt.cc

@@ -68,7 +68,7 @@ class DeoptCodegenTester {
     code = new v8::internal::compiler::InstructionSequence(linkage, graph,
                                                            schedule);
     SourcePositionTable source_positions(graph);
-    InstructionSelector selector(code, &source_positions);
+    InstructionSelector selector(code, schedule, &source_positions);
     selector.SelectInstructions();
 
     if (FLAG_trace_turbo) {

test/cctest/compiler/test-instruction.cc

@@ -93,6 +93,21 @@ class InstructionTester : public HandleAndZoneScope {
     unallocated->set_virtual_register(vreg);
     return unallocated;
   }
+
+  InstructionBlock* BlockAt(BasicBlock* block) {
+    return code->InstructionBlockAt(block->GetRpoNumber());
+  }
+  BasicBlock* GetBasicBlock(int instruction_index) {
+    const InstructionBlock* block =
+        code->GetInstructionBlock(instruction_index);
+    return schedule.rpo_order()->at(block->rpo_number().ToSize());
+  }
+  int first_instruction_index(BasicBlock* block) {
+    return BlockAt(block)->first_instruction_index();
+  }
+  int last_instruction_index(BasicBlock* block) {
+    return BlockAt(block)->last_instruction_index();
+  }
 };
 
 
@@ -121,7 +136,8 @@ TEST(InstructionBasic) {
   for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end();
        i++, index++) {
     BasicBlock* block = *i;
-    CHECK_EQ(block, R.code->BlockAt(index));
+    CHECK_EQ(block->rpo_number(), R.BlockAt(block)->rpo_number().ToInt());
+    CHECK_EQ(block->id().ToInt(), R.BlockAt(block)->id().ToInt());
     CHECK_EQ(-1, block->loop_end());
   }
 }
@@ -159,29 +175,29 @@ TEST(InstructionGetBasicBlock) {
   R.code->StartBlock(b3);
   R.code->EndBlock(b3);
 
-  CHECK_EQ(b0, R.code->GetBasicBlock(i0));
-  CHECK_EQ(b0, R.code->GetBasicBlock(i1));
+  CHECK_EQ(b0, R.GetBasicBlock(i0));
+  CHECK_EQ(b0, R.GetBasicBlock(i1));
 
-  CHECK_EQ(b1, R.code->GetBasicBlock(i2));
-  CHECK_EQ(b1, R.code->GetBasicBlock(i3));
-  CHECK_EQ(b1, R.code->GetBasicBlock(i4));
-  CHECK_EQ(b1, R.code->GetBasicBlock(i5));
+  CHECK_EQ(b1, R.GetBasicBlock(i2));
+  CHECK_EQ(b1, R.GetBasicBlock(i3));
+  CHECK_EQ(b1, R.GetBasicBlock(i4));
+  CHECK_EQ(b1, R.GetBasicBlock(i5));
 
-  CHECK_EQ(b2, R.code->GetBasicBlock(i6));
-  CHECK_EQ(b2, R.code->GetBasicBlock(i7));
-  CHECK_EQ(b2, R.code->GetBasicBlock(i8));
+  CHECK_EQ(b2, R.GetBasicBlock(i6));
+  CHECK_EQ(b2, R.GetBasicBlock(i7));
+  CHECK_EQ(b2, R.GetBasicBlock(i8));
 
-  CHECK_EQ(b0, R.code->GetBasicBlock(R.code->first_instruction_index(b0)));
-  CHECK_EQ(b0, R.code->GetBasicBlock(R.code->last_instruction_index(b0)));
+  CHECK_EQ(b0, R.GetBasicBlock(R.first_instruction_index(b0)));
+  CHECK_EQ(b0, R.GetBasicBlock(R.last_instruction_index(b0)));
 
-  CHECK_EQ(b1, R.code->GetBasicBlock(R.code->first_instruction_index(b1)));
-  CHECK_EQ(b1, R.code->GetBasicBlock(R.code->last_instruction_index(b1)));
+  CHECK_EQ(b1, R.GetBasicBlock(R.first_instruction_index(b1)));
+  CHECK_EQ(b1, R.GetBasicBlock(R.last_instruction_index(b1)));
 
-  CHECK_EQ(b2, R.code->GetBasicBlock(R.code->first_instruction_index(b2)));
-  CHECK_EQ(b2, R.code->GetBasicBlock(R.code->last_instruction_index(b2)));
+  CHECK_EQ(b2, R.GetBasicBlock(R.first_instruction_index(b2)));
+  CHECK_EQ(b2, R.GetBasicBlock(R.last_instruction_index(b2)));
 
-  CHECK_EQ(b3, R.code->GetBasicBlock(R.code->first_instruction_index(b3)));
-  CHECK_EQ(b3, R.code->GetBasicBlock(R.code->last_instruction_index(b3)));
+  CHECK_EQ(b3, R.GetBasicBlock(R.first_instruction_index(b3)));
+  CHECK_EQ(b3, R.GetBasicBlock(R.last_instruction_index(b3)));
 }
 
 

test/unittests/compiler/instruction-selector-unittest.cc

@@ -40,7 +40,8 @@ InstructionSelectorTest::Stream InstructionSelectorTest::StreamBuilder::Build(
   Linkage linkage(&info, call_descriptor());
   InstructionSequence sequence(&linkage, graph(), schedule);
   SourcePositionTable source_position_table(graph());
-  InstructionSelector selector(&sequence, &source_position_table, features);
+  InstructionSelector selector(&sequence, schedule, &source_position_table,
+                               features);
   selector.SelectInstructions();
   if (FLAG_trace_turbo) {
     OFStream out(stdout);