Add contexts.

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 "vm/ast_printer.h"
 #include "vm/flags.h"
 #include "vm/intermediate_language.h"
 #include "vm/longjump.h"
@@ skipping 148 matching lines @@
       const AbstractType& type =
           AbstractType::ZoneHandle(
               owner()->parsed_function().function().result_type());
       AssertAssignableComp* assert =
           new AssertAssignableComp(return_value, type);
       AddInstruction(new BindInstr(temp_index(), assert));
       return_value = new TempVal(temp_index());
     }
   }
 
+  intptr_t current_context_level = owner()->context_level();
+  ASSERT(current_context_level >= 0);
+  if (owner()->parsed_function().saved_context_var() != NULL) {
+    // CTX on entry was saved, but not linked as context parent.
+    LoadLocalComp* load_comp =
+        new LoadLocalComp(*owner()->parsed_function().saved_context_var(), 0);
+    AddInstruction(new BindInstr(temp_index(), load_comp));
+    TempVal* local_value = new TempVal(temp_index());
+    StoreContextComp* store_context = new StoreContextComp(local_value);
+    AddInstruction(new DoInstr(store_context));
+  } else {
+    while (current_context_level-- > 0) {
+      UnchainContext();
+    }
+  }
+
+
   AddInstruction(new ReturnInstr(return_value, node->token_index()));
   CloseFragment();
 }
 
 
 // <Expression> ::= Literal { literal: Instance }
 void EffectGraphVisitor::VisitLiteralNode(LiteralNode* node) {
   return;
 }
 
@@ skipping 201 matching lines @@
   ReturnComputation(call);
 }
 
 
 void EffectGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   // In an effect context, treat postincrement as if it were preincrement
   // because its value is not needed.
 
   // 1. Load the value.
-  LoadLocalComp* load = new LoadLocalComp(node->local());
+  LoadLocalComp* load = new LoadLocalComp(node->local(),
+                                          owner()->context_level());
   AddInstruction(new BindInstr(temp_index(), load));
   // 2. Increment.
   BuildIncrOpIncrement(node->kind(), node->id(), node->token_index(),
                        temp_index() + 1);
   // 3. Perform the store, resulting in the new value.
-  StoreLocalComp* store =
-      new StoreLocalComp(node->local(), new TempVal(temp_index()));
+  StoreLocalComp* store = new StoreLocalComp(
+      node->local(), new TempVal(temp_index()), owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void ValueGraphVisitor::VisitIncrOpLocalNode(IncrOpLocalNode* node) {
   ASSERT((node->kind() == Token::kINCR) || (node->kind() == Token::kDECR));
   if (node->prefix()) {
     // Base class handles preincrement.
     EffectGraphVisitor::VisitIncrOpLocalNode(node);
     return;
   }
   // For postincrement, duplicate the original value to use one copy as the
   // result.
   //
   // 1. Load the value.
-  LoadLocalComp* load = new LoadLocalComp(node->local());
+  LoadLocalComp* load = new LoadLocalComp(node->local(),
+                                          owner()->context_level());
   AddInstruction(new BindInstr(temp_index(), load));
   // 2. Duplicate it to increment.
   AddInstruction(new PickTempInstr(temp_index() + 1, temp_index()));
   // 3. Increment.
   BuildIncrOpIncrement(node->kind(), node->id(), node->token_index(),
                        temp_index() + 2);
   // 4. Perform the store and return the original value.
-  StoreLocalComp* store =
-      new StoreLocalComp(node->local(), new TempVal(temp_index() + 1));
+  StoreLocalComp* store = new StoreLocalComp(
+      node->local(), new TempVal(temp_index() + 1), owner()->context_level());
   AddInstruction(new DoInstr(store));
   ReturnValue(new TempVal(AllocateTempIndex()));
 }
 
 
 int EffectGraphVisitor::BuildIncrOpFieldLoad(IncrOpInstanceFieldNode* node,
                                              intptr_t start_index) {
   // Evaluate the receiver and duplicate it (it has two uses).
   //   t_n   <- ... receiver ...
   //   t_n+1 <- Pick(t_n)
@@ skipping 360 matching lines @@
   CreateArrayComp* create = new CreateArrayComp(node, values);
   ReturnComputation(create);
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   int next_index = temp_index();
   if (function.IsNonImplicitClosureFunction()) {
-    const int context_level = 0;  // Only because we don't handle nesting yet.
     const ContextScope& context_scope = ContextScope::ZoneHandle(
-        node->scope()->PreserveOuterScope(context_level));
+        node->scope()->PreserveOuterScope(owner()->context_level()));
     ASSERT(!function.HasCode());
     ASSERT(function.context_scope() == ContextScope::null());
     function.set_context_scope(context_scope);
   } else if (function.IsImplicitInstanceClosureFunction()) {
     ValueGraphVisitor for_receiver(owner(), temp_index());
     node->receiver()->Visit(&for_receiver);
     Append(for_receiver);
     if (!for_receiver.value()->IsTemp()) {
       AddInstruction(new BindInstr(temp_index(), for_receiver.value()));
     }
@@ skipping 333 matching lines @@
 void EffectGraphVisitor::VisitPrimaryNode(PrimaryNode* node) {
   Bailout("EffectGraphVisitor::VisitPrimaryNode");
 }
 
 
 // <Expression> ::= LoadLocal { local: LocalVariable }
 void EffectGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   return;
 }
 
+
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
-  LoadLocalComp* load = new LoadLocalComp(node->local());
+  LoadLocalComp* load = new LoadLocalComp(node->local(),
+                                          owner()->context_level());
   ReturnComputation(load);
 }
 
