Enable allocation sinking for closures.

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/bit_vector.h"
 #include "vm/code_descriptors.h"
@@ skipping 1822 matching lines @@
 
 LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
   Do(new PushTempInstr(value));
   AllocateTempIndex();
 
   ASSERT(value->definition()->temp_index() == temp_index() - 1);
   intptr_t index = GetCurrentTempLocalIndex();
   char name[64];
   OS::SNPrint(name, 64, ":tmp_local%"Pd, index);
   LocalVariable*  var =
-      new LocalVariable(0, String::ZoneHandle(Symbols::New(name)),
-                        Type::ZoneHandle(Type::DynamicType()));
+      new LocalVariable(0,
+                        String::ZoneHandle(Symbols::New(name)),
+                        *value->Type()->ToAbstractType());
   var->set_index(index);
   return var;
 }
 
 
 Definition* EffectGraphVisitor::ExitTempLocalScope(LocalVariable* var) {
     Value* tmp = Bind(new LoadLocalInstr(*var));
     DeallocateTempIndex(1);
     ASSERT(GetCurrentTempLocalIndex() == var->index());
     return new DropTempsInstr(1, tmp);
@@ skipping 116 matching lines @@
     closure ^= function.implicit_static_closure();
     if (closure.IsNull()) {
       ObjectStore* object_store = Isolate::Current()->object_store();
       const Context& context = Context::Handle(object_store->empty_context());
       closure ^= Closure::New(function, context, Heap::kOld);
       function.set_implicit_static_closure(closure);
     }
     ReturnDefinition(new ConstantInstr(closure));
     return;
   }
-  Value* receiver = NULL;
   if (function.IsNonImplicitClosureFunction()) {
     // The context scope may have already been set by the non-optimizing
     // compiler.  If it was not, set it here.
     if (function.context_scope() == ContextScope::null()) {
       // TODO(regis): Why are we not doing this in the parser?
       const ContextScope& context_scope = ContextScope::ZoneHandle(
           node->scope()->PreserveOuterScope(owner()->context_level()));
       ASSERT(!function.HasCode());
       ASSERT(function.context_scope() == ContextScope::null());
       function.set_context_scope(context_scope);
     }
-    receiver = BuildNullValue();
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>(2);
+    ASSERT(function.context_scope() != ContextScope::null());
+
+    // The function type of a closure may have type arguments. In that case,
+    // pass the type arguments of the instantiator.
+    const Class& cls = Class::ZoneHandle(function.signature_class());
+    ASSERT(!cls.IsNull());
+    const bool requires_type_arguments = cls.HasTypeArguments();
+    Value* type_arguments = NULL;
+    if (requires_type_arguments) {
+      ASSERT(cls.type_arguments_field_offset() ==
+             Closure::type_arguments_offset());
+      const Class& instantiator_class = Class::Handle(
+          owner()->parsed_function()->function().Owner());
+      type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
+                                                      instantiator_class,
+                                                      NULL);
+      arguments->Add(PushArgument(type_arguments));
+
+      Value* instantiator_val = Bind(new ConstantInstr(
+          Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
+      arguments->Add(PushArgument(instantiator_val));
+    }
+    AllocateObjectInstr* alloc = new AllocateObjectInstr(node->token_pos(),
+                                                         cls,
+                                                         arguments);
+    alloc->set_closure_function(function);
+
+    // Create fake fields for function and context. Only the context field is
+    // stored at the allocation to be used later when inlining a closure call.
+    const Field& function_field =
+        Field::ZoneHandle(
+            Field::New(Symbols::ClosureFunctionField(),
+            false,  // !static
+            false,  // !final
+            false,  // !const
+            alloc->cls(),
+            0));  // No token position.
+    function_field.SetOffset(Closure::function_offset());
+    const Field& context_field =
+        Field::ZoneHandle(Field::New(
+            Symbols::ClosureContextField(),
+            false,  // !static
+            false,  // !final
+            false,  // !const
+            alloc->cls(),
+            0));  // No token position.
+    context_field.SetOffset(Closure::context_offset());
+    alloc->set_context_field(context_field);
+
+    Value* closure_val = Bind(alloc);
+    { LocalVariable* tmp_var = EnterTempLocalScope(closure_val);
+      // Store function.
+      Value* tmp_val = Bind(new LoadLocalInstr(*tmp_var));
+      Value* func_val =
+          Bind(new ConstantInstr(Function::ZoneHandle(function.raw())));
+      Do(new StoreInstanceFieldInstr(function_field,
+                                     tmp_val,
+                                     func_val,
+                                     kEmitStoreBarrier));
+      // Store current context.
+      tmp_val = Bind(new LoadLocalInstr(*tmp_var));
+      Value* context = Bind(new CurrentContextInstr());
+      Do(new StoreInstanceFieldInstr(context_field,
+                                     tmp_val,
+                                     context,
+                                     kEmitStoreBarrier));
+      ReturnDefinition(ExitTempLocalScope(tmp_var));
+    }
   } else {
     ASSERT(function.IsImplicitInstanceClosureFunction());
     ValueGraphVisitor for_receiver(owner(), temp_index());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
-    receiver = for_receiver.value();
+    Value* receiver = for_receiver.value();
+
+    PushArgumentInstr* push_receiver = PushArgument(receiver);
+    ZoneGrowableArray<PushArgumentInstr*>* arguments =
+        new ZoneGrowableArray<PushArgumentInstr*>(2);
+    arguments->Add(push_receiver);
+    ASSERT(function.context_scope() != ContextScope::null());
+
+    // The function type of a closure may have type arguments. In that case,
+    // pass the type arguments of the instantiator. Otherwise, pass null object.
+    const Class& cls = Class::Handle(function.signature_class());
+    ASSERT(!cls.IsNull());
+    const bool requires_type_arguments = cls.HasTypeArguments();
+    Value* type_arguments = NULL;
+    if (requires_type_arguments) {
+      const Class& instantiator_class = Class::Handle(
+          owner()->parsed_function()->function().Owner());
+      type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
+                                                      instantiator_class,
+                                                      NULL);
+    } else {
+      type_arguments = BuildNullValue();
+    }
+    PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
+    arguments->Add(push_type_arguments);
+    ReturnDefinition(
+        new CreateClosureInstr(node->function(), arguments, node->token_pos()));
   }
