First step of refactoring expression contexts in the toplevel code...

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 757 matching lines @@
   Handle<JSFunction> boilerplate =
       Compiler::BuildBoilerplate(expr, script_, this);
   if (HasStackOverflow()) return;
 
   ASSERT(boilerplate->IsBoilerplate());
 
   // Create a new closure.
   __ push(esi);
   __ push(Immediate(boilerplate));
   __ CallRuntime(Runtime::kNewClosure, 2);
-  Apply(expr->context(), eax);
+  Apply(context_, eax);
 }
 
 
 void FastCodeGenerator::VisitVariableProxy(VariableProxy* expr) {
   Comment cmnt(masm_, "[ VariableProxy");
-  EmitVariableLoad(expr->var(), expr->context());
+  EmitVariableLoad(expr->var(), context_);
 }
 
 
 void FastCodeGenerator::EmitVariableLoad(Variable* var,
                                          Expression::Context context) {
   Expression* rewrite = var->rewrite();
   if (rewrite == NULL) {
     ASSERT(var->is_global());
     Comment cmnt(masm_, "Global variable");
     // Use inline caching. Variable name is passed in ecx and the global
@@ skipping 83 matching lines @@
   __ j(not_equal, &done);
   // Create regexp literal using runtime function
   // Result will be in eax.
   __ push(ebx);
   __ push(Immediate(Smi::FromInt(expr->literal_index())));
   __ push(Immediate(expr->pattern()));
   __ push(Immediate(expr->flags()));
   __ CallRuntime(Runtime::kMaterializeRegExpLiteral, 4);
   // Label done:
   __ bind(&done);
-  Apply(expr->context(), eax);
+  Apply(context_, eax);
 }
 
 
 void FastCodeGenerator::VisitObjectLiteral(ObjectLiteral* expr) {
   Comment cmnt(masm_, "[ ObjectLiteral");
   __ mov(edi, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
   __ push(FieldOperand(edi, JSFunction::kLiteralsOffset));
   __ push(Immediate(Smi::FromInt(expr->literal_index())));
   __ push(Immediate(expr->constant_properties()));
   if (expr->depth() > 1) {
@@ skipping 45 matching lines @@
                           Smi::FromInt(1) :
                           Smi::FromInt(0)));
         VisitForValue(value, kStack);
         __ CallRuntime(Runtime::kDefineAccessor, 4);
         break;
       default: UNREACHABLE();
     }
   }
 
   if (result_saved) {
-    ApplyTOS(expr->context());
+    ApplyTOS(context_);
   } else {
-    Apply(expr->context(), eax);
+    Apply(context_, eax);
   }
 }
 
 
 void FastCodeGenerator::VisitArrayLiteral(ArrayLiteral* expr) {
   Comment cmnt(masm_, "[ ArrayLiteral");
   __ mov(ebx, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
   __ push(FieldOperand(ebx, JSFunction::kLiteralsOffset));
   __ push(Immediate(Smi::FromInt(expr->literal_index())));
   __ push(Immediate(expr->constant_elements()));
@@ skipping 27 matching lines @@
     __ mov(ebx, Operand(esp, 0));  // Copy of array literal.
     __ mov(ebx, FieldOperand(ebx, JSObject::kElementsOffset));
     int offset = FixedArray::kHeaderSize + (i * kPointerSize);
     __ mov(FieldOperand(ebx, offset), result_register());
 
     // Update the write barrier for the array store.
     __ RecordWrite(ebx, offset, result_register(), ecx);
   }
 
   if (result_saved) {
-    ApplyTOS(expr->context());
+    ApplyTOS(context_);
   } else {
-    Apply(expr->context(), eax);
+    Apply(context_, eax);
   }
 }
 
 
 void FastCodeGenerator::EmitNamedPropertyLoad(Property* prop) {
   SetSourcePosition(prop->position());
   Literal* key = prop->key()->AsLiteral();
   __ mov(ecx, Immediate(key->handle()));
   Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
   __ call(ic, RelocInfo::CODE_TARGET);
@@ skipping 93 matching lines @@
   __ nop();
 
   // If the assignment ends an initialization block, revert to fast case.
   if (expr->ends_initialization_block()) {
     __ push(eax);  // Result of assignment, saved even if not needed.
     __ push(Operand(esp, kPointerSize));  // Receiver is under value.
     __ CallRuntime(Runtime::kToFastProperties, 1);
     __ pop(eax);
   }
 
-  DropAndApply(1, expr->context(), eax);
+  DropAndApply(1, context_, eax);
 }
 
 
 void FastCodeGenerator::EmitKeyedPropertyAssignment(Assignment* expr) {
   // Assignment to a property, using a keyed store IC.
 
   // If the assignment starts a block of assignments to the same object,
   // change to slow case to avoid the quadratic behavior of repeatedly
   // adding fast properties.
   if (expr->starts_initialization_block()) {
@@ skipping 15 matching lines @@
   // If the assignment ends an initialization block, revert to fast case.
   if (expr->ends_initialization_block()) {
     __ push(eax);  // Result of assignment, saved even if not needed.
     // Receiver is under the key and value.
     __ push(Operand(esp, 2 * kPointerSize));
     __ CallRuntime(Runtime::kToFastProperties, 1);
     __ pop(eax);
   }
 
   // Receiver and key are still on stack.
-  DropAndApply(2, expr->context(), eax);
+  DropAndApply(2, context_, eax);
 }
 
 
 void FastCodeGenerator::VisitProperty(Property* expr) {
   Comment cmnt(masm_, "[ Property");
   Expression* key = expr->key();
 
   // Evaluate the receiver.
   VisitForValue(expr->obj(), kStack);
 
   if (key->IsPropertyName()) {
     EmitNamedPropertyLoad(expr);
     // Drop receiver left on the stack by IC.
-    DropAndApply(1, expr->context(), eax);
+    DropAndApply(1, context_, eax);
   } else {
     VisitForValue(expr->key(), kStack);
     EmitKeyedPropertyLoad(expr);
     // Drop key and receiver left on the stack by IC.
-    DropAndApply(2, expr->context(), eax);
+    DropAndApply(2, context_, eax);
   }
 }
 
 
 void FastCodeGenerator::EmitCallWithIC(Call* expr,
                                        Handle<Object> name,
                                        RelocInfo::Mode mode) {
   // Code common for calls using the IC.
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     VisitForValue(args->at(i), kStack);
   }
   __ Set(ecx, Immediate(name));
   // Record source position of the IC call.
   SetSourcePosition(expr->position());
   InLoopFlag in_loop = (loop_depth() > 0) ? IN_LOOP : NOT_IN_LOOP;
   Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count, in_loop);
   __ call(ic, mode);
   // Restore context register.
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
-  Apply(expr->context(), eax);
+  Apply(context_, eax);
 }
 
 
 void FastCodeGenerator::EmitCallWithStub(Call* expr) {
   // Code common for calls using the call stub.
   ZoneList<Expression*>* args = expr->arguments();
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     VisitForValue(args->at(i), kStack);
   }
   // Record source position for debugger.
   SetSourcePosition(expr->position());
   CallFunctionStub stub(arg_count, NOT_IN_LOOP, RECEIVER_MIGHT_BE_VALUE);
   __ CallStub(&stub);
   // Restore context register.
   __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
-  DropAndApply(1, expr->context(), eax);
+  DropAndApply(1, context_, eax);
 }
 
 
 void FastCodeGenerator::VisitCall(Call* expr) {
   Comment cmnt(masm_, "[ Call");
   Expression* fun = expr->expression();
   Variable* var = fun->AsVariableProxy()->AsVariable();
 
   if (var != NULL && var->is_possibly_eval()) {
     // Call to the identifier 'eval'.
@@ skipping 85 matching lines @@
 
   // Load function, arg_count into edi and eax.
   __ Set(eax, Immediate(arg_count));
   // Function is in esp[arg_count + 1].
   __ mov(edi, Operand(esp, eax, times_pointer_size, kPointerSize));
 
   Handle<Code> construct_builtin(Builtins::builtin(Builtins::JSConstructCall));
   __ call(construct_builtin, RelocInfo::CONSTRUCT_CALL);
 
   // Replace function on TOS with result in eax, or pop it.
-  DropAndApply(1, expr->context(), eax);
+  DropAndApply(1, context_, eax);
 }
 
 
 void FastCodeGenerator::VisitCallRuntime(CallRuntime* expr) {
   Comment cmnt(masm_, "[ CallRuntime");
   ZoneList<Expression*>* args = expr->arguments();
 
   if (expr->is_jsruntime()) {
     // Prepare for calling JS runtime function.
     __ mov(eax, CodeGenerator::GlobalObject());
@@ skipping 11 matching lines @@
     __ Set(ecx, Immediate(expr->name()));
     InLoopFlag in_loop = (loop_depth() > 0) ? IN_LOOP : NOT_IN_LOOP;
     Handle<Code> ic = CodeGenerator::ComputeCallInitialize(arg_count, in_loop);
     __ call(ic, RelocInfo::CODE_TARGET);
       // Restore context register.
     __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
   } else {
     // Call the C runtime function.
     __ CallRuntime(expr->function(), arg_count);
   }
-  Apply(expr->context(), eax);
+  Apply(context_, eax);
 }
 
 
 void FastCodeGenerator::VisitUnaryOperation(UnaryOperation* expr) {
   switch (expr->op()) {
     case Token::VOID: {
       Comment cmnt(masm_, "[ UnaryOperation (VOID)");
-      ASSERT_EQ(Expression::kEffect, expr->expression()->context());
-      Visit(expr->expression());
-      switch (expr->context()) {
+      VisitForEffect(expr->expression());
+      switch (context_) {
         case Expression::kUninitialized:
           UNREACHABLE();
           break;
         case Expression::kEffect:
           break;
         case Expression::kValue:
           switch (location_) {
             case kAccumulator:
               __ mov(result_register(), Factory::undefined_value());
               break;
@@ skipping 16 matching lines @@
         case Expression::kTest:
         case Expression::kValueTest:
           __ jmp(false_label_);
           break;
       }
       break;
     }
 
     case Token::NOT: {
       Comment cmnt(masm_, "[ UnaryOperation (NOT)");
-      ASSERT_EQ(Expression::kTest, expr->expression()->context());
-
       Label materialize_true, materialize_false, done;
       // Initially assume a pure test context.  Notice that the labels are
       // swapped.
       Label* if_true = false_label_;
       Label* if_false = true_label_;
-      switch (expr->context()) {
+      switch (context_) {
         case Expression::kUninitialized:
           UNREACHABLE();
           break;
         case Expression::kEffect:
           if_true = &done;
           if_false = &done;
           break;
         case Expression::kValue:
           if_true = &materialize_false;
           if_false = &materialize_true;
           break;
         case Expression::kTest:
           break;
         case Expression::kValueTest:
           if_false = &materialize_true;
           break;
         case Expression::kTestValue:
           if_true = &materialize_false;
           break;
       }
       VisitForControl(expr->expression(), if_true, if_false);
-      Apply(expr->context(), if_false, if_true);  // Labels swapped.
+      Apply(context_, if_false, if_true);  // Labels swapped.
       break;
     }
 
     case Token::TYPEOF: {
       Comment cmnt(masm_, "[ UnaryOperation (TYPEOF)");
-      ASSERT_EQ(Expression::kValue, expr->expression()->context());
-
       VariableProxy* proxy = expr->expression()->AsVariableProxy();
       if (proxy != NULL &&
           !proxy->var()->is_this() &&
           proxy->var()->is_global()) {
         Comment cmnt(masm_, "Global variable");
         __ push(CodeGenerator::GlobalObject());
         __ mov(ecx, Immediate(proxy->name()));
         Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
         // Use a regular load, not a contextual load, to avoid a reference
         // error.
         __ call(ic, RelocInfo::CODE_TARGET);
         __ mov(Operand(esp, 0), eax);
       } else if (proxy != NULL &&
                  proxy->var()->slot() != NULL &&
                  proxy->var()->slot()->type() == Slot::LOOKUP) {
         __ push(esi);
         __ push(Immediate(proxy->name()));
         __ CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
         __ push(eax);
       } else {
         // This expression cannot throw a reference error at the top level.
         VisitForValue(expr->expression(), kStack);
       }
 
       __ CallRuntime(Runtime::kTypeof, 1);
-      Apply(expr->context(), eax);
+      Apply(context_, eax);
       break;
     }
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCountOperation(CountOperation* expr) {
   Comment cmnt(masm_, "[ CountOperation");
 
   // Expression 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->expression()->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;
+    assign_type =
+        (prop->key()->IsPropertyName()) ? NAMED_PROPERTY : KEYED_PROPERTY;
   }
 
   // Evaluate expression and get value.
   if (assign_type == VARIABLE) {
     ASSERT(expr->expression()->AsVariableProxy()->var() != NULL);
     Location saved_location = location_;
     location_ = kStack;
     EmitVariableLoad(expr->expression()->AsVariableProxy()->var(),
                      Expression::kValue);
     location_ = saved_location;
   } else  {
     // Reserve space for result of postfix operation.
-    if (expr->is_postfix() && expr->context() != Expression::kEffect) {
-      ASSERT(expr->context() != Expression::kUninitialized);
+    if (expr->is_postfix() && context_ != Expression::kEffect) {
       __ push(Immediate(Smi::FromInt(0)));
     }
     VisitForValue(prop->obj(), kStack);
     if (assign_type == NAMED_PROPERTY) {
       EmitNamedPropertyLoad(prop);
     } else {
       VisitForValue(prop->key(), kStack);
       EmitKeyedPropertyLoad(prop);
     }
     __ push(eax);
   }
 
   // Convert to number.
   __ InvokeBuiltin(Builtins::TO_NUMBER, CALL_FUNCTION);
 
   // Save result for postfix expressions.
   if (expr->is_postfix()) {
-    switch (expr->context()) {
+    switch (context_) {
       case Expression::kUninitialized:
         UNREACHABLE();
       case Expression::kEffect:
         // Do not save result.
         break;
       case Expression::kValue:
       case Expression::kTest:
       case Expression::kValueTest:
       case Expression::kTestValue:
         // Save the result on the stack. If we have a named or keyed property
@@ skipping 23 matching lines @@
   __ CallStub(&stub);
 
   // Store the value returned in eax.
   switch (assign_type) {
     case VARIABLE:
       if (expr->is_postfix()) {
         EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
                                Expression::kEffect);
         // For all contexts except kEffect: We have the result on
         // top of the stack.
-        if (expr->context() != Expression::kEffect) {
-          ApplyTOS(expr->context());
+        if (context_ != Expression::kEffect) {
+          ApplyTOS(context_);
         }
       } else {
         EmitVariableAssignment(expr->expression()->AsVariableProxy()->var(),
-                               expr->context());
+                               context_);
       }
       break;
     case NAMED_PROPERTY: {
       __ mov(ecx, prop->key()->AsLiteral()->handle());
       Handle<Code> ic(Builtins::builtin(Builtins::StoreIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
       // This nop signals to the IC that there is no inlined code at the call
       // site for it to patch.
       __ nop();
       if (expr->is_postfix()) {
         __ Drop(1);  // Result is on the stack under the receiver.
-        if (expr->context() != Expression::kEffect) {
-          ApplyTOS(expr->context());
+        if (context_ != Expression::kEffect) {
+          ApplyTOS(context_);
         }
       } else {
-        DropAndApply(1, expr->context(), eax);
+        DropAndApply(1, context_, eax);
       }
       break;
     }
     case KEYED_PROPERTY: {
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedStoreIC_Initialize));
       __ call(ic, RelocInfo::CODE_TARGET);
       // This nop signals to the IC that there is no inlined code at the call
       // site for it to patch.
       __ nop();
       if (expr->is_postfix()) {
         __ Drop(2);  // Result is on the stack under the key and the receiver.
-        if (expr->context() != Expression::kEffect) {
-          ApplyTOS(expr->context());
+        if (context_ != Expression::kEffect) {
+          ApplyTOS(context_);
         }
       } else {
-        DropAndApply(2, expr->context(), eax);
+        DropAndApply(2, context_, eax);
       }
       break;
     }
   }
 }
 
 
 void FastCodeGenerator::VisitBinaryOperation(BinaryOperation* expr) {
   Comment cmnt(masm_, "[ BinaryOperation");
   switch (expr->op()) {
     case Token::COMMA:
-      ASSERT_EQ(Expression::kEffect, expr->left()->context());
-      ASSERT_EQ(expr->context(), expr->right()->context());
-      Visit(expr->left());
+      VisitForEffect(expr->left());
       Visit(expr->right());
       break;
 
     case Token::OR:
     case Token::AND:
       EmitLogicalOperation(expr);
       break;
 
     case Token::ADD:
     case Token::SUB:
     case Token::DIV:
     case Token::MOD:
     case Token::MUL:
     case Token::BIT_OR:
     case Token::BIT_AND:
     case Token::BIT_XOR:
     case Token::SHL:
     case Token::SHR:
     case Token::SAR:
       VisitForValue(expr->left(), kStack);
       VisitForValue(expr->right(), kAccumulator);
-      EmitBinaryOp(expr->op(), expr->context());
+      EmitBinaryOp(expr->op(), context_);
       break;
 
     default:
       UNREACHABLE();
   }
 }
 
 
 void FastCodeGenerator::VisitCompareOperation(CompareOperation* expr) {
   Comment cmnt(masm_, "[ CompareOperation");
 
   // Always perform the comparison for its control flow.  Pack the result
   // into the expression's context after the comparison is performed.
   Label materialize_true, materialize_false, done;
   // Initially assume we are in a test context.
   Label* if_true = true_label_;
   Label* if_false = false_label_;
-  switch (expr->context()) {
+  switch (context_) {
     case Expression::kUninitialized:
       UNREACHABLE();
       break;
     case Expression::kEffect:
       if_true = &done;
       if_false = &done;
       break;
     case Expression::kValue:
       if_true = &materialize_true;
       if_false = &materialize_false;
@@ skipping 81 matching lines @@
       CompareStub stub(cc, strict);
       __ CallStub(&stub);
       __ test(eax, Operand(eax));
       __ j(cc, if_true);
       __ jmp(if_false);
     }
   }
 
   // Convert the result of the comparison into one expected for this
   // expression's context.
-  Apply(expr->context(), if_true, if_false);
+  Apply(context_, if_true, if_false);
 }
 
 
 void FastCodeGenerator::VisitThisFunction(ThisFunction* expr) {
   __ mov(eax, Operand(ebp, JavaScriptFrameConstants::kFunctionOffset));
-  Apply(expr->context(), eax);
+  Apply(context_, eax);
 }
 
 
 Register FastCodeGenerator::result_register() { return eax; }
 
 
 Register FastCodeGenerator::context_register() { return esi; }
 
 
 void FastCodeGenerator::StoreToFrameField(int frame_offset, Register value) {
@@ skipping 34 matching lines @@
   __ add(Operand(edx), Immediate(masm_->CodeObject()));
   __ mov(Operand(esp, 0), edx);
   // And return.
   __ ret(0);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal