Eliminate the constant location used for literals in the AST....

src/arm/fast-codegen-arm.cc

 // Copyright 2009 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 131 matching lines @@
   Comment cmnt(masm_, "[ ExpressionStatement");
   SetStatementPosition(stmt);
   Visit(stmt->expression());
 }
 
 
 void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Comment cmnt(masm_, "[ ReturnStatement");
   SetStatementPosition(stmt);
   Expression* expr = stmt->expression();
-  Visit(expr);
-
-  // Complete the statement based on the location of the subexpression.
-  Location source = expr->location();
-  ASSERT(!source.is_nowhere());
-  if (source.is_temporary()) {
+  // Complete the statement based on the type of the subexpression.
+  if (expr->AsLiteral() != NULL) {
+    __ mov(r0, Operand(expr->AsLiteral()->handle()));
+  } else {
+    Visit(expr);
+    ASSERT(expr->location().is_temporary());
     __ pop(r0);
-  } else {
-    ASSERT(source.is_constant());
-    ASSERT(expr->AsLiteral() != NULL);
-    __ mov(r0, Operand(expr->AsLiteral()->handle()));
   }
 
   if (FLAG_trace) {
-    // Push the return value on the stack as the parameter.
-    // Runtime::TraceExit returns its parameter in r0.
     __ push(r0);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
 
   __ RecordJSReturn();
   __ mov(sp, fp);
   __ ldm(ia_w, sp, fp.bit() | lr.bit());
   int num_parameters = function_->scope()->num_parameters();
   __ add(sp, sp, Operand((num_parameters + 1) * kPointerSize));
   __ Jump(lr);
@@ skipping 49 matching lines @@
     if (expr->location().is_temporary()) {
       __ ldr(ip, MemOperand(fp, SlotOffset(slot)));
       __ push(ip);
     } else {
       ASSERT(expr->location().is_nowhere());
     }
   }
 }
 
 
+void FastCodeGenerator::VisitLiteral(Literal* expr) {
+  if (expr->location().is_temporary()) {
+    __ mov(ip, Operand(expr->AsLiteral()->handle()));
+    __ push(ip);
+  } else {
+    ASSERT(expr->location().is_nowhere());
+  }
+}
+
+
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   Label boilerplate_exists;
   __ ldr(r2, MemOperand(fp,  JavaScriptFrameConstants::kFunctionOffset));
   // r2 = literal array (0).
   __ ldr(r2, FieldMemOperand(r2, JSFunction::kLiteralsOffset));
   int literal_offset =
       FixedArray::kHeaderSize + expr->literal_index() * kPointerSize;
   __ ldr(r0, FieldMemOperand(r2, literal_offset));
   // Check whether we need to materialize the object literal boilerplate.
@@ skipping 34 matching lines @@
       __ push(r0);  // Save result on stack
       result_saved = true;
     }
     switch (property->kind()) {
       case ObjectLiteral::Property::MATERIALIZED_LITERAL:   // fall through
         ASSERT(!CompileTimeValue::IsCompileTimeValue(property->value()));
       case ObjectLiteral::Property::COMPUTED:  // fall through
       case ObjectLiteral::Property::PROTOTYPE:
         __ push(r0);
         Visit(key);
-        if (key->location().is_constant()) {
-          __ mov(r1, Operand(key->handle()));
-          __ push(r1);
-        }
+        ASSERT(key->location().is_temporary());
         Visit(value);
         ASSERT(value->location().is_temporary());
         __ CallRuntime(Runtime::kSetProperty, 3);
         __ ldr(r0, MemOperand(sp));  // Restore result into r0
         break;
       case ObjectLiteral::Property::SETTER:  // fall through
       case ObjectLiteral::Property::GETTER:
         __ push(r0);
         Visit(key);
-        if (key->location().is_constant()) {
-          __ mov(r1, Operand(key->handle()));
-          __ push(r1);
-        }
+        ASSERT(key->location().is_temporary());
         __ mov(r1, Operand(property->kind() == ObjectLiteral::Property::SETTER ?
                            Smi::FromInt(1) :
                            Smi::FromInt(0)));
         __ push(r1);
         Visit(value);
         ASSERT(value->location().is_temporary());
         __ CallRuntime(Runtime::kDefineAccessor, 4);
         __ ldr(r0, MemOperand(sp));  // Restore result into r0
         break;
       default: UNREACHABLE();
@@ skipping 108 matching lines @@
     __ pop();
   } else if (destination.is_temporary() && !result_saved) {
     __ push(r0);
   }
 }
 
 
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
   ASSERT(expr->op() == Token::ASSIGN || expr->op() == Token::INIT_VAR);
-  Expression* rhs = expr->value();
-  Visit(rhs);
 
   // Left-hand side can only be a global or a (parameter or local) slot.
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL);
   ASSERT(var->is_global() || var->slot() != NULL);
 
-  // Complete the assignment based on the location of the right-hand-side
-  // value and the desired location of the assignment value.
+  Expression* rhs = expr->value();
   Location destination = expr->location();
-  Location source = rhs->location();
-  ASSERT(!destination.is_constant());
-  ASSERT(!source.is_nowhere());
-
   if (var->is_global()) {
     // Assignment to a global variable, use inline caching.  Right-hand-side
     // value is passed in r0, variable name in r2, and the global object on
     // the stack.
-    if (source.is_temporary()) {
+
+    // Code for the right-hand-side expression depends on its type.
+    if (rhs->AsLiteral() != NULL) {
+      __ mov(r0, Operand(rhs->AsLiteral()->handle()));
+    } else {
+      ASSERT(rhs->location().is_temporary());
+      Visit(rhs);
       __ pop(r0);
-    } else {
-      ASSERT(source.is_constant());
-      ASSERT(rhs->AsLiteral() != NULL);
-      __ mov(r0, Operand(rhs->AsLiteral()->handle()));
     }
     __ mov(r2, Operand(var->name()));
     __ ldr(ip, CodeGenerator::GlobalObject());
     __ push(ip);
     Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
     __ Call(ic, RelocInfo::CODE_TARGET);
     // Overwrite the global object on the stack with the result if needed.
     if (destination.is_temporary()) {
       __ str(r0, MemOperand(sp));
     } else {
       ASSERT(destination.is_nowhere());
       __ pop();
     }
 
   } else {
-    if (source.is_temporary()) {
+    // Local or parameter assignment.
+
+    // Code for the right-hand side expression depends on its type.
+    if (rhs->AsLiteral() != NULL) {
+      // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
+      // discarded result.  Always perform the assignment.
+      __ mov(ip, Operand(rhs->AsLiteral()->handle()));
+      __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
+      if (destination.is_temporary()) {
+        // Case 'temp <- (var = constant)'.  Save result.
+        __ push(ip);
+      }

[fschneider, 2009/10/26 17:57:20]

Add an assert here to be consistent with the rest of the code:

else { ASSERT(destination.is_nowhere()); }

+    } else {
+      ASSERT(rhs->location().is_temporary());
+      Visit(rhs);
       if (destination.is_temporary()) {
         // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side
         // temporary on the stack.
         __ ldr(ip, MemOperand(sp));
       } else {
         ASSERT(destination.is_nowhere());
         // Case 'var = temp'.  Discard right-hand-side temporary.
         __ pop(ip);
       }
       __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
-    } else {
-      ASSERT(source.is_constant());
-      ASSERT(rhs->AsLiteral() != NULL);
-      // Two cases: 'temp <- (var = constant)', or 'var = constant' with a
-      // discarded result.  Always perform the assignment.
-      __ mov(ip, Operand(rhs->AsLiteral()->handle()));
-      __ str(ip, MemOperand(fp, SlotOffset(var->slot())));
-      if (destination.is_temporary()) {
-        // Case 'temp <- (var = constant)'.  Save result.
-        __ push(ip);
-      }
     }
   }
 }
 
 
 void FastCodeGenerator::VisitCall(Call* expr) {
   Comment cmnt(masm_, "[ Call");
   Expression* fun = expr->expression();
   ZoneList<Expression*>* args = expr->arguments();
   Variable* var = fun->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL && !var->is_this() && var->is_global());
   ASSERT(!var->is_possibly_eval());
 
   __ mov(r1, Operand(var->name()));
   // Push global object as receiver.
   __ ldr(r0, CodeGenerator::GlobalObject());
   __ stm(db_w, sp, r1.bit() | r0.bit());
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(!args->at(i)->location().is_nowhere());
-    if (args->at(i)->location().is_constant()) {
-      ASSERT(args->at(i)->AsLiteral() != NULL);
-      __ mov(r0, Operand(args->at(i)->AsLiteral()->handle()));
-      __ push(r0);
-    }
+    ASSERT(args->at(i)->location().is_temporary());
   }
   // Record source position for debugger
   SetSourcePosition(expr->position());
   // Call the IC initialization code.
   Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count,
                                                          NOT_IN_LOOP);
   __ Call(ic, RelocInfo::CODE_TARGET_CONTEXT);
   // Restore context register.
   __ ldr(cp, MemOperand(fp, StandardFrameConstants::kContextOffset));
   if (expr->location().is_temporary()) {
     __ str(r0, MemOperand(sp));
   } else {
     ASSERT(expr->location().is_nowhere());
     __ pop();
   }
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
   Runtime::Function* function = expr->function();
 
   ASSERT(function != NULL);
 
   // Push the arguments ("left-to-right").
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     Visit(args->at(i));
-    ASSERT(!args->at(i)->location().is_nowhere());
-    if (args->at(i)->location().is_constant()) {
-      ASSERT(args->at(i)->AsLiteral() != NULL);
-      __ mov(r0, Operand(args->at(i)->AsLiteral()->handle()));
-      __ push(r0);
-    } else {
-      ASSERT(args->at(i)->location().is_temporary());
-      // If location is temporary, it is already on the stack,
-      // so nothing to do here.
-    }
+    ASSERT(args->at(i)->location().is_temporary());
   }
 
   __ CallRuntime(function, arg_count);
   if (expr->location().is_temporary()) {
     __ push(r0);
   } else {
     ASSERT(expr->location().is_nowhere());
   }
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   // Compile a short-circuited boolean or operation in a non-test
   // context.
   ASSERT(expr->op() == Token::OR);
   // Compile (e0 || e1) as if it were
   // (let (temp = e0) temp ? temp : e1).
 
   Label done;
   Location destination = expr->location();
-  ASSERT(!destination.is_constant());
+  Expression* left = expr->left();
+  Expression* right = expr->right();
 
-  Expression* left = expr->left();
-  Location left_source = left->location();
-  ASSERT(!left_source.is_nowhere());
-
-  Expression* right = expr->right();
-  Location right_source = right->location();
-  ASSERT(!right_source.is_nowhere());
-
-  Visit(left);
   // Call the runtime to find the boolean value of the left-hand
   // subexpression.  Duplicate the value if it may be needed as the final
   // result.
-  if (left_source.is_temporary()) {
+  if (left->AsLiteral() != NULL) {
+    __ mov(r0, Operand(left->AsLiteral()->handle()));
+    __ push(r0);
+    if (destination.is_temporary()) __ push(r0);

[fschneider, 2009/10/26 17:57:20]

May want to add an assert here to be consistent with the rest of the code:

else ASSERT(destination.is_nowhere());

+  } else {
+    Visit(left);
+    ASSERT(left->location().is_temporary());
     if (destination.is_temporary()) {
       __ ldr(r0, MemOperand(sp));
       __ push(r0);
     }

[fschneider, 2009/10/26 17:57:20]

Add an assert:

else {
  ASSERT(destination.is_nowhere());
}

-  } else {
-    ASSERT(left->AsLiteral() != NULL);
-    __ mov(r0, Operand(left->AsLiteral()->handle()));
-    __ push(r0);
-    if (destination.is_temporary()) __ push(r0);
   }
   // The left-hand value is in on top of the stack.  It is duplicated on the
   // stack iff the destination location is temporary.
   __ CallRuntime(Runtime::kToBool, 1);
   __ LoadRoot(ip, Heap::kTrueValueRootIndex);
   __ cmp(r0, ip);
   __ b(eq, &done);
 
   // Discard the left-hand value if present on the stack.
   if (destination.is_temporary()) __ pop();
-  Visit(right);
-
   // Save or discard the right-hand value as needed.
-  if (destination.is_temporary() && right_source.is_constant()) {
-    ASSERT(right->AsLiteral() != NULL);
-    __ mov(ip, Operand(right->AsLiteral()->handle()));
-    __ push(ip);
-  } else if (destination.is_nowhere() && right_source.is_temporary()) {
-    __ pop();
+  if (right->AsLiteral() != NULL) {
+    if (destination.is_temporary()) {
+      __ mov(ip, Operand(right->AsLiteral()->handle()));
+      __ push(ip);
+    } else {
+      ASSERT(destination.is_nowhere());
+    }
+  } else {
+    Visit(right);
+    ASSERT(right->location().is_temporary());
+    if (destination.is_nowhere()) {
+      __ pop();
+    } else {
+      ASSERT(destination.is_temporary());
+    }
   }
 
   __ bind(&done);
 }
 
 } }  // namespace v8::internal