Add support for converted closures with explicit contexts to VM

runtime/vm/kernel_binary_flowgraph.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 "vm/kernel_binary_flowgraph.h"
 
 #include "vm/compiler.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 
@@ skipping 113 matching lines @@
   parsed_function->SetNodeSequence(
       new SequenceNode(TokenPosition::kNoSource, scope_));
 
   intptr_t parent_offset = -1;
   builder_->SetOffset(kernel_offset_);
 
   FunctionNodeHelper function_node_helper(builder_);
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
+    case RawFunction::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction:
     case RawFunction::kConstructor: {
       const Tag tag = builder_->PeekTag();
       parent_offset = builder_->ReadUntilFunctionNode();
       function_node_helper.ReadUntilExcluding(
           FunctionNodeHelper::kPositionalParameters);
       current_function_async_marker_ = function_node_helper.async_marker_;
       // NOTE: FunctionNode is read further below the if.
@@ skipping 524 matching lines @@
       return;
     case kDoubleLiteral:
       builder_->SkipStringReference();  // read index into string table.
       return;
     case kTrueLiteral:
       return;
     case kFalseLiteral:
       return;
     case kNullLiteral:
       return;
+    case kVectorCreation:
+      builder_->ReadUInt();  // read size.
+      return;
+    case kVectorGet:
+      VisitExpression();     // read expression.
+      builder_->ReadUInt();  // read index.
+      return;
+    case kVectorSet:
+      VisitExpression();     // read vector expression.
+      builder_->ReadUInt();  // read index.
+      VisitExpression();     // read value.
+      return;
+    case kVectorCopy:
+      VisitExpression();  // read vector expression.
+      return;
+    case kClosureCreation:
+      builder_->SkipCanonicalNameReference();  // read function reference.
+      VisitExpression();                       // read context vector.
+      VisitDartType();  // read function type of the closure.
+      return;
     default:
       UNREACHABLE();
   }
 }
 
 void StreamingScopeBuilder::VisitStatement() {
   Tag tag = builder_->ReadTag();  // read tag.
   switch (tag) {
     case kInvalidStatement:
       return;
@@ skipping 316 matching lines @@
   result_->locals.Insert(kernel_offset_no_tag, variable);
 }
 
 void StreamingScopeBuilder::VisitDartType() {
   Tag tag = builder_->ReadTag();
   switch (tag) {
     case kInvalidType:
     case kDynamicType:
     case kVoidType:
     case kBottomType:
+    case kVectorType:
       // those contain nothing.
       return;
     case kInterfaceType:
       VisitInterfaceType(false);
       return;
     case kSimpleInterfaceType:
       VisitInterfaceType(true);
       return;
     case kFunctionType:
       VisitFunctionType(false);
@@ skipping 380 matching lines @@
           Error::Handle(Z),  // No previous error.
           dart::Script::Handle(Z, dart::Script::null()),
           TokenPosition::kNoSource, "[InvalidType] in Kernel IR.");
       break;
     case kDynamicType:
       result_ = Object::dynamic_type().raw();
       break;
     case kVoidType:
       result_ = Object::void_type().raw();
       break;
+    case kVectorType:
+      result_ = Object::vector_type().raw();
+      break;
     case kBottomType:
       result_ = dart::Class::Handle(Z, I->object_store()->null_class())
                     .CanonicalType();
       break;
     case kInterfaceType:
       BuildInterfaceType(false);
       break;
     case kSimpleInterfaceType:
       BuildInterfaceType(true);
       break;
@@ skipping 1554 matching lines @@
                      argument_names);
 
   // Return the result.
   body += Return(function_node_helper.end_position_);
 
   return new (Z)
       FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
                 flow_graph_builder_->next_block_id_ - 1);
 }
 
+// This method follows the logic of
+// StreamingFlowGraphBuilder::BuildGraphOfImplicitClosureFunction.  For
+// additional details on converted closure functions, please, see the comment on
+// the method Function::ConvertedClosureFunction.
+FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfConvertedClosureFunction(
+    const Function& function) {
+  const Function& target = Function::ZoneHandle(Z, function.parent_function());
+
+  TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
+  flow_graph_builder_->graph_entry_ = new (Z) GraphEntryInstr(
+      *parsed_function(), normal_entry, Compiler::kNoOSRDeoptId);
+  SetupDefaultParameterValues();
+
+  Fragment body(normal_entry);
+  body += flow_graph_builder_->CheckStackOverflowInPrologue();
+
+  // Load all the arguments.
+  ASSERT(target.is_static());
+
+  FunctionNodeHelper function_node_helper(this);
+  function_node_helper.ReadUntilExcluding(
+      FunctionNodeHelper::kPositionalParameters);
+
+  // Positional.
+  const intptr_t positional_argument_count = ReadListLength();
+
+  // The first argument is the instance of the closure class.  For converted
+  // closures its context field contains the context vector that is used by the
+  // converted top-level function (target) explicitly and that should be passed
+  // to that function as the first parameter.
+  body += LoadLocal(LookupVariable(ReaderOffset()));  // 0th variable offset.
+  body += flow_graph_builder_->LoadField(Closure::context_offset());
+  body += PushArgument();
+  SkipVariableDeclaration();  // read 0th variable.
+
+  // The rest of the parameters are the same for the method of the Closure class
+  // being invoked and the top-level function (target).
+  for (intptr_t i = 1; i < positional_argument_count; i++) {
+    body += LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
+    body += PushArgument();
+    SkipVariableDeclaration();  // read ith variable.
+  }
+
+  // Named.
+  const intptr_t named_argument_count = ReadListLength();
+  Array& argument_names = Array::ZoneHandle(Z);
+  if (named_argument_count > 0) {
+    argument_names = Array::New(named_argument_count);
+    for (intptr_t i = 0; i < named_argument_count; i++) {
+      body +=
+          LoadLocal(LookupVariable(ReaderOffset()));  // ith variable offset.
+      body += PushArgument();
+      argument_names.SetAt(
+          i, H.DartSymbol(GetNameFromVariableDeclaration(ReaderOffset())));
+      SkipVariableDeclaration();  // read ith variable.
+    }
+  }
+
+  // Forward them to the target.
+  const intptr_t argument_count =
+      positional_argument_count + named_argument_count;
+  body += StaticCall(TokenPosition::kNoSource, target, argument_count,
+                     argument_names);
+
+  // Return the result.
+  body += Return(function_node_helper.end_position_);
+
+  return new (Z)
+      FlowGraph(*parsed_function(), flow_graph_builder_->graph_entry_,
+                flow_graph_builder_->next_block_id_ - 1);
+}
+
 FlowGraph* StreamingFlowGraphBuilder::BuildGraphOfFunction(
     intptr_t constructor_class_parent_offset) {
   const Function& dart_function = parsed_function()->function();
   TargetEntryInstr* normal_entry = flow_graph_builder_->BuildTargetEntry();
   flow_graph_builder_->graph_entry_ = new (Z) GraphEntryInstr(
       *parsed_function(), normal_entry, flow_graph_builder_->osr_id_);
 
   SetupDefaultParameterValues();
 
   Fragment body;
@@ skipping 320 matching lines @@
   // will not need an AST.  The code generator will assume that there is a
   // local variable stack slot allocated for the current context and (I
   // think) that the runtime will expect it to be at a fixed offset which
   // requires allocating an unused expression temporary variable.
   set_scopes(parsed_function()->EnsureKernelScopes());
 
   SetOffset(kernel_offset);
 
   switch (function.kind()) {
     case RawFunction::kClosureFunction:
+    case RawFunction::kConvertedClosureFunction:
     case RawFunction::kRegularFunction:
     case RawFunction::kGetterFunction:
     case RawFunction::kSetterFunction: {
       ReadUntilFunctionNode();  // read until function node.
-      return function.IsImplicitClosureFunction()
-                 ? BuildGraphOfImplicitClosureFunction(function)
-                 : BuildGraphOfFunction();
+      if (function.IsImplicitClosureFunction()) {
+        return BuildGraphOfImplicitClosureFunction(function);
+      } else if (function.IsConvertedClosureFunction()) {
+        return BuildGraphOfConvertedClosureFunction(function);
+      }
+      return BuildGraphOfFunction();
     }
     case RawFunction::kConstructor: {
       bool is_factory = function.IsFactory();
       if (is_factory) {
         ReadUntilFunctionNode();  // read until function node.
         return BuildGraphOfFunction();
       } else {
         // Constructor: Pass offset to parent class.
         return BuildGraphOfFunction(
             ReadUntilFunctionNode());  // read until function node.
@@ skipping 108 matching lines @@
     case kPositiveIntLiteral:
       return BuildIntLiteral(false, position);
     case kDoubleLiteral:
       return BuildDoubleLiteral(position);
     case kTrueLiteral:
       return BuildBoolLiteral(true, position);
     case kFalseLiteral:
       return BuildBoolLiteral(false, position);
     case kNullLiteral:
       return BuildNullLiteral(position);
+    case kVectorCreation:
+      return BuildVectorCreation(position);
+    case kVectorGet:
+      return BuildVectorGet(position);
+    case kVectorSet:
+      return BuildVectorSet(position);
+    case kVectorCopy:
+      return BuildVectorCopy(position);
+    case kClosureCreation:
+      return BuildClosureCreation(position);
     default:
       UNREACHABLE();
   }
 
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildStatement() {
   Tag tag = ReadTag();  // read tag.
   switch (tag) {
@@ skipping 146 matching lines @@
   ReadUInt();
 }
 
 void StreamingFlowGraphBuilder::SkipDartType() {
   Tag tag = ReadTag();
   switch (tag) {
     case kInvalidType:
     case kDynamicType:
     case kVoidType:
     case kBottomType:
+    case kVectorType:
       // those contain nothing.
       return;
     case kInterfaceType:
       SkipInterfaceType(false);
       return;
     case kSimpleInterfaceType:
       SkipInterfaceType(true);
       return;
     case kFunctionType:
       SkipFunctionType(false);
@@ skipping 228 matching lines @@
       }
       return;
     }
     case kFunctionExpression:
       SkipFunctionNode();  // read function node.
       return;
     case kLet:
       SkipVariableDeclaration();  // read variable declaration.
       SkipExpression();           // read expression.
       return;
+    case kVectorCreation:
+      ReadUInt();  // read value.
+      return;
+    case kVectorGet:
+      SkipExpression();  // read vector expression.
+      ReadUInt();        // read index.
+      return;
+    case kVectorSet:
+      SkipExpression();  // read vector expression.
+      ReadUInt();        // read index.
+      SkipExpression();  // read value.
+      return;
+    case kVectorCopy:
+      SkipExpression();  // read vector expression.
+      return;
+    case kClosureCreation:
+      SkipCanonicalNameReference();  // read top-level function reference.
+      SkipExpression();              // read context vector.
+      SkipDartType();                // read function type.
+      return;
     case kBigIntLiteral:
       SkipStringReference();  // read string reference.
       return;
     case kStringLiteral:
       SkipStringReference();  // read string reference.
       return;
     case kSpecialIntLiteral:
       return;
     case kNegativeIntLiteral:
       ReadUInt();  // read value.
@@ skipping 325 matching lines @@
 
 GrowableArray<YieldContinuation>&
 StreamingFlowGraphBuilder::yield_continuations() {
   return flow_graph_builder_->yield_continuations_;
 }
 
 Value* StreamingFlowGraphBuilder::stack() {
   return flow_graph_builder_->stack_;
 }
 
+void StreamingFlowGraphBuilder::Push(Definition* definition) {
+  flow_graph_builder_->Push(definition);
+}
+
 Value* StreamingFlowGraphBuilder::Pop() {
   return flow_graph_builder_->Pop();
 }
 
 Tag StreamingFlowGraphBuilder::PeekArgumentsFirstPositionalTag() {
   // read parts of arguments, then go back to before doing so.
   AlternativeReadingScope alt(reader_);
   ReadUInt();  // read number of arguments.
 
   SkipListOfDartTypes();  // Read list of types.
@@ skipping 148 matching lines @@
                                                   bool number_check) {
   return flow_graph_builder_->StrictCompare(kind, number_check);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateObject(TokenPosition position,
                                                    const dart::Class& klass,
                                                    intptr_t argument_count) {
   return flow_graph_builder_->AllocateObject(position, klass, argument_count);
 }
 
+Fragment StreamingFlowGraphBuilder::AllocateObject(
+    const dart::Class& klass,
+    const Function& closure_function) {
+  return flow_graph_builder_->AllocateObject(klass, closure_function);
+}
+
+Fragment StreamingFlowGraphBuilder::AllocateContext(intptr_t size) {
+  return flow_graph_builder_->AllocateContext(size);
+}
+
+Fragment StreamingFlowGraphBuilder::LoadField(intptr_t offset) {
+  return flow_graph_builder_->LoadField(offset);
+}
+
 Fragment StreamingFlowGraphBuilder::InstanceCall(
     TokenPosition position,
     const dart::String& name,
     Token::Kind kind,
     intptr_t type_args_len,
     intptr_t argument_count,
     const Array& argument_names,
     intptr_t checked_argument_count) {
   return flow_graph_builder_->InstanceCall(position, name, kind, type_args_len,
                                            argument_count, argument_names,
                                            checked_argument_count);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreLocal(TokenPosition position,
                                                LocalVariable* variable) {
   return flow_graph_builder_->StoreLocal(position, variable);
 }
 
 Fragment StreamingFlowGraphBuilder::StoreStaticField(TokenPosition position,
                                                      const dart::Field& field) {
   return flow_graph_builder_->StoreStaticField(position, field);
 }
 
+Fragment StreamingFlowGraphBuilder::StoreInstanceField(TokenPosition position,
+                                                       intptr_t offset) {
+  return flow_graph_builder_->StoreInstanceField(position, offset);
+}
+
 Fragment StreamingFlowGraphBuilder::StringInterpolate(TokenPosition position) {
   return flow_graph_builder_->StringInterpolate(position);
 }
 
 Fragment StreamingFlowGraphBuilder::StringInterpolateSingle(
     TokenPosition position) {
   return flow_graph_builder_->StringInterpolateSingle(position);
 }
 
 Fragment StreamingFlowGraphBuilder::ThrowTypeError() {
@@ skipping 1235 matching lines @@
 
   return Constant(Bool::Get(value));
 }
 
 Fragment StreamingFlowGraphBuilder::BuildNullLiteral(TokenPosition* position) {
   if (position != NULL) *position = TokenPosition::kNoSource;
 
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
+Fragment StreamingFlowGraphBuilder::BuildVectorCreation(
+    TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  intptr_t size = ReadUInt();  // read size.
+  return AllocateContext(size);
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVectorGet(TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  Fragment instructions = BuildExpression();  // read expression.
+  intptr_t index = ReadUInt();                // read index.
+  instructions += LoadField(Context::variable_offset(index));
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVectorSet(TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  Fragment instructions = NullConstant();
+  LocalVariable* result = MakeTemporary();
+
+  instructions += BuildExpression();  // read vector expression.
+  intptr_t index = ReadUInt();        // read index.
+  instructions += BuildExpression();  // read value expression.
+  instructions += StoreLocal(TokenPosition::kNoSource, result);
+
+  instructions += StoreInstanceField(TokenPosition::kNoSource,
+                                     Context::variable_offset(index));
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVectorCopy(TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  Fragment instructions = BuildExpression();  // read vector expression.
+  Value* context_to_copy = Pop();
+  CloneContextInstr* clone_instruction =
+      new (Z) CloneContextInstr(TokenPosition::kNoSource, context_to_copy,
+                                Thread::Current()->GetNextDeoptId());
+  instructions <<= clone_instruction;
+  Push(clone_instruction);
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildClosureCreation(
+    TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  NameIndex function_reference =
+      ReadCanonicalNameReference();  // read function reference.
+  Function& function = Function::ZoneHandle(
+      Z, H.LookupStaticMethodByKernelProcedure(function_reference));
+  function = function.ConvertedClosureFunction();
+  ASSERT(!function.IsNull());
+
+  const dart::Class& closure_class =
+      dart::Class::ZoneHandle(Z, I->object_store()->closure_class());
+  Fragment instructions = AllocateObject(closure_class, function);
+  LocalVariable* closure = MakeTemporary();
+
+  instructions += BuildExpression();  // read context vector.
+  LocalVariable* context = MakeTemporary();
+
+  instructions += LoadLocal(closure);
+  instructions += Constant(function);
+  instructions +=
+      StoreInstanceField(TokenPosition::kNoSource, Closure::function_offset());
+
+  instructions += LoadLocal(closure);
+  instructions += LoadLocal(context);
+  instructions +=
+      StoreInstanceField(TokenPosition::kNoSource, Closure::context_offset());
+
+  instructions += Drop();
+
+  SkipDartType();  // skip function type of the closure.
+
+  return instructions;
+}
+
 Fragment StreamingFlowGraphBuilder::BuildInvalidStatement() {
   H.ReportError("Invalid statements not implemented yet!");
   return Fragment();
 }
 
 Fragment StreamingFlowGraphBuilder::BuildExpressionStatement() {
   Fragment instructions = BuildExpression();  // read expression.
   instructions += Drop();
   return instructions;
 }
@@ skipping 1350 matching lines @@
     }
   }
 
   return Array::Handle(Array::null());
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)