Make CTX allocatable by the register allocator.

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 "lib/invocation_mirror.h"
 #include "platform/utils.h"
 #include "vm/ast_transformer.h"
 #include "vm/bootstrap.h"
@@ skipping 109 matching lines @@
                               Symbols::ExprTemp(),
                               Type::ZoneHandle(Type::DynamicType()));
     ASSERT(temp != NULL);
     set_expression_temp_var(temp);
   }
   ASSERT(has_expression_temp_var());
   return expression_temp_var();
 }
 
 
+LocalVariable* ParsedFunction::EnsureSavedCurrentContext() {

[hausner, 2014/10/29 16:44:34]

Now that every function has a local variable to store the current context, the
variable can be set up proactively in the ParsedFunction constructor, rather
than calling this function from the parser constructor.

[Florian Schneider, 2014/10/29 17:50:45]

Done. Yes, I can now remove this function.

+  if (!has_current_context_var()) {
+    LocalVariable* temp = new(I) LocalVariable(
+        function().token_pos(),
+        Symbols::CurrentContextVar(),
+        Type::ZoneHandle(I, Type::DynamicType()));
+    ASSERT(temp != NULL);
+    set_current_context_var(temp);
+  }
+  return current_context_var();
+}
+
+
 void ParsedFunction::EnsureFinallyReturnTemp() {
   if (!has_finally_return_temp_var()) {
     LocalVariable* temp = new(I) LocalVariable(
         function_.token_pos(),
         String::ZoneHandle(I, Symbols::New(":finally_ret_val")),
         Type::ZoneHandle(I, Type::DynamicType()));
     ASSERT(temp != NULL);
     temp->set_is_final();
     set_finally_return_temp_var(temp);
   }
@@ skipping 198 matching lines @@
           parsed_function->function().origin()).library())),
       try_blocks_list_(NULL),
       last_used_try_index_(0),
       unregister_pending_function_(false),
       async_temp_scope_(NULL) {
   ASSERT(tokens_iterator_.IsValid());
   ASSERT(!current_function().IsNull());
   if (FLAG_enable_type_checks) {
     EnsureExpressionTemp();
   }
+  EnsureSavedCurrentContext();
 }
 
 
 Parser::~Parser() {
   if (unregister_pending_function_) {
     const GrowableObjectArray& pending_functions =
         GrowableObjectArray::Handle(I->object_store()->pending_functions());
     ASSERT(pending_functions.Length() > 0);
     ASSERT(pending_functions.At(pending_functions.Length()-1) ==
         current_function().raw());
@@ skipping 499 matching lines @@
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(func.end_token_pos()));
   }
   if (parsed_function->has_expression_temp_var()) {
     node_sequence->scope()->AddVariable(parsed_function->expression_temp_var());
   }
-  if (parsed_function->has_saved_current_context_var()) {
+  if (parsed_function->has_current_context_var()) {

[hausner, 2014/10/29 16:44:34]

This is always true now, correct? 

[Florian Schneider, 2014/10/29 17:50:45]

Done.

     node_sequence->scope()->AddVariable(
-        parsed_function->saved_current_context_var());
+        parsed_function->current_context_var());
   }
   if (parsed_function->has_finally_return_temp_var()) {
     node_sequence->scope()->AddVariable(
         parsed_function->finally_return_temp_var());
   }
   parsed_function->SetNodeSequence(node_sequence);
 
   // The instantiator may be required at run time for generic type checks or
   // allocation of generic types.
   if (parser.IsInstantiatorRequired()) {
@@ skipping 181 matching lines @@
   ParsedFunction* parsed_function = new ParsedFunction(isolate, initializer);
   Parser parser(script, parsed_function, field.token_pos());
 
   SequenceNode* body = parser.ParseStaticInitializer();
   parsed_function->SetNodeSequence(body);
   parsed_function->set_default_parameter_values(Object::null_array());
 
   if (parsed_function->has_expression_temp_var()) {
     body->scope()->AddVariable(parsed_function->expression_temp_var());
   }
-  if (parsed_function->has_saved_current_context_var()) {
-    body->scope()->AddVariable(parsed_function->saved_current_context_var());
+  if (parsed_function->has_current_context_var()) {

[hausner, 2014/10/29 16:44:34]

ditto

[Florian Schneider, 2014/10/29 17:50:45]

Done.

+    body->scope()->AddVariable(parsed_function->current_context_var());
   }
   if (parsed_function->has_finally_return_temp_var()) {
     body->scope()->AddVariable(parsed_function->finally_return_temp_var());
   }
   // The instantiator is not required in a static expression.
   ASSERT(!parser.IsInstantiatorRequired());
 
   return parsed_function;
 }
 
@@ skipping 297 matching lines @@
     args->Add(new(I) LoadLocalNode(token_pos, scope->VariableAt(i)));
     intptr_t index = i - desc.PositionalCount();
     names.SetAt(index, String::Handle(I, desc.NameAt(index)));
   }
   args->set_names(names);
 
   const Class& owner = Class::Handle(I, func.Owner());
   ASSERT(!owner.IsNull());
   AstNode* result = NULL;
   if (owner.IsSignatureClass() && name.Equals(Symbols::Call())) {
-    EnsureSavedCurrentContext();
     result = new ClosureCallNode(token_pos, getter_call, args);
   } else {
     result = BuildClosureCall(token_pos, getter_call, args);
   }
 
   ReturnNode* return_node = new ReturnNode(token_pos, result);
   current_block_->statements->Add(return_node);
   return CloseBlock();
 }
 
@@ skipping 7288 matching lines @@
 }
 
 
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
   parsed_function()->EnsureExpressionTemp();
 }
 
 
 void Parser::EnsureSavedCurrentContext() {
-  // Used later by the flow_graph_builder to save current context.
-  if (!parsed_function()->has_saved_current_context_var()) {
-    LocalVariable* temp = new(I) LocalVariable(
-        current_function().token_pos(),
-        Symbols::SavedCurrentContextVar(),
-        Type::ZoneHandle(I, Type::DynamicType()));
-    ASSERT(temp != NULL);
-    parsed_function()->set_saved_current_context_var(temp);
-  }
+  parsed_function()->EnsureSavedCurrentContext();
 }
 
 
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_pos,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%" Pd, s, token_pos);
   LocalVariable* temp = new(I) LocalVariable(
       token_pos,
       String::ZoneHandle(I, Symbols::New(name)),
@@ skipping 3228 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart