Add support for OSR in kernel-based FlowGraphBuilder

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, 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 <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 2732 matching lines @@
   UNREACHABLE();
   return NULL;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfFunction(FunctionNode* function,
                                                   Constructor* constructor) {
   const Function& dart_function = parsed_function_->function();
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   SetupDefaultParameterValues(function);
 
   Fragment body;
   if (!dart_function.is_native()) body += CheckStackOverflowInPrologue();
   intptr_t context_size =
       parsed_function_->node_sequence()->scope()->num_context_variables();
   if (context_size > 0) {
     body += PushContext(context_size);
     LocalVariable* context = MakeTemporary();
@@ skipping 146 matching lines @@
       // False branch will contain the next comparison.
       dispatch = Fragment(dispatch.entry, otherwise);
       block = otherwise;
     }
     body = dispatch;
 
     context_depth_ = current_context_depth;
   }
   normal_entry->LinkTo(body.entry);
 
+  // When compiling for OSR, use a depth first search to prune instructions
+  // unreachable from the OSR entry. Catch entries are always considered
+  // reachable, even if they become unreachable after OSR.
+  if (osr_id_ != Compiler::kNoOSRDeoptId) {
+    BitVector* block_marks = new(Z) BitVector(Z, next_block_id_);
+    bool found = graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_,
+                                                block_marks);
+    ASSERT(found);
+  }
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 Fragment FlowGraphBuilder::NativeFunctionBody(FunctionNode* kernel_function,
                                               const Function& function) {
   ASSERT(function.is_native());
   // We explicitly build the graph for native functions in the same way that the
   // from-source backend does.  We should find a way to have a single component
   // to build these graphs so that this code is not duplicated.
@@ skipping 2639 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart