Adapt compile time constants and integrate with Kevin's CL 10302007 (Remove temporaries using expli…

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 94 matching lines @@
   UnhandledException& excp = UnhandledException::Handle();
   excp ^= obj.raw();
   const Instance& exception = Instance::ZoneHandle(excp.exception());
   const Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
+LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_index) {
+  return new LocalVariable(token_index,
+                           String::ZoneHandle(String::NewSymbol(":expr_temp")),
+                           Type::ZoneHandle(Type::DynamicType()));
+}
+
+
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
   const int num_fixed_params = function().num_fixed_parameters();
   const int num_opt_params = function().num_optional_parameters();
   // Allocated ids for parameters.
   intptr_t parameter_id = AstNode::kNoId;
   for (intptr_t i = 0; i < num_fixed_params + num_opt_params; i++) {
     parameter_id = AstNode::GetNextId();
     if (i == 0) {
       node_sequence_->set_first_parameter_id(parameter_id);
     }
   }
   node_sequence_->set_last_parameter_id(parameter_id);
 }
 
+
 void ParsedFunction::AllocateVariables() {
   LocalScope* scope = node_sequence()->scope();
   const int fixed_parameter_count = function().num_fixed_parameters();
   const int optional_parameter_count = function().num_optional_parameters();
   const int parameter_count = fixed_parameter_count + optional_parameter_count;
   // Compute start indices to parameters and locals, and the number of
   // parameters to copy.
   if (optional_parameter_count == 0) {
     // Parameter i will be at fp[1 + parameter_count - i] and local variable
     // j will be at fp[-1 - j].
@@ skipping 79 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TryBlocks);
 };
 
 
 void Parser::TryBlocks::AddNodeForFinallyInlining(AstNode* node) {
   inlined_finally_nodes_.Add(node);
 }
 
 
-Parser::Parser(const Script& script, const Library& library)
+Parser::Parser(const Script& script,
+               const Library& library)
     : 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),
-      increment_temp_(NULL) {
+      expression_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),
-      increment_temp_(NULL)  {
+      expression_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 403 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_);
+  if (parser.expression_temp_ != NULL) {
+    parsed_function->set_expression_temp_var(parser.expression_temp_);
+  }
+  if (parsed_function->has_expression_temp_var()) {

[hausner, 2012/05/09 20:52:08]

This if statement is true iff the previous one was true, I think. Can this be
simplified to one if?

[srdjan, 2012/05/09 21:25:45]

Yes, but it can be true even if the previous one was false.

+    node_sequence->scope()->AddVariable(parsed_function->expression_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()) {
     // In the case of a local function, only set the instantiator if the
     // receiver was captured.
     const bool kTestOnly = true;
     LocalVariable* receiver =
@@ skipping 4550 matching lines @@
       AstNode* exception_type = new TypeNode(catch_pos, *exception_param.type);
       AstNode* exception_var = new LoadLocalNode(catch_pos, *catch_excp_var);
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_var, exception_type);
       if (catch_clause_count == 1) {
         // Null is also allowed, but check only in the first clause.
         AstNode* null_literal =
             new LiteralNode(catch_pos, Instance::ZoneHandle(Instance::null()));
         AstNode* null_cond_expr = new ComparisonNode(
             catch_pos, Token::kEQ_STRICT, exception_var, null_literal);
+        EnsureExpressionTemp();
         AstNode* or_node = new BinaryOpNode(
             catch_pos, Token::kOR, null_cond_expr, type_cond_expr);
         current_block_->statements->Add(
             new IfNode(catch_pos, or_node, catch_handler, NULL));
       } else {
         current_block_->statements->Add(
             new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
       }
     } else {
       // No exception type exists in the catch specifier so execute the
@@ skipping 627 matching lines @@
       AstNode* expr = ParseExpr(kAllowConst);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
 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()));
+  if (expression_temp_ == NULL) {
+    expression_temp_ = ParsedFunction::CreateExpressionTempVar(
+        current_function().token_index());
   }
-  return *increment_temp_;
+  return *expression_temp_;
 }
 
+
+void Parser::EnsureExpressionTemp() {
+  // Temporary used later by the flow_graph_builder.
+  GetIncrementTempLocal();
+}
+
+
 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 16 matching lines @@
       dbl_obj ^= lhs_literal->literal().raw();
       double left_double = dbl_obj.value();
       dbl_obj ^= rhs_literal->literal().raw();
       double right_double = dbl_obj.value();
       if (binary_op == Token::kDIV) {
         dbl_obj = Double::NewCanonical((left_double / right_double));
         return new LiteralNode(op_pos, dbl_obj);
       }
     }
   }
+  if ((binary_op == Token::kAND) || (binary_op == Token::kOR)) {

[hausner, 2012/05/09 20:52:08]

I thought you wanted to do constant folding in the compiler, i.e. replace the
binary op node with a literal true or false if both sides are compile time
constant boolean expressions.

[srdjan, 2012/05/09 21:25:45]

It turns out that constant folding is not needed. It will be done by the
optimizing compiler later.

+    EnsureExpressionTemp();
+  }
   return new BinaryOpNode(op_pos, binary_op, lhs, rhs);
 }
 
 
 AstNode* Parser::ExpandAssignableOp(intptr_t op_pos,
                                     Token::Kind assignment_op,
                                     AstNode* lhs,
                                     AstNode* rhs) {
   TRACE_PARSER("ExpandAssignableOp");
   switch (assignment_op) {
@@ skipping 150 matching lines @@
   ASSERT(expr->IsLiteralNode());
   return expr->AsLiteralNode();
 }
 
 
 AstNode* Parser::ParseConditionalExpr() {
   TRACE_PARSER("ParseConditionalExpr");
   const intptr_t expr_pos = token_index_;
   AstNode* expr = ParseBinaryExpr(Token::Precedence(Token::kOR));
   if (CurrentToken() == Token::kCONDITIONAL) {
+    EnsureExpressionTemp();
     ConsumeToken();
     AstNode* expr1 = ParseExpr(kAllowConst);
     ExpectToken(Token::kCOLON);
     AstNode* expr2 = ParseExpr(kAllowConst);
     expr = new ConditionalExprNode(expr_pos, expr, expr1, expr2);
   }
   return expr;
 }
 
 
@@ skipping 2302 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart