Partial refactoring of subgraphs.

src/hydrogen.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 467 matching lines @@
 
 
 HConstant* HGraph::GetConstantFalse() {
   return GetConstant(&constant_false_, Heap::false_value());
 }
 
 
 void HSubgraph::AppendJoin(HSubgraph* then_graph,
                            HSubgraph* else_graph,
                            AstNode* node) {
-  if (then_graph->HasExit() && else_graph->HasExit()) {
+  if (then_graph->exit_block() != NULL &&
+      else_graph->exit_block() != NULL) {
     // We need to merge, create new merge block.
     HBasicBlock* join_block = graph_->CreateBasicBlock();
     then_graph->exit_block()->Goto(join_block);
     else_graph->exit_block()->Goto(join_block);
     join_block->SetJoinId(node->id());
     exit_block_ = join_block;
-  } else if (then_graph->HasExit()) {
+  } else if (then_graph->exit_block() != NULL) {
     exit_block_ = then_graph->exit_block_;
-  } else if (else_graph->HasExit()) {
+  } else if (else_graph->exit_block() != NULL) {
     exit_block_ = else_graph->exit_block_;
   } else {
     exit_block_ = NULL;
   }
 }
 
 
 void HSubgraph::ResolveContinue(IterationStatement* statement,
                                 HBasicBlock* continue_block) {
   if (continue_block != NULL) {
@@ skipping 11 matching lines @@
   a->Goto(target);
   b->Goto(target);
   target->SetJoinId(id);
   return target;
 }
 
 
 void HSubgraph::AppendEndless(HSubgraph* body,
                               IterationStatement* statement,
                               HBasicBlock* break_block) {
-  ConnectExitTo(body->entry_block());
-  body->ConnectExitTo(body->entry_block(), true);
+  if (exit_block() != NULL) {
+    exit_block()->Goto(body->entry_block(), false);
+  }
+  if (body->exit_block() != NULL) {
+    body->exit_block()->Goto(body->entry_block(), true);
+  }
   if (break_block != NULL) break_block->SetJoinId(statement->ExitId());
   exit_block_ = break_block;
   body->entry_block()->PostProcessLoopHeader(statement);
 }
 
 
 void HSubgraph::AppendDoWhile(HSubgraph* body,
                               IterationStatement* statement,
                               HSubgraph* go_back,
                               HSubgraph* exit,
                               HBasicBlock* break_block) {
-  ConnectExitTo(body->entry_block());
-  go_back->ConnectExitTo(body->entry_block(), true);
+  if (exit_block() != NULL) {
+    exit_block()->Goto(body->entry_block(), false);
+  }
+  if (go_back->exit_block() != NULL) {
+    go_back->exit_block()->Goto(body->entry_block(), true);
+  }
   if (break_block != NULL) break_block->SetJoinId(statement->ExitId());
   exit_block_ =
       JoinBlocks(exit->exit_block(), break_block, statement->ExitId());
   body->entry_block()->PostProcessLoopHeader(statement);
 }
 
 
 void HSubgraph::AppendWhile(HSubgraph* condition,
                             HSubgraph* body,
                             IterationStatement* statement,
                             HSubgraph* continue_subgraph,
                             HSubgraph* exit,
                             HBasicBlock* break_block) {
-  ConnectExitTo(condition->entry_block());
+  if (exit_block() != NULL) {
+    exit_block()->Goto(condition->entry_block(), false);
+  }
 
   if (break_block != NULL) break_block->SetJoinId(statement->ExitId());
   exit_block_ =
       JoinBlocks(exit->exit_block(), break_block, statement->ExitId());
 
   if (continue_subgraph != NULL) {
-    body->ConnectExitTo(continue_subgraph->entry_block(), true);
+    if (body->exit_block() != NULL) {
+      body->exit_block()->Goto(continue_subgraph->entry_block(), true);
+    }
     continue_subgraph->entry_block()->SetJoinId(statement->EntryId());
     exit_block_ = JoinBlocks(exit_block_,
                              continue_subgraph->exit_block(),
                              statement->ExitId());
   } else {
-    body->ConnectExitTo(condition->entry_block(), true);
+    if (body->exit_block() != NULL) {
+      body->exit_block()->Goto(condition->entry_block(), true);
+    }
   }
   condition->entry_block()->PostProcessLoopHeader(statement);
 }
 
 
 void HSubgraph::Append(HSubgraph* next,
                        BreakableStatement* stmt,
                        HBasicBlock* break_block) {
   exit_block_->Goto(next->entry_block());
   exit_block_ = next->exit_block_;
 
   if (stmt != NULL) {
     next->entry_block()->SetJoinId(stmt->EntryId());
     if (break_block != NULL) break_block->SetJoinId(stmt->EntryId());
     exit_block_ = JoinBlocks(exit_block(), break_block, stmt->ExitId());
   }
 }
 
 
 void HSubgraph::FinishExit(HControlInstruction* instruction) {
-  ASSERT(HasExit());
+  ASSERT(exit_block() != NULL);
   exit_block_->Finish(instruction);
   exit_block_->ClearEnvironment();
   exit_block_ = NULL;
 }
 
 
 HGraph::HGraph(CompilationInfo* info)
     : HSubgraph(this),
       next_block_id_(0),
       info_(info),
@@ skipping 1327 matching lines @@
 }
 
 
 AstContext::~AstContext() {
   owner_->set_ast_context(outer_);  // Pop.
 }
 
 
 EffectContext::~EffectContext() {
   ASSERT(owner()->HasStackOverflow() ||
-         !owner()->subgraph()->HasExit() ||
+         owner()->current_block() == NULL ||
          owner()->environment()->length() == original_length_);
 }
 
 
 ValueContext::~ValueContext() {
   ASSERT(owner()->HasStackOverflow() ||
-         !owner()->subgraph()->HasExit() ||
+         owner()->current_block() == NULL ||
          owner()->environment()->length() == original_length_ + 1);
 }
 
 
 void EffectContext::ReturnValue(HValue* value) {
   // The value is simply ignored.
 }
 
 
 void ValueContext::ReturnValue(HValue* value) {
@@ skipping 37 matching lines @@
 
 void TestContext::BuildBranch(HValue* value) {
   // We expect the graph to be in edge-split form: there is no edge that
   // connects a branch node to a join node.  We conservatively ensure that
   // property by always adding an empty block on the outgoing edges of this
   // branch.
   HGraphBuilder* builder = owner();
   HBasicBlock* empty_true = builder->graph()->CreateBasicBlock();
   HBasicBlock* empty_false = builder->graph()->CreateBasicBlock();
   HTest* test = new HTest(value, empty_true, empty_false);
-  builder->CurrentBlock()->Finish(test);
+  builder->current_block()->Finish(test);
 
   HValue* const no_return_value = NULL;
   HBasicBlock* true_target = if_true();
   if (true_target->IsInlineReturnTarget()) {
     empty_true->AddLeaveInlined(no_return_value, true_target);
   } else {
     empty_true->Goto(true_target);
   }
 
   HBasicBlock* false_target = if_false();
   if (false_target->IsInlineReturnTarget()) {
     empty_false->AddLeaveInlined(no_return_value, false_target);
   } else {
     empty_false->Goto(false_target);
   }
-  builder->subgraph()->set_exit_block(NULL);
+  builder->set_current_block(NULL);
 }
 
 
 // HGraphBuilder infrastructure for bailing out and checking bailouts.
 #define BAILOUT(reason)                         \
   do {                                          \
     Bailout(reason);                            \
     return;                                     \
   } while (false)
 
@@ skipping 86 matching lines @@
 
 void HGraphBuilder::VisitArgument(Expression* expr) {
   VISIT_FOR_VALUE(expr);
   Push(AddInstruction(new HPushArgument(Pop())));
 }
 
 
 void HGraphBuilder::VisitArgumentList(ZoneList<Expression*>* arguments) {
   for (int i = 0; i < arguments->length(); i++) {
     VisitArgument(arguments->at(i));
-    if (HasStackOverflow() || !current_subgraph_->HasExit()) return;
+    if (HasStackOverflow() || current_block() == NULL) return;
   }
 }
 
 
 void HGraphBuilder::VisitExpressions(ZoneList<Expression*>* exprs) {
   for (int i = 0; i < exprs->length(); ++i) {
     VISIT_FOR_VALUE(exprs->at(i));
   }
 }
 
@@ skipping 13 matching lines @@
 
     AddInstruction(new HStackCheck());
 
     ZoneList<Statement*>* stmts = info->function()->body();
     HSubgraph* body = CreateGotoSubgraph(environment());
     AddToSubgraph(body, stmts);
     if (HasStackOverflow()) return NULL;
     current_subgraph_->Append(body, NULL, NULL);
     body->entry_block()->SetJoinId(info->function()->id());
 
-    if (graph_->HasExit()) {
+    if (graph()->exit_block() != NULL) {
       graph_->FinishExit(new HReturn(graph_->GetConstantUndefined()));
     }
   }
 
   graph_->OrderBlocks();
   graph_->AssignDominators();
   graph_->EliminateRedundantPhis();
   if (!graph_->CollectPhis()) {
     Bailout("Phi-use of arguments object");
     return NULL;
@@ skipping 40 matching lines @@
 
 
 void HGraphBuilder::AddToSubgraph(HSubgraph* graph,
                                   ZoneList<Statement*>* stmts) {
   SubgraphScope scope(this, graph);
   VisitStatements(stmts);
 }
 
 
 HInstruction* HGraphBuilder::AddInstruction(HInstruction* instr) {
-  ASSERT(current_subgraph_->HasExit());
-  current_subgraph_->exit_block()->AddInstruction(instr);
+  ASSERT(current_block() != NULL);
+  current_block()->AddInstruction(instr);
   return instr;
 }
 
 
 void HGraphBuilder::AddSimulate(int id) {
-  ASSERT(current_subgraph_->HasExit());
-  current_subgraph_->exit_block()->AddSimulate(id);
+  ASSERT(current_block() != NULL);
+  current_block()->AddSimulate(id);
 }
 
 
 void HGraphBuilder::AddPhi(HPhi* instr) {
-  ASSERT(current_subgraph_->HasExit());
-  current_subgraph_->exit_block()->AddPhi(instr);
+  ASSERT(current_block() != NULL);
+  current_block()->AddPhi(instr);
 }
 
 
 void HGraphBuilder::PushAndAdd(HInstruction* instr) {
   Push(instr);
   AddInstruction(instr);
 }
 
 
 void HGraphBuilder::PreProcessCall(HCall* call) {
@@ skipping 42 matching lines @@
     graph()->SetArgumentsObject(object);
     environment()->Bind(scope->arguments(), object);
     environment()->Bind(scope->arguments_shadow(), object);
   }
 }
 
 
 void HGraphBuilder::VisitStatements(ZoneList<Statement*>* statements) {
   for (int i = 0; i < statements->length(); i++) {
     Visit(statements->at(i));
-    if (HasStackOverflow() || !current_subgraph_->HasExit()) break;
+    if (HasStackOverflow() || current_block() == NULL) break;
   }
 }
 
 
 HBasicBlock* HGraphBuilder::CreateBasicBlock(HEnvironment* env) {
   HBasicBlock* b = graph()->CreateBasicBlock();
   b->SetInitialEnvironment(env);
   return b;
 }
 
@@ skipping 118 matching lines @@
       }
       break;
   }
 
   return block;
 }
 
 
 void HGraphBuilder::VisitContinueStatement(ContinueStatement* stmt) {
   HBasicBlock* continue_block = break_scope()->Get(stmt->target(), CONTINUE);
-  subgraph()->exit_block()->Goto(continue_block);
-  subgraph()->set_exit_block(NULL);
+  current_block()->Goto(continue_block);
+  set_current_block(NULL);
 }
 
 
 void HGraphBuilder::VisitBreakStatement(BreakStatement* stmt) {
   HBasicBlock* break_block = break_scope()->Get(stmt->target(), BREAK);
-  subgraph()->exit_block()->Goto(break_block);
-  subgraph()->set_exit_block(NULL);
+  current_block()->Goto(break_block);
+  set_current_block(NULL);
 }
 
 
 void HGraphBuilder::VisitReturnStatement(ReturnStatement* stmt) {
   AstContext* context = call_context();
   if (context == NULL) {
     // Not an inlined return, so an actual one.
     VISIT_FOR_VALUE(stmt->expression());
     HValue* result = environment()->Pop();
     subgraph()->FinishExit(new HReturn(result));
   } else {
     // Return from an inlined function, visit the subexpression in the
     // expression context of the call.
     if (context->IsTest()) {
       TestContext* test = TestContext::cast(context);
       VisitForControl(stmt->expression(),
                       test->if_true(),
                       test->if_false());
     } else {
       HValue* return_value = NULL;
       if (context->IsEffect()) {
         VISIT_FOR_EFFECT(stmt->expression());
         return_value = graph()->GetConstantUndefined();
       } else {
         ASSERT(context->IsValue());
         VISIT_FOR_VALUE(stmt->expression());
         return_value = environment()->Pop();
       }
-      subgraph()->exit_block()->AddLeaveInlined(return_value,
+      current_block()->AddLeaveInlined(return_value,
                                                 function_return_);
-      subgraph()->set_exit_block(NULL);
+      set_current_block(NULL);
     }
   }
 }
 
 
 void HGraphBuilder::VisitWithEnterStatement(WithEnterStatement* stmt) {
   BAILOUT("WithEnterStatement");
 }
 
 
 void HGraphBuilder::VisitWithExitStatement(WithExitStatement* stmt) {
   BAILOUT("WithExitStatement");
 }
 
 
 HCompare* HGraphBuilder::BuildSwitchCompare(HSubgraph* subgraph,
                                             HValue* switch_value,
                                             CaseClause* clause) {
   AddToSubgraph(subgraph, clause->label());
   if (HasStackOverflow()) return NULL;
-  HValue* clause_value = subgraph->environment()->Pop();
+  HValue* clause_value = subgraph->exit_block()->last_environment()->Pop();
   HCompare* compare = new HCompare(switch_value,
                                    clause_value,
                                    Token::EQ_STRICT);
   compare->SetInputRepresentation(Representation::Integer32());
   subgraph->exit_block()->AddInstruction(compare);
   return compare;
 }
 
 
 void HGraphBuilder::VisitSwitchStatement(SwitchStatement* stmt) {
@@ skipping 60 matching lines @@
     prev_compare_inst = BuildSwitchCompare(subgraph, switch_value, clause);
     if (HasStackOverflow()) return;
 
     prev_graph = subgraph;
   }
 
   // Finish last comparison if there was at least one comparison.
   // last_false_block is the (empty) false-block of the last comparison. If
   // there are no comparisons at all (a single default clause), it is just
   // the last block of the current subgraph.
-  HBasicBlock* last_false_block = current_subgraph_->exit_block();
+  HBasicBlock* last_false_block = current_block();
   if (prev_graph != current_subgraph_) {
     last_false_block = graph()->CreateBasicBlock();
     HBasicBlock* empty = graph()->CreateBasicBlock();
     prev_graph->exit_block()->Finish(new HTest(prev_compare_inst,
                                                empty,
                                                last_false_block));
   }
 
   // If we have a non-smi compare clause, we deoptimize after trying
   // all the previous compares.
@@ skipping 22 matching lines @@
         ASSERT(clause->IsSmiCompare());
         // Connect with the corresponding comparison.
         subgraph = CreateEmptySubgraph();
         HBasicBlock* empty =
             compare_graphs.at(i)->exit_block()->end()->FirstSuccessor();
         empty->Finish(new HGoto(subgraph->entry_block()));
       }
     }
 
     // Check for fall-through from previous statement block.
-    if (previous_subgraph != NULL && previous_subgraph->HasExit()) {
+    if (previous_subgraph != NULL && previous_subgraph->exit_block() != NULL) {
       if (subgraph == NULL) subgraph = CreateEmptySubgraph();
       previous_subgraph->exit_block()->
           Finish(new HGoto(subgraph->entry_block()));
     }
 
     if (subgraph != NULL) {
       BreakAndContinueInfo break_info(stmt);
       { BreakAndContinueScope push(&break_info, this);
         ADD_TO_SUBGRAPH(subgraph, clause->statements());
       }
       if (break_info.break_block() != NULL) {
         break_info.break_block()->SetJoinId(stmt->ExitId());
         break_info.break_block()->Finish(new HGoto(single_exit_block));
       }
     }
 
     previous_subgraph = subgraph;
   }
 
   // If the last statement block has a fall-through, connect it to the
   // single exit block.
-  if (previous_subgraph != NULL && previous_subgraph->HasExit()) {
+  if (previous_subgraph != NULL && previous_subgraph->exit_block() != NULL) {
     previous_subgraph->exit_block()->Finish(new HGoto(single_exit_block));
   }
 
   // If there is no default clause finish the last comparison's false target.
   if (!last_false_block->IsFinished()) {
     last_false_block->Finish(new HGoto(single_exit_block));
   }
 
   if (single_exit_block->HasPredecessor()) {
-    current_subgraph_->set_exit_block(single_exit_block);
+    set_current_block(single_exit_block);
   } else {
-    current_subgraph_->set_exit_block(NULL);
+    set_current_block(NULL);
   }
 }
 
 bool HGraph::HasOsrEntryAt(IterationStatement* statement) {
   return statement->OsrEntryId() == info()->osr_ast_id();
 }
 
 
 void HSubgraph::PreProcessOsrEntry(IterationStatement* statement) {
   if (!graph()->HasOsrEntryAt(statement)) return;
@@ skipping 21 matching lines @@
 
   osr_entry->AddSimulate(osr_entry_id);
   osr_entry->AddInstruction(new HOsrEntry(osr_entry_id));
   osr_entry->Goto(loop_predecessor);
   loop_predecessor->SetJoinId(statement->EntryId());
   set_exit_block(loop_predecessor);
 }
 
 
 void HGraphBuilder::VisitDoWhileStatement(DoWhileStatement* stmt) {
-  ASSERT(subgraph()->HasExit());
+  ASSERT(current_block() != NULL);
   subgraph()->PreProcessOsrEntry(stmt);
 
   HSubgraph* body_graph = CreateLoopHeaderSubgraph(environment());
   BreakAndContinueInfo break_info(stmt);
   { BreakAndContinueScope push(&break_info, this);
     ADD_TO_SUBGRAPH(body_graph, stmt->body());
   }
   body_graph->ResolveContinue(stmt, break_info.continue_block());
 
-  if (!body_graph->HasExit() || stmt->cond()->ToBooleanIsTrue()) {
+  if (body_graph->exit_block() == NULL || stmt->cond()->ToBooleanIsTrue()) {
     subgraph()->AppendEndless(body_graph, stmt, break_info.break_block());
   } else {
     HSubgraph* go_back = CreateEmptySubgraph();
     HSubgraph* exit = CreateEmptySubgraph();
     {
       SubgraphScope scope(this, body_graph);
       VISIT_FOR_CONTROL(stmt->cond(),
                         go_back->entry_block(),
                         exit->entry_block());
       go_back->entry_block()->SetJoinId(stmt->BackEdgeId());
       exit->entry_block()->SetJoinId(stmt->ExitId());
     }
     subgraph()->AppendDoWhile(body_graph, stmt, go_back, exit,
                               break_info.break_block());
   }
 }
 
 
 bool HGraphBuilder::ShouldPeel(HSubgraph* cond, HSubgraph* body) {
   return FLAG_use_peeling;
 }
 
 
 void HGraphBuilder::VisitWhileStatement(WhileStatement* stmt) {
-  ASSERT(subgraph()->HasExit());
+  ASSERT(current_block() != NULL);
   subgraph()->PreProcessOsrEntry(stmt);
 
   HSubgraph* cond_graph = NULL;
   HSubgraph* body_graph = NULL;
   HSubgraph* exit_graph = NULL;
 
   // If the condition is constant true, do not generate a condition subgraph.
   if (stmt->cond()->ToBooleanIsTrue()) {
     body_graph = CreateLoopHeaderSubgraph(environment());
   } else {
@@ skipping 25 matching lines @@
   }
 }
 
 
 void HGraphBuilder::AppendPeeledWhile(IterationStatement* stmt,
                                       HSubgraph* cond_graph,
                                       HSubgraph* body_graph,
                                       HSubgraph* exit_graph,
                                       HBasicBlock* break_block) {
   HSubgraph* loop = NULL;
-  if (body_graph->HasExit() && stmt != peeled_statement_ &&
+  if (body_graph->exit_block() != NULL && stmt != peeled_statement_ &&
       ShouldPeel(cond_graph, body_graph)) {
     // Save the last peeled iteration statement to prevent infinite recursion.
     IterationStatement* outer_peeled_statement = peeled_statement_;
     peeled_statement_ = stmt;
-    loop = CreateGotoSubgraph(body_graph->environment());
+    loop = CreateGotoSubgraph(body_graph->exit_block()->last_environment());
     ADD_TO_SUBGRAPH(loop, stmt);
     peeled_statement_ = outer_peeled_statement;
   }
   subgraph()->AppendWhile(cond_graph, body_graph, stmt, loop, exit_graph,
                           break_block);
 }
 
 
 void HGraphBuilder::VisitForStatement(ForStatement* stmt) {
   // Only visit the init statement in the peeled part of the loop.
   if (stmt->init() != NULL && peeled_statement_ != stmt) {
     Visit(stmt->init());
     CHECK_BAILOUT;
   }
-  ASSERT(subgraph()->HasExit());
+  ASSERT(current_block() != NULL);
   subgraph()->PreProcessOsrEntry(stmt);
 
   HSubgraph* cond_graph = NULL;
   HSubgraph* body_graph = NULL;
   HSubgraph* exit_graph = NULL;
   if (stmt->cond() != NULL) {
     cond_graph = CreateLoopHeaderSubgraph(environment());
     body_graph = CreateEmptySubgraph();
     exit_graph = CreateEmptySubgraph();
     {
       SubgraphScope scope(this, cond_graph);
       VISIT_FOR_CONTROL(stmt->cond(),
                         body_graph->entry_block(),
                         exit_graph->entry_block());
       body_graph->entry_block()->SetJoinId(stmt->BodyId());
       exit_graph->entry_block()->SetJoinId(stmt->ExitId());
     }
   } else {
     body_graph = CreateLoopHeaderSubgraph(environment());
   }
   BreakAndContinueInfo break_info(stmt);
   { BreakAndContinueScope push(&break_info, this);
     ADD_TO_SUBGRAPH(body_graph, stmt->body());
   }
 
   HSubgraph* next_graph = NULL;
   body_graph->ResolveContinue(stmt, break_info.continue_block());
 
-  if (stmt->next() != NULL && body_graph->HasExit()) {
-    next_graph = CreateGotoSubgraph(body_graph->environment());
+  if (stmt->next() != NULL && body_graph->exit_block() != NULL) {
+    next_graph =
+        CreateGotoSubgraph(body_graph->exit_block()->last_environment());
     ADD_TO_SUBGRAPH(next_graph, stmt->next());
     body_graph->Append(next_graph, NULL, NULL);
     next_graph->entry_block()->SetJoinId(stmt->ContinueId());
   }
 
   if (cond_graph != NULL) {
     AppendPeeledWhile(stmt, cond_graph, body_graph, exit_graph,
                       break_info.break_block());
   } else {
     subgraph()->AppendEndless(body_graph, stmt, break_info.break_block());
@@ skipping 256 matching lines @@
     // block.  Use the default as a target of the last branch.
     HSubgraph* if_true = body_graphs->at(i);
     HSubgraph* if_false = (i == maps->length() - 1)
         ? default_graph
         : CreateBranchSubgraph(environment());
     HCompareMap* compare =
         new HCompareMap(receiver,
                         maps->at(i),
                         if_true->entry_block(),
                         if_false->entry_block());
-    subgraph()->exit_block()->Finish(compare);
+    current_block()->Finish(compare);
 
-    if (if_true->HasExit()) {
+    if (if_true->exit_block() != NULL) {
       // In an effect context the value of the type switch is not needed.
       // There is no need to merge it at the join block only to discard it.
       if (ast_context()->IsEffect()) {
         if_true->exit_block()->last_environment()->Drop(1);
       }
       if_true->exit_block()->Goto(join_block);
     }
 
-    subgraph()->set_exit_block(if_false->exit_block());
+    set_current_block(if_false->exit_block());
   }
 
   // Connect the default if necessary.
-  if (subgraph()->HasExit()) {
+  if (current_block() != NULL) {
     if (ast_context()->IsEffect()) {
       environment()->Drop(1);
     }
-    subgraph()->exit_block()->Goto(join_block);
+    current_block()->Goto(join_block);
   }
 
   if (join_block->predecessors()->is_empty()) return NULL;
   join_block->SetJoinId(join_id);
   return join_block;
 }
 
 
 // Sets the lookup result and returns true if the store can be inlined.
 static bool ComputeStoredField(Handle<Map> type,
@@ skipping 136 matching lines @@
       } else {
         HInstruction* instr = BuildStoreNamedGeneric(object, name, value);
         Push(value);
         instr->set_position(expr->position());
         AddInstruction(instr);
       }
     }
 
     HBasicBlock* new_exit_block =
         BuildTypeSwitch(object, &maps, &subgraphs, default_graph, expr->id());
-    subgraph()->set_exit_block(new_exit_block);
+    set_current_block(new_exit_block);
     // In an effect context, we did not materialized the value in the
     // predecessor environments so there's no need to handle it here.
-    if (subgraph()->HasExit() && !ast_context()->IsEffect()) {
+    if (current_block() != NULL && !ast_context()->IsEffect()) {
       ast_context()->ReturnValue(Pop());
     }
   }
 }
 
 
 void HGraphBuilder::HandlePropertyAssignment(Assignment* expr) {
   Property* prop = expr->target()->AsProperty();
   ASSERT(prop != NULL);
   expr->RecordTypeFeedback(oracle());
@@ skipping 310 matching lines @@
         default_graph->FinishExit(new HDeoptimize());
       } else {
         HInstruction* instr = BuildLoadNamedGeneric(object, expr);
         instr->set_position(expr->position());
         PushAndAdd(instr);
       }
     }
 
     HBasicBlock* new_exit_block =
         BuildTypeSwitch(object, &maps, &subgraphs, default_graph, expr->id());
-    subgraph()->set_exit_block(new_exit_block);
+    set_current_block(new_exit_block);
     // In an effect context, we did not materialized the value in the
     // predecessor environments so there's no need to handle it here.
-    if (subgraph()->HasExit() && !ast_context()->IsEffect()) {
+    if (current_block() != NULL && !ast_context()->IsEffect()) {
       ast_context()->ReturnValue(Pop());
     }
   }
 }
 
 
 HLoadNamedField* HGraphBuilder::BuildLoadNamedField(HValue* object,
                                                     Property* expr,
                                                     Handle<Map> type,
                                                     LookupResult* lookup,
@@ skipping 336 matching lines @@
         AddInstruction(context);
         HCall* call = new HCallNamed(context, name, argument_count);
         call->set_position(expr->position());
         PreProcessCall(call);
         PushAndAdd(call);
       }
     }
 
     HBasicBlock* new_exit_block =
         BuildTypeSwitch(receiver, &maps, &subgraphs, default_graph, expr->id());
-    subgraph()->set_exit_block(new_exit_block);
+    set_current_block(new_exit_block);
     // In an effect context, we did not materialized the value in the
     // predecessor environments so there's no need to handle it here.
     if (new_exit_block != NULL && !ast_context()->IsEffect()) {
       ast_context()->ReturnValue(Pop());
     }
   }
 }
 
 
 void HGraphBuilder::TraceInline(Handle<JSFunction> target, bool result) {
@@ skipping 148 matching lines @@
     oracle_ = saved_oracle;
     graph()->info()->SetOsrAstId(saved_osr_ast_id);
     return false;
   }
 
   // Update inlined nodes count.
   inlined_count_ += nodes_added;
 
   if (FLAG_trace_inlining) TraceInline(target, true);
 
-  if (body->HasExit()) {
+  if (body->exit_block() != NULL) {
     // Add a return of undefined if control can fall off the body.  In a
     // test context, undefined is false.
     HValue* return_value = graph()->GetConstantUndefined();
     if (test_context == NULL) {
       ASSERT(function_return_ != NULL);
       body->exit_block()->AddLeaveInlined(return_value, function_return_);
     } else {
       // The graph builder assumes control can reach both branches of a
       // test, so we materialize the undefined value and test it rather than
       // simply jumping to the false target.
       //
       // TODO(3168478): refactor to avoid this.
       HBasicBlock* empty_true = graph()->CreateBasicBlock();
       HBasicBlock* empty_false = graph()->CreateBasicBlock();
       HTest* test = new HTest(return_value, empty_true, empty_false);
       body->exit_block()->Finish(test);
 
       HValue* const no_return_value = NULL;
       empty_true->AddLeaveInlined(no_return_value, test_context->if_true());
       empty_false->AddLeaveInlined(no_return_value, test_context->if_false());
     }
     body->set_exit_block(NULL);
   }
 
   // Record the environment at the inlined function call.
   AddSimulate(expr->ReturnId());
 
   // Jump to the function entry (without re-recording the environment).
-  subgraph()->exit_block()->Finish(new HGoto(body->entry_block()));
+  current_block()->Finish(new HGoto(body->entry_block()));
 
   // Fix up the function exits.
   if (test_context != NULL) {
     HBasicBlock* if_true = test_context->if_true();
     HBasicBlock* if_false = test_context->if_false();
     if_true->SetJoinId(expr->id());
     if_false->SetJoinId(expr->id());
     ASSERT(ast_context() == test_context);
     delete test_context;  // Destructor pops from expression context stack.
 
     // Forward to the real test context.
     HValue* const no_return_value = NULL;
     HBasicBlock* true_target = TestContext::cast(ast_context())->if_true();
     if (true_target->IsInlineReturnTarget()) {
       if_true->AddLeaveInlined(no_return_value, true_target);
     } else {
       if_true->Goto(true_target);
     }
 
     HBasicBlock* false_target = TestContext::cast(ast_context())->if_false();
     if (false_target->IsInlineReturnTarget()) {
       if_false->AddLeaveInlined(no_return_value, false_target);
     } else {
       if_false->Goto(false_target);
     }
 
     // TODO(kmillikin): Come up with a better way to handle this. It is too
     // subtle. NULL here indicates that the enclosing context has no control
     // flow to handle.
-    subgraph()->set_exit_block(NULL);
+    set_current_block(NULL);
 
   } else {
     function_return_->SetJoinId(expr->id());
-    subgraph()->set_exit_block(function_return_);
+    set_current_block(function_return_);
   }
 
   call_context_ = saved_call_context;
   function_return_ = saved_function_return;
   oracle_ = saved_oracle;
   graph()->info()->SetOsrAstId(saved_osr_ast_id);
 
   return true;
 }
 
@@ skipping 208 matching lines @@
         // When the target has a custom call IC generator, use the IC,
         // because it is likely to generate better code. Also use the
         // IC when a primitive receiver check is required.
         HContext* context = new HContext;
         AddInstruction(context);
         call = new HCallNamed(context, name, argument_count);
       } else {
         AddCheckConstantFunction(expr, receiver, receiver_map, true);
 
         if (TryInline(expr)) {
-          if (subgraph()->HasExit()) {
+          if (current_block() != NULL) {
             HValue* return_value = Pop();
             // If we inlined a function in a test context then we need to emit
             // a simulate here to shadow the ones at the end of the
             // predecessor blocks.  Those environments contain the return
             // value on top and do not correspond to any actual state of the
             // unoptimized code.
             if (ast_context()->IsEffect()) AddSimulate(expr->id());
             ast_context()->ReturnValue(return_value);
           }
           return;
@@ skipping 50 matching lines @@
         // Replace the global object with the global receiver.
         HGlobalReceiver* global_receiver = new HGlobalReceiver(global_object);
         // Index of the receiver from the top of the expression stack.
         const int receiver_index = argument_count - 1;
         AddInstruction(global_receiver);
         ASSERT(environment()->ExpressionStackAt(receiver_index)->
                IsGlobalObject());
         environment()->SetExpressionStackAt(receiver_index, global_receiver);
 
         if (TryInline(expr)) {
-          if (subgraph()->HasExit()) {
+          if (current_block() != NULL) {
             HValue* return_value = Pop();
             // If we inlined a function in a test context then we need to
             // emit a simulate here to shadow the ones at the end of the
             // predecessor blocks.  Those environments contain the return
             // value on top and do not correspond to any actual state of the
             // unoptimized code.
             if (ast_context()->IsEffect()) AddSimulate(expr->id());
             ast_context()->ReturnValue(return_value);
           }
           return;
@@ skipping 147 matching lines @@
       VisitForControl(expr->expression(),
                       context->if_false(),
                       context->if_true());
     } else if (ast_context()->IsValue()) {
       HSubgraph* true_graph = CreateEmptySubgraph();
       HSubgraph* false_graph = CreateEmptySubgraph();
       VISIT_FOR_CONTROL(expr->expression(),
                         false_graph->entry_block(),
                         true_graph->entry_block());
       true_graph->entry_block()->SetJoinId(expr->expression()->id());
-      true_graph->environment()->Push(graph_->GetConstantTrue());
+      true_graph->exit_block()->last_environment()->Push(
+          graph_->GetConstantTrue());
 
       false_graph->entry_block()->SetJoinId(expr->expression()->id());
-      false_graph->environment()->Push(graph_->GetConstantFalse());
+      false_graph->exit_block()->last_environment()->Push(
+          graph_->GetConstantFalse());
 
       current_subgraph_->AppendJoin(true_graph, false_graph, expr);
       ast_context()->ReturnValue(Pop());
     } else {
       ASSERT(ast_context()->IsEffect());
       VISIT_FOR_EFFECT(expr->expression());
     }
 
   } else if (op == Token::BIT_NOT || op == Token::SUB) {
     VISIT_FOR_VALUE(expr->expression());
@@ skipping 276 matching lines @@
       HBasicBlock* eval_right = graph()->CreateBasicBlock();
       if (is_logical_and) {
         VISIT_FOR_CONTROL(expr->left(), eval_right, context->if_false());
       } else {
         VISIT_FOR_CONTROL(expr->left(), context->if_true(), eval_right);
       }
       eval_right->SetJoinId(expr->RightId());
 
       // Translate right subexpression by visiting it in the same AST
       // context as the entire expression.
-      subgraph()->set_exit_block(eval_right);
+      set_current_block(eval_right);
       Visit(expr->right());
 
     } else if (ast_context()->IsValue()) {
       VISIT_FOR_VALUE(expr->left());
-      ASSERT(current_subgraph_->HasExit());
+      ASSERT(current_block() != NULL);
 
       HValue* left = Top();
       HEnvironment* environment_copy = environment()->Copy();
       environment_copy->Pop();
       HSubgraph* right_subgraph;
       right_subgraph = CreateBranchSubgraph(environment_copy);
       ADD_TO_SUBGRAPH(right_subgraph, expr->right());
 
-      ASSERT(subgraph()->HasExit() && right_subgraph->HasExit());
+      ASSERT(current_block() != NULL &&
+             right_subgraph->exit_block() != NULL);
       // We need an extra block to maintain edge-split form.
       HBasicBlock* empty_block = graph()->CreateBasicBlock();
       HBasicBlock* join_block = graph()->CreateBasicBlock();
 
       HTest* test = is_logical_and
           ? new HTest(left, right_subgraph->entry_block(), empty_block)
           : new HTest(left, empty_block, right_subgraph->entry_block());
-      subgraph()->exit_block()->Finish(test);
+      current_block()->Finish(test);
       empty_block->Goto(join_block);
       right_subgraph->exit_block()->Goto(join_block);
       join_block->SetJoinId(expr->id());
-      subgraph()->set_exit_block(join_block);
+      set_current_block(join_block);
       ast_context()->ReturnValue(Pop());
     } else {
       ASSERT(ast_context()->IsEffect());
       // In an effect context, we don't need the value of the left
       // subexpression, only its control flow and side effects.  We need an
       // extra block to maintain edge-split form.
       HBasicBlock* empty_block = graph()->CreateBasicBlock();
       HBasicBlock* right_block = graph()->CreateBasicBlock();
       HBasicBlock* join_block = graph()->CreateBasicBlock();
       if (is_logical_and) {
         VISIT_FOR_CONTROL(expr->left(), right_block, empty_block);
       } else {
         VISIT_FOR_CONTROL(expr->left(), empty_block, right_block);
       }
       // TODO(kmillikin): Find a way to fix this.  It's ugly that there are
       // actually two empty blocks (one here and one inserted by
       // TestContext::BuildBranch, and that they both have an HSimulate
       // though the second one is not a merge node, and that we really have
       // no good AST ID to put on that first HSimulate.
       empty_block->SetJoinId(expr->id());
       right_block->SetJoinId(expr->RightId());
-      subgraph()->set_exit_block(right_block);
+      set_current_block(right_block);
       VISIT_FOR_EFFECT(expr->right());
 
       empty_block->Goto(join_block);
-      subgraph()->exit_block()->Goto(join_block);
+      current_block()->Goto(join_block);
       join_block->SetJoinId(expr->id());
-      subgraph()->set_exit_block(join_block);
+      set_current_block(join_block);
       // We did not materialize any value in the predecessor environments,
       // so there is no need to handle it here.
     }
 
   } else {
     VISIT_FOR_VALUE(expr->left());
     VISIT_FOR_VALUE(expr->right());
 
     HValue* right = Pop();
     HValue* left = Pop();
@@ skipping 1030 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal