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 2629 matching lines @@
 
 void FlowGraphBuilder::InlineBailout(const char* reason) {
   bool is_inlining = exit_collector_ != NULL;
   if (is_inlining) {
     parsed_function_->function().set_is_inlinable(false);
     parsed_function_->Bailout("kernel::FlowGraphBuilder", reason);
   }
 }
 
 
+void FlowGraphBuilder::PruneUnreachableIfOSR() {
+  // 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);
+  }
+}
+
+
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   const dart::Function& function = parsed_function_->function();
 
   if (function.IsConstructorClosureFunction()) return NULL;
 
   dart::Class& klass =
       dart::Class::Handle(zone_, parsed_function_->function().Owner());
 
   // Find out if there is an enclosing kernel class (which will be used to
   // resolve type parameters).
@@ skipping 83 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);
 
+  PruneUnreachableIfOSR();

[Vyacheslav Egorov (Google), 2016/10/31 17:46:37]

I think  only this one can OSR - inline the function here.

[kustermann, 2016/10/31 18:18:13]

Done.

   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 151 matching lines @@
     Field* kernel_field, LocalVariable* setter_value) {
   const dart::Function& function = parsed_function_->function();
 
   bool is_setter = function.IsImplicitSetterFunction();
   bool is_method = !function.IsStaticFunction();
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(kernel_field));
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   // TODO(27590): Add support for FLAG_use_field_guards.
   Fragment body(normal_entry);
   if (is_setter) {
     if (is_method) {
       body += LoadLocal(scopes_->this_variable);
       body += LoadLocal(setter_value);
       body += StoreInstanceField(field);
     } else {
       body += LoadLocal(setter_value);
@@ skipping 17 matching lines @@
     // The field always has an initializer because static fields without
     // initializers are initialized eagerly and do not have implicit getters.
     ASSERT(field.has_initializer());
     body += Constant(field);
     body += InitStaticField(field);
     body += Constant(field);
     body += LoadStaticField();
   }
   body += Return();
 
+  PruneUnreachableIfOSR();

[Vyacheslav Egorov (Google), 2016/10/31 17:46:37]

I don't think this and below can be OSRed.

[kustermann, 2016/10/31 18:18:13]

Done.

   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfStaticFieldInitializer(
     Field* kernel_field) {
   ASSERT(kernel_field->IsStatic());
 
   Expression* initializer = kernel_field->initializer();
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
   if (kernel_field->IsConst()) {
     body += Constant(constant_evaluator_.EvaluateExpression(initializer));
   } else {
     body += TranslateExpression(initializer);
   }
   body += Return();
 
+  PruneUnreachableIfOSR();
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 Fragment FlowGraphBuilder::BuildImplicitClosureCreation(
     const Function& target) {
   Fragment fragment;
   const dart::Class& closure_class =
       dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
   fragment += AllocateObject(closure_class, target);
@@ skipping 23 matching lines @@
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfMethodExtractor(
     const Function& method) {
   // A method extractor is the implicit getter for a method.
   const Function& function =
       Function::ZoneHandle(Z, method.extracted_method_closure());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
   body += BuildImplicitClosureCreation(function);
   body += Return();
 
+  PruneUnreachableIfOSR();
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfImplicitClosureFunction(
     FunctionNode* kernel_function, const Function& function) {
   const Function& target = Function::ZoneHandle(Z, function.parent_function());
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
   SetupDefaultParameterValues(kernel_function);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
 
   // Load all the arguments.
   if (!target.is_static()) {
     // The context has a fixed shape: a single variable which is the
     // closed-over receiver.
     body += LoadLocal(parsed_function_->current_context_var());
@@ skipping 19 matching lines @@
     }
   }
   // Forward them to the target.
   intptr_t argument_count = positional_argument_count + named_argument_count;
   if (!target.is_static()) ++argument_count;
   body += StaticCall(target, argument_count, argument_names);
 
   // Return the result.
   body += Return();
 
+  PruneUnreachableIfOSR();
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfNoSuchMethodDispatcher(
     const Function& function) {
   // This function is specialized for a receiver class, a method name, and
   // the arguments descriptor at a call site.
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   // The backend will expect an array of default values for all the named
   // parameters, even if they are all known to be passed at the call site
   // because the call site matches the arguments descriptor.  Use null for
   // the default values.
   const Array& descriptor_array =
       Array::ZoneHandle(Z, function.saved_args_desc());
   ArgumentsDescriptor descriptor(descriptor_array);
   ZoneGrowableArray<const Instance*>* default_values =
       new ZoneGrowableArray<const Instance*>(Z, descriptor.NamedCount());
@@ skipping 69 matching lines @@
   if (no_such_method.IsNull()) {
     // If noSuchMethod is not found on the receiver class, call
     // Object.noSuchMethod.
     no_such_method = Resolver::ResolveDynamicForReceiverClass(
         dart::Class::Handle(Z, I->object_store()->object_class()),
         Symbols::NoSuchMethod(), two_arguments);
   }
   body += StaticCall(no_such_method, 2);
   body += Return();
 
+  PruneUnreachableIfOSR();
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher(
     const Function& function) {
   // Find the name of the field we should dispatch to.
   const dart::Class& owner = dart::Class::Handle(Z, function.Owner());
   ASSERT(!owner.IsNull());
   const dart::String& field_name = dart::String::Handle(Z, function.name());
@@ skipping 24 matching lines @@
   dart::String& string_handle = dart::String::Handle(Z);
   for (intptr_t i = 0; i < descriptor.NamedCount(); ++i) {
     default_values->Add(&Object::null_instance());
     string_handle = descriptor.NameAt(i);
     argument_names.SetAt(i, string_handle);
   }
   parsed_function_->set_default_parameter_values(default_values);
 
   TargetEntryInstr* normal_entry = BuildTargetEntry();
   graph_entry_ = new (Z)
-      GraphEntryInstr(*parsed_function_, normal_entry, Compiler::kNoOSRDeoptId);
+      GraphEntryInstr(*parsed_function_, normal_entry, osr_id_);
 
   Fragment body(normal_entry);
   body += CheckStackOverflowInPrologue();
 
   LocalScope* scope = parsed_function_->node_sequence()->scope();
 
   LocalVariable* closure = NULL;
   if (is_closure_call) {
     closure = scope->VariableAt(0);
 
@@ skipping 21 matching lines @@
     body += LoadField(Closure::function_offset());
 
     body += ClosureCall(descriptor.Count(), argument_names);
   } else {
     body += InstanceCall(Symbols::Call(), Token::kILLEGAL, descriptor.Count(),
                          argument_names);
   }
 
   body += Return();
 
+  PruneUnreachableIfOSR();
   return new (Z) FlowGraph(*parsed_function_, graph_entry_, next_block_id_ - 1);
 }
 
 
 void FlowGraphBuilder::SetupDefaultParameterValues(FunctionNode* function) {
   intptr_t num_optional_parameters =
       parsed_function_->function().NumOptionalParameters();
   if (num_optional_parameters > 0) {
     ZoneGrowableArray<const Instance*>* default_values =
         new ZoneGrowableArray<const Instance*>(Z, num_optional_parameters);
@@ skipping 2121 matching lines @@
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions += StoreInstanceField(Closure::context_offset());
 
   return instructions;
 }
 
 
 }  // namespace kernel
 }  // namespace dart