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/longjump.h"
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
@@ skipping 1209 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 685 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.
   intptr_t offset = ReaderOffset();
   ReadUInt();  // read number of arguments.
 
   // List of types.
@@ skipping 160 matching lines @@
 Fragment StreamingFlowGraphBuilder::StrictCompare(Token::Kind kind,
                                                   bool number_check) {
   return flow_graph_builder_->StrictCompare(kind, number_check);
 }
 
 Fragment StreamingFlowGraphBuilder::AllocateObject(const dart::Class& klass,
                                                    intptr_t argument_count) {
   return flow_graph_builder_->AllocateObject(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(int 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 argument_count,
                                                  const Array& argument_names,
                                                  intptr_t num_args_checked) {
   return flow_graph_builder_->InstanceCall(position, name, kind, argument_count,
                                            argument_names, num_args_checked);
 }
 
 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 893 matching lines @@
 
     // Let condition be always true.
     instructions += Constant(Bool::True());
   } else {
     instructions += PushArgument();
 
     // See if simple instanceOf is applicable.
     if (dart::FlowGraphBuilder::SimpleInstanceOfType(type)) {
       instructions += Constant(type);
       instructions += PushArgument();  // Type.
-      instructions += InstanceCall(position, dart::Library::PrivateCoreLibName(
-                                                 Symbols::_simpleInstanceOf()),
-                                   Token::kIS, 2, 2);  // 2 checked arguments.
+      instructions += InstanceCall(
+          position,
+          dart::Library::PrivateCoreLibName(Symbols::_simpleInstanceOf()),
+          Token::kIS, 2, 2);  // 2 checked arguments.
       return instructions;
     }
 
     if (!type.IsInstantiated(kCurrentClass)) {
       instructions += LoadInstantiatorTypeArguments();
     } else {
       instructions += NullConstant();
     }
     instructions += PushArgument();  // Instantiator type arguments.
 
@@ skipping 304 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 = BuildExpression();   // read vector expression.
+  intptr_t index = ReadUInt();                 // read index.
+  instructions += BuildExpressionStatement();  // read value expression.

[jensj, 2017/05/18 11:19:05]

Shouldn't this just be BuildExpression();?

[Dmitry Stefantsov, 2017/05/18 12:18:53]

Yes, of course. Thanks! Fixed.

+
+  // The assigned value is the result of the expression.
+  LocalVariable* result = MakeTemporary();
+
+  Value* value = Pop();
+  StoreInstanceFieldInstr* store = new (Z)
+      StoreInstanceFieldInstr(Context::variable_offset(index), Pop(), value,
+                              kNoStoreBarrier, TokenPosition::kNoSource);
+  instructions <<= store;
+
+  // Load the result that is stored in the temporary variable.
+  instructions += LoadLocal(result);
+
+  return instructions;
+}
+
+Fragment StreamingFlowGraphBuilder::BuildVectorCopy(TokenPosition* position) {
+  if (position != NULL) *position = TokenPosition::kNoSource;
+
+  Fragment instructions = BuildExpression();  // read vector expression.
+  CloneContextInstr* clone_instruction =
+      new (Z) CloneContextInstr(TokenPosition::kNoSource, Pop());
+  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 vector expression.

[jensj, 2017/05/18 11:19:06]

from the kernel_binary.cc file I would guess the comment should be "read context
vector"?

[Dmitry Stefantsov, 2017/05/18 12:18:52]

Yep. Thanks!

+  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();
+
+  return instructions;

[jensj, 2017/05/18 11:19:06]

Isn't there a SkipDartType or something missing?

[Dmitry Stefantsov, 2017/05/18 12:18:52]

Yes. I should have put an invocation of SkipDartType here. Thanks! Fixed.

+}
+
 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 926 matching lines @@
   }
   instructions += StoreLocal(position, variable);
   instructions += Drop();
   return instructions;
 }
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)