Fix for issues 6080 - pass in the Isolate's top context into the stub for invoking dart code from n…

runtime/vm/parser.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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 162 matching lines @@
   // Allocate parameters and local variables, either in the local frame or
   // in the context(s).
   LocalScope* context_owner = NULL;  // No context needed yet.
   int next_free_frame_index =
       scope->AllocateVariables(first_parameter_index_,
                                num_params,
                                first_stack_local_index_,
                                scope,
                                &context_owner);
 
+  // Allocate a local variable to save the current context when we call into

[hausner, 2013/02/07 17:00:45]

Can we allocate this variable only when really needed? That would save a stack
slot in almost all activation frames, and one VarDescriptor entry in pretty much
every function object.

[siva, 2013/02/07 22:08:31]

Changed this to allocate only when needed following the expression temp model.

PTAL.

On 2013/02/07 17:00:45, hausner wrote:

+  // any closure function as the call will destroy the current context.
+  LocalVariable* context_var =
+      new LocalVariable(function().token_pos(),
+                        Symbols::SavedCurrentContextVar(),
+                        Type::ZoneHandle(Type::DynamicType()));
+  context_var->set_index(next_free_frame_index--);
+  scope->AddVariable(context_var);
+  set_saved_current_context_var(context_var);
+
   // If this function allocates context variables, but none of its enclosing
   // functions do, the context on entry is not linked as parent of the allocated
   // context but saved on entry and restored on exit as to prevent memory leaks.
   // Add and allocate a local variable to this purpose.
   if (context_owner != NULL) {
     const ContextScope& context_scope =
         ContextScope::Handle(function().context_scope());
     if (context_scope.IsNull() || (context_scope.num_variables() == 0)) {
       LocalVariable* context_var =
           new LocalVariable(function().token_pos(),
@@ skipping 5738 matching lines @@
     ASSERT(node->IsJumpNode());
     node->AsJumpNode()->AddInlinedFinallyNode(finally_node);
   }
 }
 
 
 AstNode* Parser::ParseTryStatement(String* label_name) {
   TRACE_PARSER("ParseTryStatement");
 
   // We create three stack slots for exceptions here:
-  // ':saved_context_var' - Used to save the context before start of the try
-  //                        block. The context register is restored from this
-  //                        slot before processing the catch block handler.
+  // ':saved_try_context_var' - Used to save the context before start of the try
+  //                            block. The context register is restored from
+  //                            this slot before processing the catch block
+  //                            handler.
   // ':exception_var' - Used to save the current exception object that was
   //                    thrown.
   // ':stacktrace_var' - Used to save the current stack trace object into which
   //                     the stack trace was copied into when an exception was
   //                     thrown.
   // :exception_var and :stacktrace_var get set with the exception object
   // and the stacktrace object when an exception is thrown.
   // These three implicit variables can never be captured variables.
   LocalVariable* context_var =
-      current_block_->scope->LocalLookupVariable(Symbols::SavedContextVar());
+      current_block_->scope->LocalLookupVariable(Symbols::SavedTryContextVar());
   if (context_var == NULL) {
     context_var = new LocalVariable(TokenPos(),
-                                    Symbols::SavedContextVar(),
+                                    Symbols::SavedTryContextVar(),
                                     Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(context_var);
   }
   LocalVariable* catch_excp_var =
       current_block_->scope->LocalLookupVariable(Symbols::ExceptionVar());
   if (catch_excp_var == NULL) {
     catch_excp_var = new LocalVariable(TokenPos(),
                                        Symbols::ExceptionVar(),
                                        Type::ZoneHandle(Type::DynamicType()));
     current_block_->scope->AddVariable(catch_excp_var);
@@ skipping 3792 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart