Add contexts.

runtime/vm/flow_graph_compiler_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 174 matching lines @@
                PcDescriptors::kFuncCall);
   __ addq(RSP, Immediate(argument_count * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitCurrentContext(CurrentContextComp* comp) {
   __ movq(RAX, CTX);
 }
 
 
+void FlowGraphCompiler::VisitStoreContext(StoreContextComp* comp) {
+  LoadValue(RAX, comp->value());
+  __ movq(CTX, RAX);

[regis, 2012/03/23 20:50:25]

Why not load directly into CTX?

[srdjan, 2012/03/23 21:22:19]

Done.

+}
+
+
 void FlowGraphCompiler::VisitClosureCall(ClosureCallComp* comp) {
   ASSERT(comp->context()->IsTemp());
   ASSERT(VerifyCallComputation(comp));
   // The arguments to the stub include the closure.  The arguments
   // descriptor describes the closure's arguments (and so does not include
   // the closure).
   int argument_count = comp->ArgumentCount();
   const Array& arguments_descriptor =
       CodeGenerator::ArgumentsDescriptor(argument_count - 1,
                                          comp->argument_names());
@@ skipping 42 matching lines @@
   ASSERT(VerifyCallComputation(comp));
   EmitStaticCall(comp->token_index(),
                  comp->function(),
                  comp->ArgumentCount(),
                  comp->argument_names());
 }
 
 
 void FlowGraphCompiler::VisitLoadLocal(LoadLocalComp* comp) {
   if (comp->local().is_captured()) {
-    Bailout("load of context variable");
+    // The variable lives in the context.
+    intptr_t delta = comp->context_level() -
+                     comp->local().owner()->context_level();
+    ASSERT(delta >= 0);
+    Register base = CTX;
+    while (delta-- > 0) {
+      __ movq(RAX, FieldAddress(base, Context::parent_offset()));
+      base = RAX;
+    }
+    __ movq(RAX,
+            FieldAddress(base,
+                         Context::variable_offset(comp->local().index())));
+  } else {
+    // The variable lives in the current stack frame.
+    __ movq(RAX, Address(RBP, comp->local().index() * kWordSize));
   }
-  __ movq(RAX, Address(RBP, comp->local().index() * kWordSize));
 }
 
 
 void FlowGraphCompiler::VisitStoreLocal(StoreLocalComp* comp) {
+  LoadValue(RAX, comp->value());
   if (comp->local().is_captured()) {
-    Bailout("store to context variable");
+    // The variable lives in the context.
+    Register scratch = R10;
+    intptr_t delta = comp->context_level() -
+                     comp->local().owner()->context_level();
+    ASSERT(delta >= 0);
+    Register base = CTX;
+    while (delta-- > 0) {
+      __ movq(scratch, FieldAddress(base, Context::parent_offset()));
+      base = scratch;
+    }
+    __ StoreIntoObject(
+        base,
+        FieldAddress(base, Context::variable_offset(comp->local().index())),
+        RAX);
+  } else {
+    // The variable lives in the current stack frame.
+    __ movq(Address(RBP, comp->local().index() * kWordSize), RAX);
   }
-  LoadValue(RAX, comp->value());
-  __ movq(Address(RBP, comp->local().index() * kWordSize), RAX);
 }
 
 
 void FlowGraphCompiler::VisitNativeCall(NativeCallComp* comp) {
   // Push the result place holder initialized to NULL.
   __ PushObject(Object::ZoneHandle());
   // Pass a pointer to the first argument in RAX.
   if (!comp->has_optional_parameters()) {
     __ leaq(RAX, Address(RBP, (1 + comp->argument_count()) * kWordSize));
   } else {
@@ skipping 465 matching lines @@
     // instantiated type arguments, reset instantiator to null.
     __ movq(RAX, raw_null);  // Null instantiator.
     __ Bind(&use_instantiator);  // Use instantiator in RAX.
   }
   // In the non-factory case, we rely on the allocation stub to
   // instantiate the type arguments.
   // RAX: instantiator or null.
 }
 
 
+void FlowGraphCompiler::VisitAllocateContext(AllocateContextComp* comp) {
+  __ movq(R10, Immediate(comp->num_context_variables()));
+  const ExternalLabel label("alloc_context",
+                            StubCode::AllocateContextEntryPoint());
+  GenerateCall(comp->token_index(), &label, PcDescriptors::kOther);
+}
+
+
+void FlowGraphCompiler::VisitChainContext(ChainContextComp* comp) {
+  __ popq(RAX);
+  // Chain the new context in RAX to its parent in CTX.
+  __ StoreIntoObject(RAX,
+                     FieldAddress(RAX, Context::parent_offset()),
+                     CTX);
+  // Set new context as current context.
+  __ movq(CTX, RAX);
+}
+
+
 void FlowGraphCompiler::VisitBlocks() {
   for (intptr_t i = 0; i < block_order_.length(); ++i) {
     // Compile the block entry.
     current_block_ = block_order_[i];
     Instruction* instr = current_block()->Accept(this);
     // Compile all successors until an exit, branch, or a block entry.
     while ((instr != NULL) && !instr->IsBlockEntry()) {
       instr = instr->Accept(this);
     }
 
@@ skipping 454 matching lines @@
 void FlowGraphCompiler::FinalizeExceptionHandlers(const Code& code) {
   // We don't compile exception handlers yet.
   code.set_exception_handlers(
       ExceptionHandlers::Handle(ExceptionHandlers::New(0)));
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64