+
 void TestGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
-  LoadLocalComp* load = new LoadLocalComp(node->local());
+  LoadLocalComp* load = new LoadLocalComp(node->local(),
+                                          owner()->context_level());
   ReturnComputation(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   Value* value = for_value.value();
   if (FLAG_enable_type_checks) {
     AssertAssignableComp* assert =
         new AssertAssignableComp(value, node->local().type());
     AddInstruction(new BindInstr(temp_index(), assert));
     value = new TempVal(temp_index());
   }
 
-  StoreLocalComp* store = new StoreLocalComp(node->local(), value);
+  StoreLocalComp* store =
+      new StoreLocalComp(node->local(), value, owner()->context_level());
   ReturnComputation(store);
 }
 
 
 void EffectGraphVisitor::VisitLoadInstanceFieldNode(
     LoadInstanceFieldNode* node) {
   ValueGraphVisitor for_instance(owner(), temp_index());
   node->instance()->Visit(&for_instance);
   Append(for_instance);
   LoadInstanceFieldComp* load =
@@ skipping 77 matching lines @@
   Append(for_value);
   StoreIndexedComp* store = new StoreIndexedComp(node->id(),
                                                  node->token_index(),
                                                  for_array.value(),
                                                  for_index.value(),
                                                  for_value.value());
   ReturnComputation(store);
 }
 
 
+bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
+  return (node == owner()->parsed_function().node_sequence()) &&
+         (owner()->parsed_function().saved_context_var() != NULL);
+}
+
+
+void EffectGraphVisitor::UnchainContext() {
+  AddInstruction(new BindInstr(temp_index(), new CurrentContextComp()));
+  TempVal* temp_ctx = new TempVal(temp_index());
+  NativeLoadFieldComp* load = new NativeLoadFieldComp(
+      temp_ctx, Context::parent_offset());
+  AddInstruction(new BindInstr(temp_index(), load));
+  TempVal* parent_ctx = new TempVal(temp_index());
+  AddInstruction(new DoInstr(new StoreContextComp(parent_ctx)));
+}
+
+
 // <Statement> ::= Sequence { scope: LocalScope
 //                            nodes: <Statement>*
 //                            label: SourceLabel }
 void EffectGraphVisitor::VisitSequenceNode(SequenceNode* node) {
   LocalScope* scope = node->scope();
   const intptr_t num_context_variables =
       (scope != NULL) ? scope->num_context_variables() : 0;
   int previous_context_level = owner()->context_level();
   if (num_context_variables > 0) {
     // The loop local scope declares variables that are captured.
     // Allocate and chain a new context.
-    // Allocate context computation.
-    // Chain Context computation (maybe introduce a new variable).
-    Bailout("Sequence needs a context.  Gotta have a context.");
+    // Allocate context computation (uses current CTX)
+    AllocateContextComp* comp = new AllocateContextComp(node->token_index(),
+                                                        num_context_variables);
+    AddInstruction(new BindInstr(temp_index(), comp));
+    Value* allocated_context_value = new TempVal(temp_index());
+
+    // If this node_sequence is the body of the function being compiled, and if
+    // this function is not a closure, do not link the current context as the
+    // parent of the newly allocated context, as it is not accessible. Instead,
+    // save it in a pre-allocated variable and restore it on exit.
+    if (MustSaveRestoreContext(node)) {
+      AddInstruction(new BindInstr(temp_index() + 1, new CurrentContextComp()));
+      StoreLocalComp* store_local = new StoreLocalComp(
+          *owner()->parsed_function().saved_context_var(),
+          new TempVal(temp_index() + 1),
+          0);
+      AddInstruction(new DoInstr(store_local));
+      StoreContextComp* store_context =
+          new StoreContextComp(new ConstantVal(Object::ZoneHandle()));
+      AddInstruction(new DoInstr(store_context));
+    }
+
+    ChainContextComp* chain_context = new ChainContextComp(
+        allocated_context_value);
+    AddInstruction(new DoInstr(chain_context));
+    owner()->set_context_level(scope->context_level());
+
+    // If this node_sequence is the body of the function being compiled, copy
+    // the captured parameters from the frame into the context.
+    if (node == owner()->parsed_function().node_sequence()) {
+      ASSERT(scope->context_level() == 1);
+      const Immediate raw_null =
+          Immediate(reinterpret_cast<intptr_t>(Object::null()));
+      const Function& function = owner()->parsed_function().function();
+      const int num_params = function.NumberOfParameters();
+      int param_frame_index =
+          (num_params == function.num_fixed_parameters()) ? 1 + num_params : -1;
+      for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
+        const LocalVariable& parameter = *scope->VariableAt(pos);
+        ASSERT(parameter.owner() == scope);
+        if (parameter.is_captured()) {
+          // Create a temporary local describing the original position.
+          const String& temp_name = String::ZoneHandle(String::Concat(
+              parameter.name(), String::Handle(String::NewSymbol("-orig"))));
+          LocalVariable* temp_local = new LocalVariable(
+              0,  // Token index.
+              temp_name,
+              Type::ZoneHandle(Type::DynamicType()));  // Type.
+          temp_local->set_index(param_frame_index);
+
+          // Copy parameter from local frame to current context.
+          LoadLocalComp* load_comp = new LoadLocalComp(
+              *temp_local, owner()->context_level());
+          AddInstruction(new BindInstr(temp_index(), load_comp));
+          StoreLocalComp* store_local = new StoreLocalComp(
+              parameter,
+              new TempVal(temp_index()),
+              owner()->context_level());
+          AddInstruction(new DoInstr(store_local));
+          // Write NULL to the source location to detect buggy accesses and
+          // allow GC of passed value if it gets overwritten by a new value in
+          // the function.
+          StoreLocalComp* clear_local = new StoreLocalComp(
+              *temp_local,
+              new ConstantVal(Object::ZoneHandle()),
+              owner()->context_level());
+          AddInstruction(new DoInstr(clear_local));
+        }
+      }
+    }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function().node_sequence())) {
     Bailout("VisitSequenceNode GenerateArgumentTypeChecks()");
   }
 
   intptr_t i = 0;
   while (is_open() && (i < node->length())) {
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->NodeAt(i++)->Visit(&for_effect);
     Append(for_effect);
   }
+
+  if (is_open()) {
+    if (MustSaveRestoreContext(node)) {
+      ASSERT(num_context_variables > 0);
+      LoadLocalComp* load_comp =
+          new LoadLocalComp(*owner()->parsed_function().saved_context_var(), 0);
+      AddInstruction(new BindInstr(temp_index(), load_comp));
+      TempVal* local_value = new TempVal(temp_index());
+      StoreContextComp* store_context = new StoreContextComp(local_value);
+      AddInstruction(new DoInstr(store_context));
+    } else if (num_context_variables > 0) {
+      UnchainContext();
+    }
+  }
+
+  // If this node sequence is labeled, a break out of the sequence will have
+  // taken care of unchaining the context.
+  if (node->label() != NULL) {
+    // TODO(srdjan): Check that the break label is bound? Is this a jump?
+    Bailout("VisitSequenceNode bind break and unchain CTX");
+  }
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   Bailout("EffectGraphVisitor::VisitCatchClauseNode");
 }
 
 
 void EffectGraphVisitor::VisitTryCatchNode(TryCatchNode* node) {
@@ skipping 147 matching lines @@
             String::Handle(comp->function().name()).ToCString());
   for (intptr_t i = 0; i < comp->ArgumentCount(); ++i) {
     OS::Print(", ");
     comp->ArgumentAt(i)->Accept(this);
   }
   OS::Print(")");
 }
 
 
 void FlowGraphPrinter::VisitLoadLocal(LoadLocalComp* comp) {
-  OS::Print("LoadLocal(%s)", comp->local().name().ToCString());
+  OS::Print("LoadLocal(%s lvl:%d)",
+      comp->local().name().ToCString(), comp->context_level());
 }
 
 
 void FlowGraphPrinter::VisitStoreLocal(StoreLocalComp* comp) {
   OS::Print("StoreLocal(%s, ", comp->local().name().ToCString());
   comp->value()->Accept(this);
-  OS::Print(")");
+  OS::Print(", lvl: %d)", comp->context_level());
 }
 
 
 void FlowGraphPrinter::VisitNativeCall(NativeCallComp* comp) {
   OS::Print("NativeCall(%s)", comp->native_name().ToCString());
 }
 
 
 void FlowGraphPrinter::VisitLoadInstanceField(LoadInstanceFieldComp* comp) {
   OS::Print("LoadInstanceField(%s, ",
@@ skipping 120 matching lines @@
 void FlowGraphPrinter::VisitExtractConstructorInstantiator(
     ExtractConstructorInstantiatorComp* comp) {
   OS::Print("ExtractConstructorInstantiator(");
   comp->instantiator()->Accept(this);
   OS::Print(", ");
   comp->discard_value()->Accept(this);
   OS::Print(")");
 }
 
 
+void FlowGraphPrinter::VisitAllocateContext(AllocateContextComp* comp) {
+  OS::Print("AllocateContext(%d)", comp->num_context_variables());
+}
+
+
+void FlowGraphPrinter::VisitChainContext(ChainContextComp* comp) {
+  OS::Print("ChainContext(");
+  comp->context_value()->Accept(this);
+  OS::Print(")");
+}
+
+
+void FlowGraphPrinter::VisitStoreContext(StoreContextComp* comp) {
+  OS::Print("StoreContext(");
+  comp->value()->Accept(this);
+  OS::Print(")");
+}
+
+
 void FlowGraphPrinter::VisitJoinEntry(JoinEntryInstr* instr) {
   OS::Print("%2d: [join]", reverse_index(instr->postorder_number()));
 }
 
 
 void FlowGraphPrinter::VisitTargetEntry(TargetEntryInstr* instr) {
   OS::Print("%2d: [target]", reverse_index(instr->postorder_number()));
 }
 
 
@@ skipping 177 matching lines @@
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(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