Make CTX allocatable by the register allocator.

runtime/vm/flow_graph_compiler_ia32.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/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 1056 matching lines @@
         // The noSuchMethod call may return to the caller, but not here.
       } else {
         __ Stop("Wrong number of arguments");
       }
       __ Bind(&correct_num_arguments);
     }
   } else if (!flow_graph().IsCompiledForOsr()) {
     CopyParameters();
   }
 
+  if (function.IsClosureFunction() && !flow_graph().IsCompiledForOsr()) {

[Vyacheslav Egorov (Google), 2014/10/28 13:44:58]

It seems closure calling sequence now has a redundant load then. We load it
twice - once in a caller and once in a callee.

Why load in the caller to begin with?

[Florian Schneider, 2014/10/28 19:04:31]

Done. This was only done for now to make inlining simpler. I removed the load
from the calling sequence and added the necessary context load in the inliner.

+    // Load context from the closure object (first argument).
+    LocalScope* scope = parsed_function().node_sequence()->scope();
+    LocalVariable* closure_parameter = scope->VariableAt(0);
+    __ movl(CTX, Address(EBP, closure_parameter->index() * kWordSize));
+    __ movl(CTX, FieldAddress(CTX, Closure::context_offset()));
+#ifdef dEBUG
+    Label ok;
+    __ LoadClassId(EBX, CTX);
+    __ cmpl(EBX, Immediate(kContextCid));
+    __ j(EQUAL, &ok, Assembler::kNearJump);
+    __ Stop("Incorrect context at entry");
+    __ Bind(&ok);
+#endif
+  }
+
   // In unoptimized code, initialize (non-argument) stack allocated slots to
   // null.
-  if (!is_optimizing() && (num_locals > 0)) {
+  if (!is_optimizing()) {
+    ASSERT(num_locals > 0);  // There is always at least context_var.
     __ Comment("Initialize spill slots");
     const intptr_t slot_base = parsed_function().first_stack_local_index();
+    const intptr_t context_index =
+        parsed_function().saved_current_context_var()->index();
     const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     __ movl(EAX, raw_null);
     for (intptr_t i = 0; i < num_locals; ++i) {
       // Subtract index i (locals lie at lower addresses than EBP).
-      __ movl(Address(EBP, (slot_base - i) * kWordSize), EAX);
+      if (((slot_base - i) == context_index)) {
+        if (function.IsClosureFunction()) {
+          __ movl(Address(EBP, (slot_base - i) * kWordSize), CTX);
+        } else {
+          const Immediate& raw_empty_context =
+              Immediate(reinterpret_cast<intptr_t>(
+                  isolate()->object_store()->empty_context()));
+          __ movl(Address(EBP, (slot_base - i) * kWordSize), raw_empty_context);
+        }
+      } else {
+        __ movl(Address(EBP, (slot_base - i) * kWordSize), EAX);
+      }
     }
   }
 
   ASSERT(!block_order().is_empty());
   VisitBlocks();
 
   __ int3();
   GenerateDeferredCode();
   // Emit function patching code. This will be swapped with the first 5 bytes
   // at entry point.
@@ skipping 670 matching lines @@
   __ movups(reg, Address(ESP, 0));
   __ addl(ESP, Immediate(kFpuRegisterSize));
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32