-  PushArgumentInstr* push_receiver = PushArgument(receiver);
-  ZoneGrowableArray<PushArgumentInstr*>* arguments =
-      new ZoneGrowableArray<PushArgumentInstr*>(2);
-  arguments->Add(push_receiver);
-  ASSERT(function.context_scope() != ContextScope::null());
-
-  // The function type of a closure may have type arguments. In that case, pass
-  // the type arguments of the instantiator. Otherwise, pass null object.
-  const Class& cls = Class::Handle(function.signature_class());
-  ASSERT(!cls.IsNull());
-  const bool requires_type_arguments = cls.HasTypeArguments();
-  Value* type_arguments = NULL;
-  if (requires_type_arguments) {
-    ASSERT(!function.IsImplicitStaticClosureFunction());
-    const Class& instantiator_class = Class::Handle(
-        owner()->parsed_function()->function().Owner());
-    type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
-                                                    instantiator_class,
-                                                    NULL);
-  } else {
-    type_arguments = BuildNullValue();
-  }
-  PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
-  arguments->Add(push_type_arguments);
-  ReturnDefinition(
-      new CreateClosureInstr(node->function(), arguments, node->token_pos()));
 }
 
 
 void EffectGraphVisitor::TranslateArgumentList(
     const ArgumentListNode& node,
     ZoneGrowableArray<Value*>* values) {
   for (intptr_t i = 0; i < node.length(); ++i) {
     ValueGraphVisitor for_argument(owner(), temp_index());
     node.NodeAt(i)->Visit(&for_argument);
     Append(for_argument);
@@ skipping 156 matching lines @@
     // The uninstantiated type arguments cannot be verified to be within their
     // bounds at compile time, so verify them at runtime.
     allocation = new AllocateObjectWithBoundsCheckInstr(node);
   } else {
     ZoneGrowableArray<PushArgumentInstr*>* allocate_arguments =
         new ZoneGrowableArray<PushArgumentInstr*>();
     if (requires_type_arguments) {
       BuildConstructorTypeArguments(node, allocate_arguments);
     }
 
-    allocation = new AllocateObjectInstr(node, allocate_arguments);
+    allocation = new AllocateObjectInstr(
+        node->token_pos(),
+        Class::ZoneHandle(node->constructor().Owner()),
+        allocate_arguments);
   }
   return Bind(allocation);
 }
 
 
 void EffectGraphVisitor::BuildConstructorCall(
     ConstructorCallNode* node,
     PushArgumentInstr* push_alloc_value) {
   Value* ctor_arg = Bind(
       new ConstantInstr(Smi::ZoneHandle(Smi::New(Function::kCtorPhaseAll))));
@@ skipping 1336 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