Experimental: three small codegen 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 251 matching lines @@
         frame_->CallRuntime(Runtime::kDebugTrace, 0);
         // Ignore the return value.
       }
 #endif
       VisitStatements(body);
 
       // Generate a return statement if necessary.  A NULL frame indicates
       // that control flow leaves the body on all paths and cannot fall
       // through.
       if (frame_ != NULL) {
+        frame_->SpillAll();
         Literal undefined(Factory::undefined_value());
         ReturnStatement statement(&undefined);
         statement.set_statement_pos(fun->end_position());
         VisitReturnStatement(&statement);
       }
     }
   }
 
   // Adjust for function-level loop nesting.
   loop_nesting_ -= fun->loop_nesting();
@@ skipping 187 matching lines @@
 
 void CodeGenerator::LoadReference(Reference* ref) {
   Comment cmnt(masm_, "[ LoadReference");
   Expression* e = ref->expression();
   Property* property = e->AsProperty();
   Variable* var = e->AsVariableProxy()->AsVariable();
 
   if (property != NULL) {
     // The expression is either a property or a variable proxy that rewrites
     // to a property.
+    frame_->SpillAll();
     Load(property->obj());
     frame_->SpillAll();
     // We use a named reference if the key is a literal symbol, unless it is
     // a string that can be legally parsed as an integer.  This is because
     // otherwise we will not get into the slow case code that handles [] on
     // String objects.
     Literal* literal = property->key()->AsLiteral();
     uint32_t dummy;
     if (literal != NULL &&
         literal->handle()->IsSymbol() &&
         !String::cast(*(literal->handle()))->AsArrayIndex(&dummy)) {
       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 758 matching lines @@
 
 
 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 273 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();
   }
@@ skipping 37 matching lines @@
       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 44 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;
 
+      // TODO(): Could frame_ be NULL here?
+      frame_->SpillAll();
       // If there is no update statement, label the top of the loop 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 (frame_ != NULL) {
+          frame_->SpillAll();
+        }
 
         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.
           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
             // after the code for the body actually belongs to the loop
             // statement and not the body.
             RecordStatementPosition(node);
             __ RecordPosition(node->statement_pos());
             ASSERT(node->type() == LoopStatement::FOR_LOOP);
             Visit(node->next());
+            // TODO(): Can frame_ actually be NULL here?
+            if (frame_ != NULL) {
+              frame_->SpillAll();
+            }
             loop.Jump();
           }
         }
       }
       break;
     }
   }
 
   DecrementLoopNesting();
   if (node->break_target()->is_linked()) {
@@ skipping 162 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