Experimental: more code generator changes....

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 72 matching lines @@
       allocator_(NULL),
       cc_reg_(no_condition),
       state_(NULL),
       is_inside_try_(false),
       break_stack_height_(0),
       loop_nesting_(0),
       function_return_is_shadowed_(false) {
 }
 
 
+void CodeGenerator::SetFrame(VirtualFrame* frame) {
+  if (frame_ != NULL) {
+    frame_->DetachFromCodeGenerator();
+  }
+  if (frame != NULL) {
+    frame->AttachToCodeGenerator();
+  }
+  frame_ = frame;
+}
+
+
+void CodeGenerator::DeleteFrame() {
+  if (frame_ != NULL) {
+    frame_->DetachFromCodeGenerator();
+    delete frame_;
+    frame_ = NULL;
+  }
+}
+
+
 // Calling conventions:
 // ebp: frame pointer
 // esp: stack pointer
 // edi: caller's parameter pointer
 // esi: callee's context
 
 void CodeGenerator::GenCode(FunctionLiteral* fun) {
   // Record the position for debugging purposes.
   __ RecordPosition(fun->start_position());
 
   ZoneList<Statement*>* body = fun->body();
 
   // Initialize state.
   ASSERT(scope_ == NULL);
   scope_ = fun->scope();
-  ASSERT(frame_ == NULL);
-  set_frame(new VirtualFrame(this));
   ASSERT(allocator_ == NULL);
   RegisterAllocator register_allocator(this);
   allocator_ = &register_allocator;
+  ASSERT(frame_ == NULL);
+  SetFrame(new VirtualFrame(this));
   cc_reg_ = no_condition;
   function_return_.set_code_generator(this);
   function_return_is_shadowed_ = false;
 
   // Adjust for function-level loop nesting.
   loop_nesting_ += fun->loop_nesting();
 
   {
     CodeGenState state(this);
 
@@ skipping 158 matching lines @@
   loop_nesting_ -= fun->loop_nesting();
 
   // Code generation state must be reset.
   ASSERT(state_ == NULL);
   ASSERT(loop_nesting() == 0);
   ASSERT(!function_return_is_shadowed_);
   function_return_.Unuse();
   ASSERT(!has_cc());
   // There is no need to delete the register allocator, it is a
   // stack-allocated local.
+  DeleteFrame();
   allocator_ = NULL;
-  delete_frame();
   scope_ = NULL;
 }
 
 
 Operand CodeGenerator::SlotOperand(Slot* slot, Register tmp) {
   // Currently, this assertion will fail if we try to assign to
   // a constant variable that is constant because it is read-only
   // (such as the variable referring to a named function expression).
   // We need to implement assignments to read-only variables.
   // Ideally, we should do this during AST generation (by converting
@@ skipping 187 matching lines @@
       ref->set_type(Reference::NAMED);
     } else {
       Load(property->key());
       frame_->SpillAll();
       ref->set_type(Reference::KEYED);
     }
   } else if (var != NULL) {
     // The expression is a variable proxy that does not rewrite to a
     // property.  Global variables are treated as named property references.
     if (var->is_global()) {
+      frame_->SpillAll();
       LoadGlobal();
       ref->set_type(Reference::NAMED);
     } else {
       ASSERT(var->slot() != NULL);
       ref->set_type(Reference::SLOT);
     }
   } else {
     // Anything else is a runtime error.
     Load(e);
     frame_->SpillAll();
@@ skipping 744 matching lines @@
 
 
 void CodeGenerator::CheckStack() {
   if (FLAG_check_stack) {
     JumpTarget stack_is_ok(this);
     StackCheckStub stub;
     ExternalReference stack_guard_limit =
         ExternalReference::address_of_stack_guard_limit();
     __ cmp(esp, Operand::StaticVariable(stack_guard_limit));
     stack_is_ok.Branch(above_equal, taken);
+    // The stack check can trigger the debugger.  Before calling it, all
+    // values including constants must be spilled to the frame.
+    frame_->SpillAll();
     frame_->CallStub(&stub, 0);
     stack_is_ok.Bind();
   }
 }
 
 
 void CodeGenerator::VisitStatements(ZoneList<Statement*>* statements) {
   for (int i = 0; frame_ != NULL && i < statements->length(); i++) {
     Visit(statements->at(i));
   }
 }
 
 
 void CodeGenerator::VisitBlock(Block* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ Block");
   RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->set_code_generator(this);
   VisitStatements(node->statements());
   if (node->break_target()->is_linked()) {
     node->break_target()->Bind();
   }
 }
 
@@ skipping 74 matching lines @@
 
 
 void CodeGenerator::VisitExpressionStatement(ExpressionStatement* node) {
   Comment cmnt(masm_, "[ ExpressionStatement");
   RecordStatementPosition(node);
   Expression* expression = node->expression();
   expression->MarkAsStatement();
   Load(expression);
   // Remove the lingering expression result from the top of stack.
   frame_->Drop();
-  // Rather than using SpillAll after all recursive calls to Visit over
-  // statements, we spill here in the only statement type that uses the
-  // virtual frame.  This is temporary.
-  frame_->SpillAll();
 }
 
 
 void CodeGenerator::VisitEmptyStatement(EmptyStatement* node) {
   frame_->SpillAll();
   Comment cmnt(masm_, "// EmptyStatement");
   // nothing to do
 }
 
 
@@ skipping 22 matching lines @@
       // If control flow can reach the then part via fall-through from the
       // test or a branch to the target, compile it.
       then.Bind();
       Visit(node->then_statement());
     }
     if (frame_ != NULL) {
       // A NULL frame here indicates that control did not fall out of the
       // then statement, it escaped on all branches.  In that case, a jump
       // to the exit label would be dead code (and impossible, because we
       // don't have a current virtual frame to set at the exit label).
+      frame_->SpillAll();
       exit.Jump();
     }
     // else
     if (else_.is_linked()) {
       // Control flow for if-then-else does not fall-through to the else
       // part, it can only reach here via jump if at all.
       else_.Bind();
       Visit(node->else_statement());
     }
 
@@ skipping 96 matching lines @@
     }
 
     // Add a label for checking the size of the code used for returning.
     Label check_exit_codesize;
     __ bind(&check_exit_codesize);
 
     // Leave the frame and return popping the arguments and the
     // receiver.
     frame_->Exit();
     __ ret((scope_->num_parameters() + 1) * kPointerSize);
-    delete_frame();
+    DeleteFrame();
 
     // Check that the size of the code used for returning matches what is
     // expected by the debugger.
     ASSERT_EQ(Debug::kIa32JSReturnSequenceLength,
               __ SizeOfCodeGeneratedSince(&check_exit_codesize));
   }
 }
 
 
 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* node) {
@@ skipping 156 matching lines @@
       default_exit.Bind();
     } else {
       fall_through.Bind();
       fall_through.Unuse();
     }
     VisitStatements(clause->statements());
 
     // If control flow can fall through from the body, jump to the next body
     // or the end of the statement.
     if (frame_ != NULL) {
+      frame_->SpillAll();
       if (i < length - 1 && cases->at(i + 1)->is_default()) {
         default_entry.Jump();
       } else {
         fall_through.Jump();
       }
     }
   }
 
   // The final "test" removes the switch value.
   next_test.Bind();
   frame_->Drop();
 
   // If there is a default clause, compile it.
   if (default_clause != NULL) {
     Comment cmnt(masm_, "[ Default clause");
     default_entry.Bind();
     VisitStatements(default_clause->statements());
+    if (frame_ != NULL) {
+      frame_->SpillAll();
+    }
     // If control flow can fall out of the default and there is a case after
     // it, jump to that case's body.
     if (frame_ != NULL && default_exit.is_bound()) {
       default_exit.Jump();
     }
   }
 
   if (fall_through.is_linked()) {
     fall_through.Bind();
   }
 
   if (node->break_target()->is_linked()) {
     node->break_target()->Bind();
   }
 }
 
 
 void CodeGenerator::VisitLoopStatement(LoopStatement* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ LoopStatement");
   RecordStatementPosition(node);
   node->set_break_stack_height(break_stack_height_);
   node->break_target()->set_code_generator(this);
   node->continue_target()->set_code_generator(this);
 
   // Simple condition analysis.  ALWAYS_TRUE and ALWAYS_FALSE represent a
   // known result for the test expression, with no side effects.
   enum { ALWAYS_TRUE, ALWAYS_FALSE, DONT_KNOW } info = DONT_KNOW;
   if (node->cond() == NULL) {
     ASSERT(node->type() == LoopStatement::FOR_LOOP);
     info = ALWAYS_TRUE;
   } else {
     Literal* lit = node->cond()->AsLiteral();
     if (lit != NULL) {
       if (lit->IsTrue()) {
         info = ALWAYS_TRUE;
       } else if (lit->IsFalse()) {
         info = ALWAYS_FALSE;
       }
     }
   }
 
   switch (node->type()) {
     case LoopStatement::DO_LOOP: {
+      // The new code generator does not yet compile do loops.
+      frame_->SpillAll();
       JumpTarget body(this);
       IncrementLoopNesting();
       // Label the body.
       if (info == ALWAYS_TRUE) {
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // There is no need, we will never jump back.
       } else {
         ASSERT(info == DONT_KNOW);
         body.Bind();
       }
       CheckStack();  // TODO(1222600): ignore if body contains calls.
       Visit(node->body());
+      if (frame_ != NULL) {
+        frame_->SpillAll();
+      }
 
       // Compile the "test".
       if (info == ALWAYS_TRUE) {
         if (frame_ != NULL) {
           // If control flow can fall off the end of the body, jump back to
           // the top.
           node->continue_target()->Jump();
         }
       } else if (info == ALWAYS_FALSE) {
         // If we have a continue in the body, we only have to bind its jump
@@ skipping 13 matching lines @@
             // A NULL frame here indicates that control flow did not fall
             // out of the test expression.
             Branch(true, &body);
           }
         }
       }
       break;
     }
 
     case LoopStatement::WHILE_LOOP: {
+      // The new code generator does not yet compile while loops.
+      frame_->SpillAll();
       JumpTarget body(this);
       IncrementLoopNesting();
       // Generate the loop header.
       if (info == ALWAYS_TRUE) {
         // Merely label the body with the continue target.
         node->continue_target()->Bind();
       } else if (info == ALWAYS_FALSE) {
         // There is no need to even compile the test or body.
         break;
       } else {
@@ skipping 11 matching lines @@
         if (frame_ != NULL || body.is_linked()) {
           body.Bind();
         }
       }
       if (frame_ != NULL) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         // If control flow can fall out of the body, jump back to the top.
         if (frame_ != NULL) {
+          frame_->SpillAll();
           node->continue_target()->Jump();
         }
       }
       break;
     }
 
     case LoopStatement::FOR_LOOP: {
       JumpTarget loop(this);
       JumpTarget body(this);
       if (node->init() != NULL) {
         Visit(node->init());
       }
 
       IncrementLoopNesting();
       // There is no need to compile the test or body.
       if (info == ALWAYS_FALSE) break;
 
-      // If there is no update statement, label the top of the loop with the
-      // continue target, otherwise with the loop target.
+      // Label the top of the loop for the backward CFG edge.  If there is
+      // no update expression label it with the continue target, otherwise
+      // with the loop target.
       if (node->next() == NULL) {
         node->continue_target()->Bind();
       } else {
         loop.Bind();
       }
 
       // If the test is always true, there is no need to compile it.
       if (info == DONT_KNOW) {
         LoadCondition(node->cond(), NOT_INSIDE_TYPEOF,
                       &body, node->break_target(), true);
         if (frame_ != NULL) {
           Branch(false, node->break_target());
         }
         if (frame_ != NULL || body.is_linked()) {
           body.Bind();
         }
       }
 
       if (frame_ != NULL) {
         CheckStack();  // TODO(1222600): ignore if body contains calls.
         Visit(node->body());
 
         if (node->next() == NULL) {
           // If there is no update statement and control flow can fall out
-          // of the loop, jump directly to the continue label.
+          // of the loop, jump to the continue label.
           if (frame_ != NULL) {
             node->continue_target()->Jump();
           }
         } else {
           // If there is an update statement and control flow can reach it
           // via falling out of the body of the loop or continuing, we
           // compile the update statement.
           if (frame_ != NULL || node->continue_target()->is_linked()) {
             node->continue_target()->Bind();
             // Record source position of the statement as this code which is
@@ skipping 178 matching lines @@
       }
     }
   }
   // Discard the i'th entry pushed above or else the remainder of the
   // reference, whichever is currently on top of the stack.
   frame_->Drop();
 
   // Body.
   CheckStack();  // TODO(1222600): ignore if body contains calls.
   Visit(node->body());
+  if (frame_ != NULL) {
+    frame_->SpillAll();
+  }
 
   // Next.
   node->continue_target()->Bind();
   frame_->EmitPop(eax);
   __ add(Operand(eax), Immediate(Smi::FromInt(1)));
   frame_->EmitPush(eax);
   entry.Jump();
 
   // Cleanup.
   cleanup.Bind();
@@ skipping 25 matching lines @@
     // convenient property that it doesn't matter whether a value is
     // immediately on top of or underneath a zero-sized reference.
     ref.SetValue(NOT_CONST_INIT);
   }
 
   // Remove the exception from the stack.
   frame_->Drop();
 
   VisitStatements(node->catch_block()->statements());
   if (frame_ != NULL) {
+    frame_->SpillAll();
     exit.Jump();
   }
 
 
   // --- Try block ---
   try_block.Bind();
 
   frame_->PushTryHandler(TRY_CATCH_HANDLER);
   int handler_height = frame_->height();
 
@@ skipping 10 matching lines @@
   for (int i = 0; i < nof_escapes; i++) {
     shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
   }
   bool function_return_was_shadowed = function_return_is_shadowed_;
   function_return_is_shadowed_ = true;
 
   // Generate code for the statements in the try block.
   bool was_inside_try = is_inside_try_;
   is_inside_try_ = true;
   VisitStatements(node->try_block()->statements());
+  if (frame_ != NULL) {
+    frame_->SpillAll();
+  }
   is_inside_try_ = was_inside_try;
 
   // Stop the introduced shadowing and count the number of required unlinks.
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   int nof_unlinks = 0;
   for (int i = 0; i <= nof_escapes; i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
@@ skipping 88 matching lines @@
   for (int i = 0; i < nof_escapes; i++) {
     shadows.Add(new ShadowTarget(node->escaping_targets()->at(i)));
   }
   bool function_return_was_shadowed = function_return_is_shadowed_;
   function_return_is_shadowed_ = true;
 
   // Generate code for the statements in the try block.
   bool was_inside_try = is_inside_try_;
   is_inside_try_ = true;
   VisitStatements(node->try_block()->statements());
+  if (frame_ != NULL) {
+    frame_->SpillAll();
+  }
   is_inside_try_ = was_inside_try;
 
   // Stop the introduced shadowing and count the number of required unlinks.
   // After shadowing stops, the original targets are unshadowed and the
   // ShadowTargets represent the formerly shadowing targets.
   int nof_unlinks = 0;
   for (int i = 0; i <= nof_escapes; i++) {
     shadows[i]->StopShadowing();
     if (shadows[i]->is_linked()) nof_unlinks++;
   }
@@ skipping 56 matching lines @@
   // that a break/continue crossing this statement can restore the
   // stack.
   const int kFinallyStackSize = 2 * kPointerSize;
   break_stack_height_ += kFinallyStackSize;
 
   // Generate code for the statements in the finally block.
   VisitStatements(node->finally_block()->statements());
 
   break_stack_height_ -= kFinallyStackSize;
   if (frame_ != NULL) {
+    frame_->SpillAll();
     JumpTarget exit(this);
     // Restore state and return value or faked TOS.
     frame_->EmitPop(ecx);
     frame_->EmitPop(eax);
 
     // Generate code to jump to the right destination for all used
     // (formerly) shadowing targets.
     for (int i = 0; i <= nof_escapes; i++) {
       if (shadows[i]->is_bound()) {
         __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
@@ skipping 484 matching lines @@
 
 
 bool CodeGenerator::IsInlineSmi(Literal* literal) {
   if (literal == NULL || !literal->handle()->IsSmi()) return false;
   int int_value = Smi::cast(*literal->handle())->value();
   return is_intn(int_value, kMaxSmiInlinedBits);
 }
 
 
 void CodeGenerator::VisitAssignment(Assignment* node) {
-  frame_->SpillAll();
   Comment cmnt(masm_, "[ Assignment");
 
   RecordStatementPosition(node);
   { Reference target(this, node->target());
     if (target.is_illegal()) {
       // Fool the virtual frame into thinking that we left the assignment's
       // value on the frame.
       frame_->EmitPush(Immediate(Smi::FromInt(0)));
       return;
     }
 
     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);
       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 2604 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal