Change the inlining context from an enum to a class.

runtime/vm/flow_graph.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.h"
 
 #include "vm/bit_vector.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 12 matching lines @@
     current_ssa_temp_index_(0),
     max_block_id_(max_block_id),
     parsed_function_(builder.parsed_function()),
     num_copied_params_(builder.num_copied_params()),
     num_non_copied_params_(builder.num_non_copied_params()),
     num_stack_locals_(builder.num_stack_locals()),
     graph_entry_(graph_entry),
     preorder_(),
     postorder_(),
     reverse_postorder_(),
-    exits_(NULL),
     invalid_dominator_tree_(true) {
   DiscoverBlocks();
 }
 
 
 ConstantInstr* FlowGraph::AddConstantToInitialDefinitions(
     const Object& object) {
   // Check if the constant is already in the pool.
   for (intptr_t i = 0; i < graph_entry_->initial_definitions()->length(); ++i) {
     ConstantInstr* constant =
@@ skipping 158 matching lines @@
       ValidateUseListsInInstruction(it.Current());
     }
   }
   return true;  // Return true so we can ASSERT validation.
 }
 #endif  // DEBUG
 
 
 static void ClearUseLists(Definition* defn) {
   ASSERT(defn != NULL);
-  ASSERT(defn->input_use_list() == NULL);
-  ASSERT(defn->env_use_list() == NULL);
+  ASSERT(!defn->HasUses());
   defn->set_input_use_list(NULL);
   defn->set_env_use_list(NULL);
 }
 
 
 static void RecordInputUses(Instruction* instr) {
   ASSERT(instr != NULL);
   for (intptr_t i = 0; i < instr->InputCount(); ++i) {
     Value* use = instr->InputAt(i);
     ASSERT(use->instruction() == NULL);
@@ skipping 596 matching lines @@
         use->set_use_index(use_idx);
       }
       // Write the predecessor use.
       phi->SetInputAt(new_index, pred_use);
       pred_use->set_use_index(new_index);
     }
   }
 }
 
 
-// Helper to sort a list of blocks.
-static int LowestBlockIdFirst(BlockEntryInstr* const* a,
-                              BlockEntryInstr* const* b) {
-  return (*a)->block_id() - (*b)->block_id();
-}
-
-
 // Inline a flow graph at a call site.
 //
 // Assumes the callee graph was computed by BuildGraph with an inlining context
 // and transformed to SSA with ComputeSSA with a correct virtual register
 // number, and that the use lists have been correctly computed.
 //
 // After inlining the caller graph will correctly have adjusted the pre/post
 // orders, the dominator tree and the use lists.
-void FlowGraph::InlineCall(Definition* call, FlowGraph* callee_graph) {
+void FlowGraph::InlineCall(Definition* call,
+                           FlowGraph* callee_graph,
+                           ValueInliningContext* inlining_context) {
   ASSERT(call->previous() != NULL);
   ASSERT(call->next() != NULL);
-  ASSERT(callee_graph->exits() != NULL);
   ASSERT(callee_graph->graph_entry()->SuccessorCount() == 1);
   ASSERT(callee_graph->max_block_id() > max_block_id());
   ASSERT(callee_graph->max_virtual_register_number() >
          max_virtual_register_number());
 
   // Adjust the max block id to the max block id of the callee graph.
   max_block_id_ = callee_graph->max_block_id();
 
   // Adjust the SSA temp index by the callee graph's index.
   current_ssa_temp_index_ = callee_graph->max_virtual_register_number();
 
   BlockEntryInstr* caller_entry = call->GetBlock();
   TargetEntryInstr* callee_entry = callee_graph->graph_entry()->normal_entry();
-  ZoneGrowableArray<ReturnInstr*>* callee_exits = callee_graph->exits();
 
   // 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);
     }
   }
 
-  // Insert the callee graph into the caller graph.
-  if (callee_exits->is_empty()) {
+  // Insert the callee graph into the caller graph.  First sort the list of
+  // exits by block id (recording block entries as a side effect).
+  inlining_context->SortExits();
+  if (inlining_context->NumExits() == 0) {
     // TODO(zerny): Add support for non-local exits, such as throw.
     UNREACHABLE();
-  } else if (callee_exits->length() == 1) {
-    ReturnInstr* exit = (*callee_exits)[0];
-    ASSERT(exit->previous() != NULL);
+  } else if (inlining_context->NumExits() == 1) {
     // For just one exit, replace the uses and remove the call from the graph.
-    call->ReplaceUsesWith(exit->value()->definition());
+    call->ReplaceUsesWith(inlining_context->ValueAt(0)->definition());
     call->previous()->LinkTo(callee_entry->next());
-    exit->previous()->LinkTo(call->next());
+    inlining_context->LastInstructionAt(0)->LinkTo(call->next());
     // In case of control flow, locally update the predecessors, phis and
     // dominator tree.
     // TODO(zerny): should we leave the dominator tree since we recompute it
     // after a full inlining pass?
     if (callee_graph->preorder().length() > 2) {
-      BlockEntryInstr* exit_block = exit->GetBlock();
+      BlockEntryInstr* exit_block = inlining_context->ExitBlockAt(0);
       // Pictorially, the graph structure is:
       //
       //   Bc : caller_entry    Bi : callee_entry
       //     before_call          inlined_head
       //     call               ... other blocks ...
       //     after_call         Be : exit_block
       //                          inlined_foot
       // And becomes:
       //
       //   Bc : caller_entry
@@ skipping 19 matching lines @@
       // The caller entry is now the immediate dominator of blocks whose
       // immediate dominator was the callee entry.
       caller_entry->ClearDominatedBlocks();
       for (intptr_t i = 0; i < callee_entry->dominated_blocks().length(); ++i) {
         BlockEntryInstr* block = callee_entry->dominated_blocks()[i];
         block->set_dominator(caller_entry);
         caller_entry->AddDominatedBlock(block);
       }
     }
   } else {
-    // Sort the list of exits by block id.
-    GrowableArray<BlockEntryInstr*> exits(callee_exits->length());
-    for (intptr_t i = 0; i < callee_exits->length(); ++i) {
-      exits.Add((*callee_exits)[i]->GetBlock());
-    }
-    exits.Sort(LowestBlockIdFirst);
     // Create a join of the returns.
     JoinEntryInstr* join =
         new JoinEntryInstr(++max_block_id_,
                            CatchClauseNode::kInvalidTryIndex,
                            caller_entry->loop_depth());
-    for (intptr_t i = 0; i < exits.length(); ++i) {
-      ReturnInstr* exit_instr = exits[i]->last_instruction()->AsReturn();
-      ASSERT(exit_instr != NULL);
-      exit_instr->previous()->Goto(join);
+    intptr_t count = inlining_context->NumExits();
+    for (intptr_t i = 0; i < count; ++i) {
+      inlining_context->LastInstructionAt(i)->Goto(join);
       // Directly add the predecessors of the join in ascending block id order.
-      join->predecessors_.Add(exits[i]);
+      join->predecessors_.Add(inlining_context->ExitBlockAt(i));
     }
     // If the call has uses, create a phi of the returns.
-    if ((call->input_use_list() != NULL) ||
-        (call->env_use_list() != NULL)) {
+    if (call->HasUses()) {
       // Environment count: length before call - argument count (+ return)
       intptr_t env_count = call->env()->Length() - call->ArgumentCount();
       // Add a phi of the return values.
       join->InsertPhi(env_count, env_count + 1);
       PhiInstr* phi = join->phis()->Last();
       phi->set_ssa_temp_index(alloc_ssa_temp_index());
       phi->mark_alive();
-      for (intptr_t i = 0; i < exits.length(); ++i) {
-        ReturnInstr* exit_instr = exits[i]->last_instruction()->AsReturn();
-        ASSERT(exit_instr != NULL);
-        Value* use = exit_instr->value();
-        phi->SetInputAt(i, use);
-        use->set_instruction(phi);
-        use->set_use_index(i);
+      for (intptr_t i = 0; i < count; ++i) {
+        Value* value = inlining_context->ValueAt(i);
+        phi->SetInputAt(i, value);
+        value->set_instruction(phi);
+        value->set_use_index(i);
       }
       // Replace uses of the call with the phi.
       call->ReplaceUsesWith(phi);
     }
     // Remove the call from the graph.
     call->previous()->LinkTo(callee_entry->next());
     join->LinkTo(call->next());
     // Replace the blocks after splitting (see comment in the len=1 case above).
     ReplacePredecessor(caller_entry, join);
     ReplacePredecessor(callee_entry, caller_entry);
-    // Update the last instruction pointers on each exit (ie, to the new goto).
-    for (intptr_t i = 0; i < exits.length(); ++i) {
-      exits[i]->set_last_instruction(
-          exits[i]->last_instruction()->previous()->next());
+    // Update the last instruction pointers on each exit block to the new goto.
+    for (intptr_t i = 0; i < count; ++i) {
+      inlining_context->ExitBlockAt(i)->set_last_instruction(
+          inlining_context->LastInstructionAt(i)->next());
     }
     // Mark that the dominator tree is invalid.
     // TODO(zerny): Compute the dominator frontier locally.
     invalid_dominator_tree_ = true;
   }
 }
 
 
 void FlowGraph::RepairGraphAfterInlining() {
   DiscoverBlocks();
@@ skipping 12 matching lines @@
          !it.Done();
          it.Advance()) {
       ++size;
     }
   }
   return size;
 }
 
 
 }  // namespace dart