Begin using the virtual frame for variable proxies and slots. Loading...

src/codegen-ia32.cc

 // Copyright 2006-2008 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 2479 matching lines @@
   }
   exit.Bind();
 }
 
 
 void CodeGenerator::LoadFromSlot(Slot* slot, TypeofState typeof_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
+    frame_->SpillAll();
     frame_->EmitPush(esi);
     frame_->EmitPush(Immediate(slot->var()->name()));
 
     if (typeof_state == INSIDE_TYPEOF) {
       frame_->CallRuntime(Runtime::kLoadContextSlotNoReferenceError, 2);
     } else {
       frame_->CallRuntime(Runtime::kLoadContextSlot, 2);
     }
     frame_->EmitPush(eax);
 
   } else {
     // Note: We would like to keep the assert below, but it fires because of
     // some nasty code in LoadTypeofExpression() which should be removed...
     // ASSERT(slot->var()->mode() != Variable::DYNAMIC);
     if (slot->var()->mode() == Variable::CONST) {
       // Const slots may contain 'the hole' value (the constant hasn't been
       // initialized yet) which needs to be converted into the 'undefined'
       // value.
+      frame_->SpillAll();
       Comment cmnt(masm_, "[ Load const");
       JumpTarget exit(this);
       __ mov(eax, SlotOperand(slot, ecx));
       __ cmp(eax, Factory::the_hole_value());
       exit.Branch(not_equal);
       __ mov(eax, Factory::undefined_value());
       exit.Bind();
       frame_->EmitPush(eax);
     } else {
-      frame_->EmitPush(SlotOperand(slot, ecx));
+      if (slot->type() == Slot::PARAMETER) {
+        frame_->LoadParameterAt(slot->index());
+      } else if (slot->type() == Slot::LOCAL) {
+        frame_->LoadLocalAt(slot->index());
+      } else {
+        // The other remaining slot types (LOOKUP and GLOBAL) cannot reach
+        // here.
+        ASSERT(slot->type() == Slot::CONTEXT);
+        frame_->SpillAll();
+        frame_->EmitPush(SlotOperand(slot, ecx));
+      }
     }
   }
 }
 
 
 void CodeGenerator::StoreToSlot(Slot* slot, InitState init_state) {
   if (slot->type() == Slot::LOOKUP) {
     ASSERT(slot->var()->mode() == Variable::DYNAMIC);
 
     // For now, just do a runtime call.
@@ skipping 67 matching lines @@
     // to bind the exit label.  Doing so can defeat peephole
     // optimization.
     if (init_state == CONST_INIT) {
       exit.Bind();
     }
   }
 }
 
 
 void CodeGenerator::VisitSlot(Slot* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ Slot");
   LoadFromSlot(node, typeof_state());
 }
 
 
 void CodeGenerator::VisitVariableProxy(VariableProxy* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ VariableProxy");
   Variable* var = node->var();
   Expression* expr = var->rewrite();
   if (expr != NULL) {
     // We have to be wary of calling Visit directly on expressions.  Because
     // of special casing comparisons of the form typeof<expr> === "string",
     // we can return from a call from Visit (to a comparison or a unary
     // operation) without a virtual frame; which will probably crash if we
     // try to emit frame code before reestablishing a frame.  Here we're
     // safe as long as variable proxies can't rewrite into typeof
@@ skipping 280 matching lines @@
     }
 
     if (node->op() == Token::ASSIGN ||
         node->op() == Token::INIT_VAR ||
         node->op() == Token::INIT_CONST) {
       Load(node->value());
 
     } else {
       frame_->SpillAll();
       target.GetValue(NOT_INSIDE_TYPEOF);
+      frame_->SpillAll();
       Literal* literal = node->value()->AsLiteral();
       if (IsInlineSmi(literal)) {
         SmiOperation(node->binary_op(), node->type(), literal->handle(), false,
                      NO_OVERWRITE);
       } else {
         Load(node->value());
         frame_->SpillAll();
         GenericBinaryOperation(node->binary_op(), node->type());
       }
     }
@@ skipping 143 matching lines @@
       __ mov(frame_->Top(), eax);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
       // Load the function to call from the property through a reference.
       Reference ref(this, property);
       ref.GetValue(NOT_INSIDE_TYPEOF);
+      frame_->SpillAll();
 
       // Pass receiver to called function.
       // The reference's size is non-negative.
       frame_->EmitPush(frame_->ElementAt(ref.size()));
 
       // Call the function.
       CallWithArguments(args, node->position());
     }
 
   } else {
@@ skipping 141 matching lines @@
   ASSERT(args->length() == 2);
 
   JumpTarget slow_case(this);
   JumpTarget end(this);
   JumpTarget not_a_flat_string(this);
   JumpTarget not_a_cons_string_either(this);
   JumpTarget try_again_with_new_string(this);
   JumpTarget ascii_string(this);
   JumpTarget got_char_code(this);
 
-  // Load the string into eax.
+  // Load the string into eax and the index into ebx.
   Load(args->at(0));
   frame_->SpillAll();
+  Load(args->at(1));
+  frame_->SpillAll();
+  frame_->EmitPop(ebx);
   frame_->EmitPop(eax);
   // If the receiver is a smi return undefined.
   ASSERT(kSmiTag == 0);
   __ test(eax, Immediate(kSmiTagMask));
   slow_case.Branch(zero, not_taken);
 
-  // Load the index into ebx.
-  Load(args->at(1));
-  frame_->SpillAll();
-  frame_->EmitPop(ebx);
-
   // Check for negative or non-smi index.
   ASSERT(kSmiTag == 0);
   __ test(ebx, Immediate(kSmiTagMask | 0x80000000));
   slow_case.Branch(not_zero, not_taken);
   // Get rid of the smi tag on the index.
   __ sar(ebx, kSmiTagSize);
 
   try_again_with_new_string.Bind();
   // Get the type of the heap object into edi.
   __ mov(edx, FieldOperand(eax, HeapObject::kMapOffset));
@@ skipping 473 matching lines @@
   { Reference target(this, node->expression());
     if (target.is_illegal()) {
       // Spoof the virtual frame to have the expected height (one higher
       // than on entry).
       if (!is_postfix) {
         frame_->EmitPush(Immediate(Smi::FromInt(0)));
       }
       return;
     }
     target.GetValue(NOT_INSIDE_TYPEOF);
+    frame_->SpillAll();
 
     CountOperationDeferred* deferred =
         new CountOperationDeferred(this, is_postfix, is_increment,
                                    target.size() * kPointerSize);
 
     frame_->EmitPop(eax);  // Load TOS into eax for calculations below
 
     // Postfix: Store the old value as the result.
     if (is_postfix) {
       __ mov(frame_->ElementAt(target.size()), eax);
@@ skipping 186 matching lines @@
 
   void Generate(MacroAssembler* masm);
 
  private:
   Major MajorKey() { return Instanceof; }
   int MinorKey() { return 0; }
 };
 
 
 void CodeGenerator::VisitCompareOperation(CompareOperation* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ CompareOperation");
 
   // Get the expressions from the node.
   Expression* left = node->left();
   Expression* right = node->right();
   Token::Value op = node->op();
 
   // To make null checks efficient, we check if either left or right is the
   // literal 'null'. If so, we optimize the code by inlining a null check
   // instead of calling the (very) general runtime routine for checking
@@ skipping 38 matching lines @@
   // 'typeof <expression> == <string>'.
   UnaryOperation* operation = left->AsUnaryOperation();
   if ((op == Token::EQ || op == Token::EQ_STRICT) &&
       (operation != NULL && operation->op() == Token::TYPEOF) &&
       (right->AsLiteral() != NULL &&
        right->AsLiteral()->handle()->IsString())) {
     Handle<String> check(String::cast(*right->AsLiteral()->handle()));
 
     // Load the operand and move it to register edx.
     LoadTypeofExpression(operation->expression());
+    frame_->SpillAll();
     frame_->EmitPop(edx);
 
     if (check->Equals(Heap::number_symbol())) {
       __ test(edx, Immediate(kSmiTagMask));
       true_target()->Branch(zero);
       __ mov(edx, FieldOperand(edx, HeapObject::kMapOffset));
       __ cmp(edx, Factory::heap_number_map());
       cc_reg_ = equal;
 
     } else if (check->Equals(Heap::string_symbol())) {
@@ skipping 189 matching lines @@
       cgen_->LoadFromSlot(slot, typeof_state);
       break;
     }
 
     case NAMED: {
       // TODO(1241834): Make sure that this it is safe to ignore the
       // distinction between expressions in a typeof and not in a typeof. If
       // there is a chance that reference errors can be thrown below, we
       // must distinguish between the two kinds of loads (typeof expression
       // loads must not throw a reference error).
+      frame->SpillAll();
       Comment cmnt(masm, "[ Load from named Property");
       Handle<String> name(GetName());
       Handle<Code> ic(Builtins::builtin(Builtins::LoadIC_Initialize));
       // Setup the name register.
       __ mov(ecx, name);
 
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       if (var != NULL) {
         ASSERT(var->is_global());
         frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
       } else {
         frame->CallCodeObject(ic, RelocInfo::CODE_TARGET, 0);
       }
       frame->EmitPush(eax);  // IC call leaves result in eax, push it out
       break;
     }
 
     case KEYED: {
       // TODO(1241834): Make sure that this it is safe to ignore the
       // distinction between expressions in a typeof and not in a typeof.
+      frame->SpillAll();
       Comment cmnt(masm, "[ Load from keyed Property");
       Property* property = expression_->AsProperty();
       ASSERT(property != NULL);
       __ RecordPosition(property->position());
       Handle<Code> ic(Builtins::builtin(Builtins::KeyedLoadIC_Initialize));
 
       Variable* var = expression_->AsVariableProxy()->AsVariable();
       if (var != NULL) {
         ASSERT(var->is_global());
         frame->CallCodeObject(ic, RelocInfo::CODE_TARGET_CONTEXT, 0);
@@ skipping 1434 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal