Initial support for polymorphic inlining.

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 79 matching lines @@
   }
 }
 
 
 void InlineExitCollector::AddExit(ReturnInstr* exit) {
   Data data = { NULL, exit };
   exits_.Add(data);
 }
 
 
+void InlineExitCollector::Union(const InlineExitCollector* other) {
+  // It doesn't make sense to combine different calls or calls from
+  // different graphs.
+  ASSERT(caller_graph_ == other->caller_graph_);
+  ASSERT(call_ == other->call_);
+  exits_.AddArray(other->exits_);
+}
+
+
 int InlineExitCollector::LowestBlockIdFirst(const Data* a, const Data* b) {
   return (a->exit_block->block_id() - b->exit_block->block_id());
 }
 
 
 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();
@@ skipping 16 matching lines @@
     ReturnAt(0)->UnuseAllInputs();
     *exit_block = ExitBlockAt(0);
     *last_instruction = LastInstructionAt(0);
     return call_->HasUses() ? ValueAt(0)->definition() : NULL;
   } else {
     // Create a join of the returns.
     intptr_t join_id = caller_graph_->max_block_id() + 1;
     caller_graph_->set_max_block_id(join_id);
     JoinEntryInstr* join =
         new JoinEntryInstr(join_id, CatchClauseNode::kInvalidTryIndex);
-    join->InheritDeoptTarget(call_);
+    join->InheritDeoptTargetAfter(call_);
 
     // The dominator set of the join is the intersection of the dominator
     // sets of all the predecessors.  If we keep the dominator sets ordered
     // by height in the dominator tree, we can also get the immediate
     // dominator of the join node from the intersection.
     //
     // block_dominators is the dominator set for each block, ordered from
     // the immediate dominator to the root of the dominator tree.  This is
     // the order we collect them in (adding at the end).
     //
@@ skipping 26 matching lines @@
         }
       } else {
         // Intersect the block's dominators with the join's dominators so far.
         intptr_t last = block_dominators.length() - 1;
         for (intptr_t j = 0; j < join_dominators.length(); ++j) {
           intptr_t k = last - j;  // Corresponding index in block_dominators.
           if ((k < 0) || (join_dominators[j] != block_dominators[k])) {
             // We either exhausted the dominators for this block before
             // exhausting the current intersection, or else we found a block
             // on the path from the root of the tree that is not in common.
-            ASSERT(j >= 2);
+            // I.e., there cannot be an empty set of dominators.
+            ASSERT(j > 0);
             join_dominators.TruncateTo(j);
             break;
           }
         }
       }
     }
     // The immediate dominator of the join is the last one in the ordered
     // intersection.
-    join->set_dominator(join_dominators.Last());
     join_dominators.Last()->AddDominatedBlock(join);
     *exit_block = join;
     *last_instruction = join;
 
     // If the call has uses, create a phi of the returns.
     if (call_->HasUses()) {
       // Add a phi of the return values.
       PhiInstr* phi = new PhiInstr(join, num_exits);
       phi->set_ssa_temp_index(caller_graph_->alloc_ssa_temp_index());
       phi->mark_alive();
@@ skipping 63 matching lines @@
     call_block->ReplaceAsPredecessorWith(callee_exit);
     // For successors of 'inlined_head', the callee entry (Bi) is replaced
     // as a predecessor by the call block (Bc).
     callee_entry->ReplaceAsPredecessorWith(call_block);
 
     // The callee exit is now the immediate dominator of blocks whose
     // immediate dominator was the call block.
     ASSERT(callee_exit->dominated_blocks().is_empty());
     for (intptr_t i = 0; i < call_block->dominated_blocks().length(); ++i) {
       BlockEntryInstr* block = call_block->dominated_blocks()[i];
-      block->set_dominator(callee_exit);
       callee_exit->AddDominatedBlock(block);
     }
     // The call block is now the immediate dominator of blocks whose
     // immediate dominator was the callee entry.
     call_block->ClearDominatedBlocks();
     for (intptr_t i = 0; i < callee_entry->dominated_blocks().length(); ++i) {
       BlockEntryInstr* block = callee_entry->dominated_blocks()[i];
-      block->set_dominator(call_block);
       call_block->AddDominatedBlock(block);
     }
   }
 }
 
 
 void EffectGraphVisitor::Append(const EffectGraphVisitor& other_fragment) {
   ASSERT(is_open());
   if (other_fragment.is_empty()) return;
   if (is_empty()) {
@@ skipping 3080 matching lines @@
   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