Step toward eliminating increment nodes, starting with increment local. Fix a bug in evaluating sid…

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 221 matching lines @@
     : script_(script),
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(Function::Handle()),
       current_class_(Class::Handle()),
       library_(library),
-      try_blocks_list_(NULL) {
+      try_blocks_list_(NULL),
+      increment_temp_(NULL) {
   ASSERT(!tokens_.IsNull());
   ASSERT(!library.IsNull());
   SetPosition(0);
 }
 
 
 Parser::Parser(const Script& script,
                const Function& function,
                intptr_t token_index)
     : script_(script),
       tokens_(TokenStream::Handle(script.tokens())),
       token_index_(0),
       current_block_(NULL),
       is_top_level_(false),
       current_member_(NULL),
       allow_function_literals_(true),
       current_function_(function),
       current_class_(Class::Handle(current_function_.owner())),
       library_(Library::Handle(current_class_.library())),
-      try_blocks_list_(NULL) {
+      try_blocks_list_(NULL),
+      increment_temp_(NULL)  {
   ASSERT(!tokens_.IsNull());
   ASSERT(!function.IsNull());
   SetPosition(token_index);
 }
 
 
 bool Parser::SetAllowFunctionLiterals(bool value) {
   bool current_value = allow_function_literals_;
   allow_function_literals_ = value;
   return current_value;
@@ skipping 367 matching lines @@
     return seq->NodeAt(seq->length() - 1)->IsReturnNode();
   }
 }
 
 
 void Parser::ParseFunction(ParsedFunction* parsed_function) {
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::parser_timer);
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->long_jump_base()->IsSafeToJump());
   // Compilation can be nested, preserve the ast node id.
-  const int prev_ast_node_id = isolate->ast_node_id();
+  const intptr_t prev_ast_node_id = isolate->ast_node_id();
   isolate->set_ast_node_id(0);
   ASSERT(parsed_function != NULL);
   const Function& func = parsed_function->function();
   const Class& cls = Class::Handle(isolate, func.owner());
   const Script& script = Script::Handle(isolate, cls.script());
   Parser parser(script, func, func.token_index());
   SequenceNode* node_sequence = NULL;
   Array& default_parameter_values = Array::Handle(isolate, Array::null());
   switch (func.kind()) {
     case RawFunction::kFunction:
@@ skipping 15 matching lines @@
       node_sequence = parser.ParseStaticConstGetter(func);
       break;
     default:
       UNREACHABLE();
   }
 
   if (!HasReturnNode(node_sequence)) {
     // Add implicit return node.
     node_sequence->Add(new ReturnNode(parser.token_index_));
   }
+  if (parser.increment_temp_ != NULL) {
+    node_sequence->scope()->AddVariable(parser.increment_temp_);
+  }
   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()) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
     const bool kTestOnly = true;
     LocalVariable* receiver =
         parser.LookupReceiver(node_sequence->scope(),
@@ skipping 512 matching lines @@
 
   ArgumentListNode* arguments = new ArgumentListNode(supercall_pos);
   // 'this' parameter is the first argument to super call.
   AstNode* receiver = LoadReceiver(supercall_pos);
   arguments->Add(receiver);
   ParseActualParameters(arguments, kAllowConst);
   return new StaticCallNode(supercall_pos, super_function, arguments);
 }
 
 
+// Simple test if a node is side effect free.
+static bool IsSimpleLocalOrLiteralNode(AstNode* node) {
+  if (node->IsLiteralNode()) {
+    return true;
+  }
+  if (node->IsLoadLocalNode() && !node->AsLoadLocalNode()->HasPseudo()) {
+    return true;
+  }
+  return false;
+}
+
+
 AstNode* Parser::ParseSuperOperator() {
   TRACE_PARSER("ParseSuperOperator");
   AstNode* super_op = NULL;
   const intptr_t operator_pos = token_index_;
 
   if (CurrentToken() == Token::kLBRACK) {
     ConsumeToken();
     AstNode* index_expr = ParseExpr(kAllowConst);
     ExpectToken(Token::kRBRACK);
 
     if (Token::IsAssignmentOperator(CurrentToken()) &&
         (CurrentToken() != Token::kASSIGN)) {
       // Compound assignment. Ensure side effects in index expression
       // only execute once. If the index is not a local variable or an
       // literal, evaluate and save in a temporary local.
-      if (!index_expr->IsLoadLocalNode() && !index_expr->IsLiteralNode()) {
+      if (!IsSimpleLocalOrLiteralNode(index_expr)) {
         LocalVariable* temp =
             CreateTempConstVariable(operator_pos, index_expr->id(), "lix");
         AstNode* save =
             new StoreLocalNode(operator_pos, *temp, index_expr);
         current_block_->statements->Add(save);
         index_expr = new LoadLocalNode(operator_pos, *temp);
       }
     }
 
     // Resolve the [] operator function in the superclass.
@@ skipping 602 matching lines @@
     // We need to patch the super _initializer_ call so that it
     // saves the evaluated actual arguments in temporary variables.
     // The temporary variables are necessary so that the argument
     // expressions are not evaluated twice.
     ArgumentListNode* ctor_args = super_call->arguments();
     // The super initializer call has at least 2 arguments: the
     // implicit receiver, and the hidden construction phase.
     ASSERT(ctor_args->length() >= 2);
     for (int i = 2; i < ctor_args->length(); i++) {
       AstNode* arg = ctor_args->NodeAt(i);
-      if (!arg->IsLoadLocalNode() && !arg->IsLiteralNode()) {
+      if (!IsSimpleLocalOrLiteralNode(arg)) {
         LocalVariable* temp =
             CreateTempConstVariable(arg->token_index(), arg->id(), "sca");
         AstNode* save_temp =
             new StoreLocalNode(arg->token_index(), *temp, arg);
         ctor_args->SetNodeAt(i, save_temp);
       }
     }
   }
   OpenBlock();  // Block to collect constructor body nodes.
 
@@ skipping 3986 matching lines @@
       }
     }
     current_preced--;
   }
   return left_operand;
 }
 
 
 bool Parser::IsAssignableExpr(AstNode* expr) {
   return expr->IsPrimaryNode()
-      || expr->IsLoadLocalNode()
+      || (expr->IsLoadLocalNode() && !expr->AsLoadLocalNode()->HasPseudo())
       || expr->IsLoadStaticFieldNode()
       || expr->IsStaticGetterNode()
       || expr->IsInstanceGetterNode()
       || expr->IsLoadIndexedNode();
 }
 
 
 AstNode* Parser::ParseExprList() {
   TRACE_PARSER("ParseExprList");
   AstNode* expressions = ParseExpr(kAllowConst);
   if (CurrentToken() == Token::kCOMMA) {
     // Collect comma-separated expressions in a non scope owning sequence node.
     SequenceNode* list = new SequenceNode(token_index_, NULL);
     list->Add(expressions);
     while (CurrentToken() == Token::kCOMMA) {
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
-static bool IsLocalOrLiteralNode(AstNode* node) {
-  return node->IsLoadLocalNode() || node->IsLiteralNode();
+const LocalVariable& Parser::GetIncrementTempLocal() {
+  if (increment_temp_ == NULL) {
+    increment_temp_ =
+        new LocalVariable(current_function_.token_index(),
+                          String::ZoneHandle(String::NewSymbol(":incrtemp")),
+                          Type::ZoneHandle(Type::DynamicType()));
+  }
+  return *increment_temp_;
 }
 
-
 LocalVariable* Parser::CreateTempConstVariable(intptr_t token_index,
                                                intptr_t token_id,
                                                const char* s) {
   char name[64];
   OS::SNPrint(name, 64, ":%s%d", s, token_id);
   LocalVariable* temp =
       new LocalVariable(token_index,
                         String::ZoneHandle(String::NewSymbol(name)),
                         Type::ZoneHandle(Type::DynamicType()));
   temp->set_is_final();
@@ skipping 86 matching lines @@
 // left and right nodes. 'expr' becomes the right node, left node is returned as
 // result.
 AstNode* Parser::PrepareCompoundAssignmentNodes(AstNode** expr) {
   AstNode* node = *expr;
   if (node->IsLoadIndexedNode()) {
     LoadIndexedNode* left_node = node->AsLoadIndexedNode();
     LoadIndexedNode* right_node = left_node;
     intptr_t node_id = node->id();
     intptr_t token_index = node->token_index();
     node = NULL;  // Do not use it.
-    if (!IsLocalOrLiteralNode(left_node->array())) {
+    if (!IsSimpleLocalOrLiteralNode(left_node->array())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_index, node_id, "lia");
       StoreLocalNode* save =
           new StoreLocalNode(token_index, *temp, left_node->array());
       left_node =
           new LoadIndexedNode(token_index, save, left_node->index_expr());
       right_node = new LoadIndexedNode(token_index,
                                        new LoadLocalNode(token_index, *temp),
                                        right_node->index_expr());
     }
-    if (!IsLocalOrLiteralNode(left_node->index_expr())) {
+    if (!IsSimpleLocalOrLiteralNode(left_node->index_expr())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_index, node_id, "lix");
       StoreLocalNode* save =
           new StoreLocalNode(token_index, *temp, left_node->index_expr());
       left_node = new LoadIndexedNode(token_index,
                                       left_node->array(),
                                       save);
       right_node = new LoadIndexedNode(token_index,
                                        right_node->array(),
                                        new LoadLocalNode(token_index, *temp));
     }
     *expr = right_node;
     return left_node;
   }
   if (node->IsInstanceGetterNode()) {
     InstanceGetterNode* left_node = node->AsInstanceGetterNode();
     InstanceGetterNode* right_node = left_node;
     intptr_t node_id = node->id();
     intptr_t token_index = node->token_index();
     node = NULL;  // Do not use it.
-    if (!IsLocalOrLiteralNode(left_node->receiver())) {
+    if (!IsSimpleLocalOrLiteralNode(left_node->receiver())) {
       LocalVariable* temp =
           CreateTempConstVariable(token_index, node_id, "igr");
       StoreLocalNode* save =
           new StoreLocalNode(token_index, *temp, left_node->receiver());
       left_node = new InstanceGetterNode(token_index,
                                          save,
                                          left_node->field_name());
       right_node = new InstanceGetterNode(token_index,
                                           new LoadLocalNode(token_index, *temp),
                                           right_node->field_name());
@@ skipping 576 matching lines @@
   }
   if (IsIncrementOperator(CurrentToken())) {
     TRACE_PARSER("IncrementOperator");
     Token::Kind incr_op = CurrentToken();
     if (!IsAssignableExpr(postfix_expr)) {
       ErrorMsg("expression is not assignable");
     }
     ConsumeToken();
     // Not prefix.
     if (postfix_expr->IsLoadStaticFieldNode() ||
-        postfix_expr->IsStaticGetterNode()) {
-      LocalVariable* temp = CreateTempConstVariable(
-          postfix_expr_pos, postfix_expr->id(), "incoplix");
+        postfix_expr->IsStaticGetterNode() ||
+        postfix_expr->IsLoadLocalNode()) {
+      const LocalVariable& temp = GetIncrementTempLocal();
       AstNode* save =
-          new StoreLocalNode(postfix_expr_pos, *temp, postfix_expr);
+          new StoreLocalNode(postfix_expr_pos, temp, postfix_expr);
       Token::Kind binary_op =
           (incr_op == Token::kINCR) ? Token::kADD : Token::kSUB;
       BinaryOpNode* add = new BinaryOpNode(
           postfix_expr_pos,
           binary_op,
           save,
           new LiteralNode(postfix_expr_pos, Smi::ZoneHandle(Smi::New(1))));
       AstNode* store = postfix_expr->MakeAssignmentNode(add);
       LoadLocalNode* load_res =
-          new LoadLocalNode(postfix_expr_pos, *temp, store);
+          new LoadLocalNode(postfix_expr_pos, temp, store);
       return load_res;
     } else {
       AstNode* incr_op_node =
           postfix_expr->MakeIncrOpNode(postfix_expr_pos, incr_op, false);
       if (incr_op_node == NULL) {
         Unimplemented("incr op not implemented");
       }
       postfix_expr = incr_op_node;
     }
   }
@@ skipping 1772 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart