Recognize in the fast-mode code generator when a subexpression is a...

src/ia32/fast-codegen-ia32.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 86 matching lines @@
 void FastCodeGenerator::VisitExpressionStatement(ExpressionStatement* stmt) {
   Comment cmnt(masm_, "[ ExpressionStatement");
   SetStatementPosition(stmt);
   Visit(stmt->expression());
 }
 
 
 void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Comment cmnt(masm_, "[ ReturnStatement");
   SetStatementPosition(stmt);
-  Visit(stmt->expression());
-  __ pop(eax);
+  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()) {
+    __ pop(eax);
+  } else {
+    ASSERT(source.is_constant());
+    ASSERT(expr->AsLiteral() != NULL);
+    __ mov(eax, expr->AsLiteral()->handle());
+  }
   __ RecordJSReturn();
   // Do not use the leave instruction here because it is too short to
   // patch with the code required by the debugger.
   __ mov(esp, ebp);
   __ pop(ebp);
   __ ret((function_->scope()->num_parameters() + 1) * kPointerSize);
 }
 
 
 void FastCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
   Comment cmnt(masm_, "[ VariableProxy");
   Expression* rewrite = expr->var()->rewrite();
   ASSERT(rewrite != NULL);
 
   Slot* slot = rewrite->AsSlot();
   ASSERT(slot != NULL);
   { Comment cmnt(masm_, "[ Slot");
     if (expr->location().is_temporary()) {
       __ push(Operand(ebp, SlotOffset(slot)));
     } else {
       ASSERT(expr->location().is_nowhere());
     }
   }
 }
 
 
-void FastCodeGenerator::VisitLiteral(Literal* expr) {
-  Comment cmnt(masm_, "[ Literal");
-  if (expr->location().is_temporary()) {
-    __ push(Immediate(expr->handle()));
-  } else {
-    ASSERT(expr->location().is_nowhere());
-  }
-}
-
-
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
   ASSERT(expr->op() == Token::ASSIGN || expr->op() == Token::INIT_VAR);
-  Visit(expr->value());
+  Expression* rhs = expr->value();
+  Visit(rhs);
 
+  // Left-hand side is always a (parameter or local) slot.
   Variable* var = expr->target()->AsVariableProxy()->AsVariable();
   ASSERT(var != NULL && var->slot() != NULL);
 
-  if (expr->location().is_temporary()) {
-    __ mov(eax, Operand(esp, 0));
+  // Complete the assignment based on the location of the right-hand-side
+  // value and the desired location of the assignment value.
+  Location destination = expr->location();
+  Location source = rhs->location();
+  ASSERT(!destination.is_constant());
+  ASSERT(!source.is_nowhere());
+
+  if (source.is_temporary()) {
+    if (destination.is_temporary()) {
+      // Case 'temp1 <- (var = temp0)'.  Preserve right-hand-side temporary
+      // on the stack.
+      __ mov(eax, Operand(esp, 0));
+      __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
+    } else {
+      ASSERT(destination.is_nowhere());
+      // Case 'var = temp'.  Discard right-hand-side temporary.
+      __ pop(Operand(ebp, 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(eax, rhs->AsLiteral()->handle());
     __ mov(Operand(ebp, SlotOffset(var->slot())), eax);
-  } else {
-    ASSERT(expr->location().is_nowhere());
-    __ pop(Operand(ebp, SlotOffset(var->slot())));
+    if (destination.is_temporary()) {
+      // Case 'temp <- (var = constant)'.  Save result.
+      __ push(eax);

[fschneider, 2009/10/19 09:21:38]

LGTM. As a future optimization: Do we have to push onto the stack? The result is
already stored in the variable slot. Could we set the location of the assignment
node to sth. like 'variable slot'?

+    }
   }
 }
 
 
 } }  // namespace v8::internal