Merge r3610, r3611, r3612, r3630, r3636, r3640, and r3664...

src/fast-codegen.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 57 matching lines @@
       offset += JavaScriptFrameConstants::kLocal0Offset;
       break;
     case Slot::CONTEXT:
     case Slot::LOOKUP:
       UNREACHABLE();
   }
   return offset;
 }
 
 
-void FastCodeGenerator::Apply(Expression::Context context, Register reg) {
-  switch (context) {
-    case Expression::kUninitialized:
-      UNREACHABLE();
-    case Expression::kEffect:
-      break;
-    case Expression::kValue:
-      __ push(reg);
-      break;
-    case Expression::kTest:
-      TestAndBranch(reg, true_label_, false_label_);
-      break;
-    case Expression::kValueTest: {
-      Label discard;
-      __ push(reg);
-      TestAndBranch(reg, true_label_, &discard);
-      __ bind(&discard);
-      __ Drop(1);
-      __ jmp(false_label_);
-      break;
-    }
-    case Expression::kTestValue: {
-      Label discard;
-      __ push(reg);
-      TestAndBranch(reg, &discard, false_label_);
-      __ bind(&discard);
-      __ Drop(1);
-      __ jmp(true_label_);
-    }
-  }
-}
-
-
 void FastCodeGenerator::VisitDeclarations(
     ZoneList<Declaration*>* declarations) {
   int length = declarations->length();
   int globals = 0;
   for (int i = 0; i < length; i++) {
     Declaration* decl = declarations->at(i);
     Variable* var = decl->proxy()->var();
     Slot* slot = var->slot();
 
     // If it was not possible to allocate the variable at compile
@@ skipping 55 matching lines @@
 }
 
 
 void FastCodeGenerator::SetStatementPosition(Statement* stmt) {
   if (FLAG_debug_info) {
     CodeGenerator::RecordPositions(masm_, stmt->statement_pos());
   }
 }
 
 
+void FastCodeGenerator::SetStatementPosition(int pos) {
+  if (FLAG_debug_info) {
+    CodeGenerator::RecordPositions(masm_, pos);
+  }
+}
+
+
 void FastCodeGenerator::SetSourcePosition(int pos) {
   if (FLAG_debug_info && pos != RelocInfo::kNoPosition) {
     masm_->RecordPosition(pos);
   }
 }
 
 
 void FastCodeGenerator::EmitLogicalOperation(BinaryOperation* expr) {
 #ifdef DEBUG
   Expression::Context expected = Expression::kUninitialized;
@@ skipping 135 matching lines @@
 
   Breakable* target = current->AsBreakable();
   __ jmp(target->break_target());
 }
 
 
 void FastCodeGenerator::VisitReturnStatement(ReturnStatement* stmt) {
   Comment cmnt(masm_, "[ ReturnStatement");
   SetStatementPosition(stmt);
   Expression* expr = stmt->expression();
-  // Complete the statement based on the type of the subexpression.
-  if (expr->AsLiteral() != NULL) {
-    __ Move(result_register(), expr->AsLiteral()->handle());
-  } else {
-    ASSERT_EQ(Expression::kValue, expr->context());
-    Visit(expr);
-    __ pop(result_register());
-  }
+  VisitForValue(expr, kAccumulator);
 
   // Exit all nested statements.
   NestedStatement* current = nesting_stack_;
   int stack_depth = 0;
   while (current != NULL) {
     stack_depth = current->Exit(stack_depth);
     current = current->outer();
   }
   __ Drop(stack_depth);
 
   EmitReturnSequence(stmt->statement_pos());
 }
 
 
-
-
 void FastCodeGenerator::VisitWithEnterStatement(WithEnterStatement* stmt) {
   Comment cmnt(masm_, "[ WithEnterStatement");
   SetStatementPosition(stmt);
 
-  Visit(stmt->expression());
+  VisitForValue(stmt->expression(), kStack);
   if (stmt->is_catch_block()) {
     __ CallRuntime(Runtime::kPushCatchContext, 1);
   } else {
     __ CallRuntime(Runtime::kPushContext, 1);
   }
   // Both runtime calls return the new context in both the context and the
   // result registers.
 
   // Update local stack frame context field.
   StoreToFrameField(StandardFrameConstants::kContextOffset, context_register());
@@ skipping 25 matching lines @@
   increment_loop_depth();
 
   __ bind(&body);
   Visit(stmt->body());
 
   // Check stack before looping.
   __ StackLimitCheck(&stack_limit_hit);
   __ bind(&stack_check_success);
 
   __ bind(loop_statement.continue_target());
+  SetStatementPosition(stmt->condition_position());
   VisitForControl(stmt->cond(), &body, loop_statement.break_target());
 
   __ bind(&stack_limit_hit);
   StackCheckStub stack_stub;
   __ CallStub(&stack_stub);
   __ jmp(&stack_check_success);
 
   __ bind(loop_statement.break_target());
 
   decrement_loop_depth();
@@ skipping 201 matching lines @@
 
 void FastCodeGenerator::VisitLiteral(Literal* expr) {
   Comment cmnt(masm_, "[ Literal");
   Apply(expr->context(), expr);
 }
 
 
 void FastCodeGenerator::VisitAssignment(Assignment* expr) {
   Comment cmnt(masm_, "[ Assignment");
 
-  // Record source code position of the (possible) IC call.
-  SetSourcePosition(expr->position());
-
   // Left-hand side can only be a property, a global or a (parameter or local)
   // slot. Variables with rewrite to .arguments are treated as KEYED_PROPERTY.
   enum LhsKind { VARIABLE, NAMED_PROPERTY, KEYED_PROPERTY };
   LhsKind assign_type = VARIABLE;
   Property* prop = expr->target()->AsProperty();
   // In case of a property we use the uninitialized expression context
   // of the key to detect a named property.
   if (prop != NULL) {
     assign_type = (prop->key()->context() == Expression::kUninitialized)
         ? NAMED_PROPERTY
         : KEYED_PROPERTY;
   }
 
   // Evaluate LHS expression.
   switch (assign_type) {
     case VARIABLE:
       // Nothing to do here.
       break;
     case NAMED_PROPERTY:
-      Visit(prop->obj());
-      ASSERT_EQ(Expression::kValue, prop->obj()->context());
+      VisitForValue(prop->obj(), kStack);
       break;
     case KEYED_PROPERTY:
-      Visit(prop->obj());
-      ASSERT_EQ(Expression::kValue, prop->obj()->context());
-      Visit(prop->key());
-      ASSERT_EQ(Expression::kValue, prop->key()->context());
+      VisitForValue(prop->obj(), kStack);
+      VisitForValue(prop->key(), kStack);
       break;
   }
 
   // If we have a compound assignment: Get value of LHS expression and
   // store in on top of the stack.
-  // Note: Relies on kValue context being 'stack'.
   if (expr->is_compound()) {
+    Location saved_location = location_;
+    location_ = kStack;
     switch (assign_type) {
       case VARIABLE:
         EmitVariableLoad(expr->target()->AsVariableProxy()->var(),
                          Expression::kValue);
         break;
       case NAMED_PROPERTY:
-        EmitNamedPropertyLoad(prop, Expression::kValue);
+        EmitNamedPropertyLoad(prop);
+        __ push(result_register());
         break;
       case KEYED_PROPERTY:
-        EmitKeyedPropertyLoad(prop, Expression::kValue);
+        EmitKeyedPropertyLoad(prop);
+        __ push(result_register());
         break;
     }
+    location_ = saved_location;
   }
 
   // Evaluate RHS expression.
   Expression* rhs = expr->value();
-  ASSERT_EQ(Expression::kValue, rhs->context());
-  Visit(rhs);
+  VisitForValue(rhs, kAccumulator);
 
   // If we have a compount assignment: Apply operator.
   if (expr->is_compound()) {
-    EmitCompoundAssignmentOp(expr->binary_op(), Expression::kValue);
+    Location saved_location = location_;
+    location_ = kAccumulator;
+    EmitBinaryOp(expr->binary_op(), Expression::kValue);
+    location_ = saved_location;
   }
 
+  // Record source position before possible IC call.
+  SetSourcePosition(expr->position());
+
   // Store the value.
   switch (assign_type) {
     case VARIABLE:
       EmitVariableAssignment(expr->target()->AsVariableProxy()->var(),
                              expr->context());
       break;
     case NAMED_PROPERTY:
       EmitNamedPropertyAssignment(expr);
       break;
     case KEYED_PROPERTY:
       EmitKeyedPropertyAssignment(expr);
       break;
   }
 }
 
 
 void FastCodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* expr) {
   // Call runtime routine to allocate the catch extension object and
   // assign the exception value to the catch variable.
   Comment cmnt(masm_, "[ CatchExtensionObject");
 
-  // Push key string.
-  ASSERT_EQ(Expression::kValue, expr->key()->context());
-  Visit(expr->key());
-  ASSERT_EQ(Expression::kValue, expr->value()->context());
-  Visit(expr->value());
+  VisitForValue(expr->key(), kStack);
+  VisitForValue(expr->value(), kStack);
 
   // Create catch extension object.
   __ CallRuntime(Runtime::kCreateCatchExtensionObject, 2);
 
   __ push(result_register());
 }
 
 
 void FastCodeGenerator::VisitThrow(Throw* expr) {
   Comment cmnt(masm_, "[ Throw");
-  Visit(expr->exception());
-  // Exception is on stack.
+  VisitForValue(expr->exception(), kStack);
   __ CallRuntime(Runtime::kThrow, 1);
   // Never returns here.
 }
 
 
 int FastCodeGenerator::TryFinally::Exit(int stack_depth) {
   // The macros used here must preserve the result register.
   __ Drop(stack_depth);
   __ PopTryHandler();
   __ Call(finally_entry_);
   return 0;
 }
 
 
 int FastCodeGenerator::TryCatch::Exit(int stack_depth) {
   // The macros used here must preserve the result register.
   __ Drop(stack_depth);
   __ PopTryHandler();
   return 0;
 }
 
 
 #undef __
 
 
 } }  // namespace v8::internal