Enable allocation sinking for closures.

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, 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_inliner.h"
 
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 663 matching lines @@
         callee_graph->graph_entry()->normal_entry();
     ClosureCallInstr* closure_call = call_data->call->AsClosureCall();
     if (closure_call != NULL) {
       // TODO(fschneider): Avoid setting the context, if not needed.
       Definition* closure =
           closure_call->PushArgumentAt(0)->value()->definition();
       LoadFieldInstr* context =
           new LoadFieldInstr(new Value(closure),
                              Closure::context_offset(),
                              Type::ZoneHandle());
+      AllocateObjectInstr* alloc =
+          closure_call->ArgumentAt(0)->AsAllocateObject();
+      if ((alloc != NULL) && !alloc->closure_function().IsNull()) {
+        ASSERT(!alloc->context_field().IsNull());
+        context->set_field(&alloc->context_field());
+      }
+
       context->set_ssa_temp_index(caller_graph()->alloc_ssa_temp_index());
       context->InsertAfter(callee_entry);
       StoreContextInstr* set_context =
           new StoreContextInstr(new Value(context));
       set_context->InsertAfter(context);
     }
 
     // Plug result in the caller graph.
     InlineExitCollector* exit_collector = call_data->exit_collector;
     exit_collector->PrepareGraphs(callee_graph);
@@ skipping 102 matching lines @@
   }
 
   void InlineClosureCalls() {
     const GrowableArray<ClosureCallInstr*>& calls =
         inlining_call_sites_->closure_calls();
     TRACE_INLINING(OS::Print("  Closure Calls (%d)\n", calls.length()));
     for (intptr_t i = 0; i < calls.length(); ++i) {
       ClosureCallInstr* call = calls[i];
       // Find the closure of the callee.
       ASSERT(call->ArgumentCount() > 0);
-      const CreateClosureInstr* closure =
+      Function& target = Function::ZoneHandle();
+      CreateClosureInstr* closure =
           call->ArgumentAt(0)->AsCreateClosure();
-      if (closure == NULL) {
+      if (closure != NULL) {
+        target ^= closure->function().raw();
+      }
+      AllocateObjectInstr* alloc =
+          call->ArgumentAt(0)->AsAllocateObject();
+      if ((alloc != NULL) && !alloc->closure_function().IsNull()) {
+        target ^= alloc->closure_function().raw();
+        ASSERT(target.signature_class() == alloc->cls().raw());
+      }
+      if (target.IsNull()) {
         TRACE_INLINING(OS::Print("     Bailout: non-closure operator\n"));
         continue;
       }
       GrowableArray<Value*> arguments(call->ArgumentCount());
       for (int i = 0; i < call->ArgumentCount(); ++i) {
         arguments.Add(call->PushArgumentAt(i)->value());
       }
       InlinedCallData call_data(call, &arguments);
-      if (TryInlining(closure->function(),
+      if (TryInlining(target,
                       call->argument_names(),
                       &call_data)) {
         InlineCall(&call_data);
       }
     }
   }
 
   void InlineInstanceCalls() {
     const GrowableArray<CallSites::InstanceCallInfo>& call_info =
         inlining_call_sites_->instance_calls();
@@ skipping 345 matching lines @@
       // Handle the two possible cases (unshared and shared subsequent
       // predecessors) separately.
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       if (callee_entry->IsGraphEntry()) {
         // Unshared.  Graft the normal entry on after the check class
         // instruction.
         TargetEntryInstr* target =
             callee_entry->AsGraphEntry()->normal_entry();
         cursor->LinkTo(target->next());
         target->ReplaceAsPredecessorWith(current_block);
+
+        // Unuse the graph entry. It is not in the graph anymore.
+        callee_entry->UnuseAllInputs();
+
         // All blocks that were dominated by the normal entry are now
         // dominated by the current block.
         for (intptr_t j = 0;
              j < target->dominated_blocks().length();
              ++j) {
           BlockEntryInstr* block = target->dominated_blocks()[j];
           current_block->AddDominatedBlock(block);
         }
       } else if (callee_entry->IsJoinEntry()) {
         // Shared inlined body and this is a subsequent entry.  We have
@@ skipping 30 matching lines @@
       cursor = NULL;
 
       // 2. Handle a match by linking to the inlined body.  There are three
       // cases (unshared, shared first predecessor, and shared subsequent
       // predecessors).
       BlockEntryInstr* callee_entry = inlined_entries_[i];
       TargetEntryInstr* true_target = NULL;
       if (callee_entry->IsGraphEntry()) {
         // Unshared.
         true_target = callee_entry->AsGraphEntry()->normal_entry();
+
+        // Unuse the graph entry. It is not in the graph anymore.
+        callee_entry->UnuseAllInputs();
+
       } else if (callee_entry->IsTargetEntry()) {
         // Shared inlined body and this is the first entry.  We have already
         // constructed a join and this target jumps to it.
         true_target = callee_entry->AsTargetEntry();
         BlockEntryInstr* join =
             true_target->last_instruction()->SuccessorAt(0);
         current_block->AddDominatedBlock(join);
       } else {
         // Shared inlined body and this is a subsequent entry.  We have
         // already constructed a join.  We need a fresh target that jumps to
@@ skipping 158 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart