Change the inlining context from an enum to a class.

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 "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
 #include "vm/flags.h"
@@ skipping 13 matching lines @@
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_flow_graph, false, "Print the IR flow graph.");
 DEFINE_FLAG(bool, print_flow_graph_optimized, false,
             "Print the IR flow graph when optimizing.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 DECLARE_FLAG(bool, enable_type_checks);
 
 
-FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function)
+FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function,
+                                   InliningContext* inlining_context)
   : 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),
     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),
-    inlining_context_(kNotInlining),
-    exits_(NULL) { }
+    graph_entry_(NULL) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(TargetEntryInstr* entry) {
   graph_entry_->AddCatchEntry(entry);
 }
 
 
+void ValueInliningContext::AddExit(ReturnInstr* exit) {
+  Data data = { NULL, exit };
+  exits_.Add(data);
+}
+
+
+int ValueInliningContext::LowestBlockIdFirst(const Data* a, const Data* b) {
+  return (a->exit_block->block_id() - b->exit_block->block_id());
+}
+
+
+void ValueInliningContext::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);
+}
+
+
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
     entry_ = other_fragment.entry();
     exit_ = other_fragment.exit();
   } else {
     exit()->LinkTo(other_fragment.entry());
     exit_ = other_fragment.exit();
   }
@@ skipping 36 matching lines @@
   DeallocateTempIndex(instruction->InputCount());
   if (is_empty()) {
     entry_ = exit_ = instruction;
   } else {
     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);
+  }
+  CloseFragment();
+}
+
+
 void EffectGraphVisitor::Goto(JoinEntryInstr* join) {
   ASSERT(is_open());
   if (is_empty()) {
     entry_ = new GotoInstr(join);
   } else {
     exit()->Goto(join);
   }
   exit_ = NULL;
 }
 
@@ skipping 397 matching lines @@
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function().saved_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
     BuildLoadContext(*owner()->parsed_function().saved_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
-  ReturnInstr* return_instr = new ReturnInstr(node->token_pos(), return_value);
-  AddReturnExit(return_instr);
-  AddInstruction(return_instr);
-  CloseFragment();
+  AddReturnExit(node->token_pos(), return_value);
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
 
 void ValueGraphVisitor::VisitLiteralNode(LiteralNode* node) {
@@ skipping 2480 matching lines @@
     for_finally_block.Goto(after_finally);
     for_finally_block.exit_ = after_finally;
   }
 
   Goto(finally_entry);
   AppendFragment(finally_entry, for_finally_block);
   exit_ = for_finally_block.exit_;
 }
 
 
-FlowGraph* FlowGraphBuilder::BuildGraph(InliningContext context,
-                                        intptr_t initial_loop_depth) {
+FlowGraph* FlowGraphBuilder::BuildGraph(intptr_t initial_loop_depth) {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
     AstPrinter::PrintFunctionNodes(parsed_function());
   }
-  // Set the inlining context.
-  ASSERT(inlining_context_ == kNotInlining);
-  inlining_context_ = context;
-  if (InInliningContext()) exits_ = new ZoneGrowableArray<ReturnInstr*>();
   // Compilation can be nested, preserve the computation-id.
   const Function& function = parsed_function().function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
                            CatchClauseNode::kInvalidTryIndex,
                            initial_loop_depth);
   graph_entry_ = new GraphEntryInstr(normal_entry);
   EffectGraphVisitor for_effect(this, 0, initial_loop_depth);
   // 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);
   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_);
-  if (InInliningContext()) graph->set_exits(exits_);
   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