Refactor the code for making inlining decisions.

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 23 matching lines @@
 
 
 static const String& PrivateCoreLibName(const String& str) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
   return private_name;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function,
-                                   InliningContext* inlining_context)
+                                   InlineExitCollector* exit_collector)
   : parsed_function_(parsed_function),
     num_copied_params_(parsed_function.num_copied_params()),
     // All parameters are copied if any parameter is.
     num_non_copied_params_((num_copied_params_ == 0)
         ? parsed_function.function().num_fixed_parameters()
         : 0),
     num_stack_locals_(parsed_function.num_stack_locals()),
-    inlining_context_(inlining_context),
+    exit_collector_(exit_collector),
     last_used_block_id_(0),  // 0 is used for the graph entry.
     context_level_(0),
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
     try_index_(CatchClauseNode::kInvalidTryIndex),
     graph_entry_(NULL) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(CatchBlockEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
-void InliningContext::PrepareGraphs(FlowGraph* callee_graph) {
+void InlineExitCollector::PrepareGraphs(FlowGraph* callee_graph) {
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_block_id() > caller_graph_->max_block_id());
   ASSERT(callee_graph->max_virtual_register_number() >
          caller_graph_->max_virtual_register_number());
 
   // Adjust the caller's maximum block id and current SSA temp index.
   caller_graph_->set_max_block_id(callee_graph->max_block_id());
   caller_graph_->set_current_ssa_temp_index(
       callee_graph->max_virtual_register_number());
 
   // Attach the outer environment on each instruction in the callee graph.
   for (BlockIterator block_it = callee_graph->postorder_iterator();
        !block_it.Done();
        block_it.Advance()) {
     for (ForwardInstructionIterator it(block_it.Current());
          !it.Done();
          it.Advance()) {
       Instruction* instr = it.Current();
       // TODO(zerny): Avoid creating unnecessary environments. Note that some
       // optimizations need deoptimization info for non-deoptable instructions,
       // eg, LICM on GOTOs.
       if (instr->env() != NULL) call_->env()->DeepCopyToOuter(instr);
     }
   }
 }
 
 
-void InliningContext::AddExit(ReturnInstr* exit) {
+void InlineExitCollector::AddExit(ReturnInstr* exit) {
   Data data = { NULL, exit };
   exits_.Add(data);
 }
 
 
-int InliningContext::LowestBlockIdFirst(const Data* a, const Data* b) {
+int InlineExitCollector::LowestBlockIdFirst(const Data* a, const Data* b) {
   return (a->exit_block->block_id() - b->exit_block->block_id());
 }
 
 
-void InliningContext::SortExits() {
+void InlineExitCollector::SortExits() {
   // Assign block entries here because we did not necessarily know them when
   // the return exit was added to the array.
   for (int i = 0; i < exits_.length(); ++i) {
     exits_[i].exit_block = exits_[i].exit_return->GetBlock();
   }
   exits_.Sort(LowestBlockIdFirst);
 }
 
 
-Definition* InliningContext::JoinReturns(BlockEntryInstr** exit_block,
-                                         Instruction** last_instruction) {
+Definition* InlineExitCollector::JoinReturns(BlockEntryInstr** exit_block,
+                                             Instruction** last_instruction) {
   // First sort the list of exits by block id (caching return instruction
   // block entries as a side effect).
   SortExits();
   intptr_t num_exits = exits_.length();
   if (num_exits == 0) {
     // TODO(zerny): Add support for non-local exits, such as throw.
     UNREACHABLE();
     return NULL;
   } else if (num_exits == 1) {
     ReturnAt(0)->UnuseAllInputs();
@@ skipping 84 matching lines @@
       // from their definition's use list.
       for (intptr_t i = 0; i < num_exits; ++i) {
         ReturnAt(i)->UnuseAllInputs();
       }
       return NULL;
     }
   }
 }
 
 
-void InliningContext::ReplaceCall(FlowGraph* callee_graph) {
+void InlineExitCollector::ReplaceCall(TargetEntryInstr* callee_entry) {
   ASSERT(call_->previous() != NULL);
   ASSERT(call_->next() != NULL);
-  PrepareGraphs(callee_graph);
-
   BlockEntryInstr* call_block = call_->GetBlock();
-  TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
 
   // Insert the callee graph into the caller graph.
   BlockEntryInstr* callee_exit = NULL;
   Instruction* callee_last_instruction = NULL;
   Definition* callee_result = JoinReturns(&callee_exit,
                                           &callee_last_instruction);
   if (callee_result != NULL) {
     call_->ReplaceUsesWith(callee_result);
   }
   if (callee_last_instruction == callee_entry) {
@@ skipping 106 matching lines @@
     exit()->LinkTo(instruction);
     exit_ = instruction;
   }
 }
 
 
 void EffectGraphVisitor::AddReturnExit(intptr_t token_pos, Value* value) {
   ASSERT(is_open());
   ReturnInstr* return_instr = new ReturnInstr(token_pos, value);
   AddInstruction(return_instr);
-  InliningContext* inlining_context = owner()->inlining_context();
-  if (inlining_context != NULL) {
-    inlining_context->AddExit(return_instr);
+  InlineExitCollector* exit_collector = owner()->exit_collector();
+  if (exit_collector != NULL) {
+    exit_collector->AddExit(return_instr);
   }
   CloseFragment();
 }
 
 
 void EffectGraphVisitor::Goto(JoinEntryInstr* join) {
   ASSERT(is_open());
   if (is_empty()) {
     entry_ = new GotoInstr(join);
   } else {
@@ skipping 337 matching lines @@
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
   owner()->parsed_function().function().set_is_inlinable(false);
-  if (owner()->InInliningContext()) owner()->Bailout(reason);
+  if (owner()->IsInlining()) owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
@@ skipping 2659 matching lines @@
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
                            CatchClauseNode::kInvalidTryIndex);
   graph_entry_ = new GraphEntryInstr(parsed_function(), normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   // TODO(kmillikin): We can eliminate stack checks in some cases (e.g., the
   // stack check on entry for leaf routines).
   Instruction* check = new CheckStackOverflowInstr(function.token_pos());
   // If we are inlining don't actually attach the stack check. We must still
-  // create the stack check inorder to allocate a deopt id.
-  if (!InInliningContext()) for_effect.AddInstruction(check);
+  // create the stack check in order to allocate a deopt id.
+  if (!IsInlining()) for_effect.AddInstruction(check);
   parsed_function().node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   FlowGraph* graph = new FlowGraph(*this, graph_entry_, last_used_block_id_);
   return graph;
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
   const char* function_name = parsed_function_.function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart