Enable register allocation for return statements. Make sure to...

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 65 matching lines @@
                              bool is_eval)
     : is_eval_(is_eval),
       script_(script),
       deferred_(8),
       masm_(new MacroAssembler(NULL, buffer_size)),
       scope_(NULL),
       frame_(NULL),
       allocator_(NULL),
       cc_reg_(no_condition),
       state_(NULL),
-      is_inside_try_(false),
       break_stack_height_(0),
       loop_nesting_(0),
       function_return_is_shadowed_(false),
       in_spilled_code_(false) {
 }
 
 
 void CodeGenerator::SetFrame(VirtualFrame* new_frame) {
   if (has_valid_frame()) {
     frame_->DetachFromCodeGenerator();
@@ skipping 1523 matching lines @@
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ BreakStatement");
   CodeForStatement(node);
   CleanStack(break_stack_height_ - node->target()->break_stack_height());
   node->target()->break_target()->Jump();
 }
 
 
 void CodeGenerator::VisitReturnStatement(ReturnStatement* node) {
   ASSERT(!in_spilled_code());
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ ReturnStatement");
-  CodeForStatement(node);
-  LoadAndSpill(node->expression());
 
-  // Move the function result into eax
-  frame_->EmitPop(eax);
-
-  // If we're inside a try statement or the return instruction
-  // sequence has been generated, we just jump to that
-  // point. Otherwise, we generate the return instruction sequence and
-  // bind the function return label.
-  if (is_inside_try_ || function_return_.is_bound()) {
+  if (function_return_is_shadowed_) {
+    // If the function return is shadowed, we spill all information
+    // and just jump to the label.
+    VirtualFrame::SpilledScope spilled_scope(this);
+    CodeForStatement(node);
+    LoadAndSpill(node->expression());
+    frame_->EmitPop(eax);
     function_return_.Jump();
   } else {
-    function_return_.Bind();
-    if (FLAG_trace) {
-      frame_->EmitPush(eax);  // undo the pop(eax) from above
-      frame_->CallRuntime(Runtime::kTraceExit, 1);
+    // Load the returned value.
+    CodeForStatement(node);
+    Load(node->expression());
+
+    // Pop the result from the frame and prepare the frame for
+    // returning thus making it easier to merge.
+    Result result = frame_->Pop();
+    frame_->PrepareForReturn();
+
+    // Move the result into register eax where it belongs.
+    result.ToRegister(eax);
+    result.Unuse();

[Kevin Millikin (Chromium), 2009/01/07 10:25:12]

Since the reference to eax is live in the next basic block, it should be passed
to Jump or Bind.

+
+    // If the function return label is already bound, we reuse the
+    // code by jumping to the return site.
+    if (function_return_.is_bound()) {
+      function_return_.Jump();
+    } else {
+      function_return_.Bind();
+      if (FLAG_trace) {
+        frame_->EmitPush(eax);  // Materialize result on the stack.

[Kevin Millikin (Chromium), 2009/01/07 10:25:12]

EmitPush assumes the frame is spilled.  This should be a plain Push of the
result.

+        frame_->CallRuntime(Runtime::kTraceExit, 1);
+      }
+
+      // 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);
+      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));
     }
-
-    // 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);
-    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) {
   ASSERT(!in_spilled_code());
   Comment cmnt(masm_, "[ WithEnterStatement");
   CodeForStatement(node);
   Load(node->expression());
   Result context(this);
@@ skipping 628 matching lines @@
 
   // Shadow the jump targets for all escapes from the try block, including
   // returns.  During shadowing, the original target is hidden as the
   // ShadowTarget and operations on the original actually affect the
   // shadowing target.
   //
   // We should probably try to unify the escaping targets and the return
   // target.
   int nof_escapes = node->escaping_targets()->length();
   List<ShadowTarget*> shadows(1 + nof_escapes);
+
+  // Add the shadow target for the function return.
+  static const int kReturnShadowIndex = 0;
   shadows.Add(new ShadowTarget(&function_return_));
+  bool function_return_was_shadowed = function_return_is_shadowed_;
+  function_return_is_shadowed_ = true;
+  ASSERT(shadows[kReturnShadowIndex]->original_target() == &function_return_);
+
+  // Add the remaining shadow targets.
   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.
-  { TempAssign<bool> temp(&is_inside_try_, true);
-    VisitStatementsAndSpill(node->try_block()->statements());
-  }
+  VisitStatementsAndSpill(node->try_block()->statements());
 
   // 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++;
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
@@ skipping 36 matching lines @@
       // break from (eg, for...in) may have left stuff on the stack.
       __ mov(edx, Operand::StaticVariable(handler_address));
       const int kNextOffset = StackHandlerConstants::kNextOffset +
           StackHandlerConstants::kAddressDisplacement;
       __ lea(esp, Operand(edx, kNextOffset));
       frame_->Forget(frame_->height() - handler_height);
 
       frame_->EmitPop(Operand::StaticVariable(handler_address));
       frame_->Drop(StackHandlerConstants::kSize / kPointerSize - 1);
       // next_sp popped.
+
+      if (!function_return_is_shadowed_ && i == kReturnShadowIndex) {
+        frame_->PrepareForReturn();
+      }
       shadows[i]->original_target()->Jump();
     }
   }
 
   exit.Bind();
 }
 
 
 void CodeGenerator::VisitTryFinally(TryFinally* node) {
   ASSERT(!in_spilled_code());
@@ skipping 26 matching lines @@
 
   // Shadow the jump targets for all escapes from the try block, including
   // returns.  During shadowing, the original target is hidden as the
   // ShadowTarget and operations on the original actually affect the
   // shadowing target.
   //
   // We should probably try to unify the escaping targets and the return
   // target.
   int nof_escapes = node->escaping_targets()->length();
   List<ShadowTarget*> shadows(1 + nof_escapes);
+
+  // Add the shadow target for the function return.
+  static const int kReturnShadowIndex = 0;
   shadows.Add(new ShadowTarget(&function_return_));
+  bool function_return_was_shadowed = function_return_is_shadowed_;
+  function_return_is_shadowed_ = true;
+  ASSERT(shadows[kReturnShadowIndex]->original_target() == &function_return_);
+
+  // Add the remaining shadow targets.
   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.
-  { TempAssign<bool> temp(&is_inside_try_, true);
-    VisitStatementsAndSpill(node->try_block()->statements());
-  }
+  VisitStatementsAndSpill(node->try_block()->statements());
 
   // 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++;
   }
   function_return_is_shadowed_ = function_return_was_shadowed;
 
   // If we can fall off the end of the try block, set the state on the stack
   // to FALLING.
   if (has_valid_frame()) {
     frame_->EmitPush(Immediate(Factory::undefined_value()));  // fake TOS
     __ Set(ecx, Immediate(Smi::FromInt(FALLING)));
     if (nof_unlinks > 0) {
       unlink.Jump();
     }
   }
 
   // Generate code to set the state for the (formerly) shadowing targets that
   // have been jumped to.
   for (int i = 0; i <= nof_escapes; i++) {
     if (shadows[i]->is_linked()) {
-      // Because we can be jumping here (to spilled code) from unspilled
-      // code, we need to reestablish a spilled frame at this block.
+      // Because we can be jumping here (to spilled code) from
+      // unspilled code, we need to reestablish a spilled frame at
+      // this block.
       shadows[i]->Bind();
       frame_->SpillAll();
-      if (shadows[i]->original_target() == &function_return_) {
-        // If this target shadowed the function return, materialize the
-        // return value on the stack.
+      if (i == kReturnShadowIndex) {
+        // If this target shadowed the function return, materialize
+        // the return value on the stack.
         frame_->EmitPush(eax);
       } else {
         // Fake TOS for targets that shadowed breaks and continues.
         frame_->EmitPush(Immediate(Factory::undefined_value()));
       }
       __ Set(ecx, Immediate(Smi::FromInt(JUMPING + i)));
       unlink.Jump();
     }
   }
 
@@ skipping 32 matching lines @@
   VisitStatementsAndSpill(node->finally_block()->statements());
 
   break_stack_height_ -= kFinallyStackSize;
   if (has_valid_frame()) {
     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.
+    // formerly shadowing targets.
     for (int i = 0; i <= nof_escapes; i++) {
       if (shadows[i]->is_bound()) {
+        JumpTarget* original = shadows[i]->original_target();
         __ cmp(Operand(ecx), Immediate(Smi::FromInt(JUMPING + i)));
-        shadows[i]->original_target()->Branch(equal);
+        if (!function_return_is_shadowed_ && i == kReturnShadowIndex) {
+          JumpTarget skip(this);
+          skip.Branch(not_equal);
+          frame_->PrepareForReturn();
+          original->Jump();
+          skip.Bind();
+        } else {
+          original->Branch(equal);
+        }
       }
     }
 
     // Check if we need to rethrow the exception.
     __ cmp(Operand(ecx), Immediate(Smi::FromInt(THROWING)));
     exit.Branch(not_equal);
 
     // Rethrow exception.
     frame_->EmitPush(eax);  // undo pop from above
     frame_->CallRuntime(Runtime::kReThrow, 1);
@@ skipping 1757 matching lines @@
     SmiComparison(cc, right->AsLiteral()->handle(), strict);
     return;
   }
 
   Load(left);
   Load(right);
   Comparison(cc, strict);
 }
 
 
-bool CodeGenerator::IsActualFunctionReturn(JumpTarget* target) {
-  return (target == &function_return_ && !function_return_is_shadowed_);
-}
-
-
 #ifdef DEBUG
 bool CodeGenerator::HasValidEntryRegisters() {
-  return (allocator()->count(eax) - frame()->register_count(eax) == 0)
-      && (allocator()->count(ebx) - frame()->register_count(ebx) == 0)
-      && (allocator()->count(ecx) - frame()->register_count(ecx) == 0)
-      && (allocator()->count(edx) - frame()->register_count(edx) == 0)
-      && (allocator()->count(edi) - frame()->register_count(edi) == 0);
+  return (allocator()->count(eax) == frame()->register_count(eax))
+      && (allocator()->count(ebx) == frame()->register_count(ebx))
+      && (allocator()->count(ecx) == frame()->register_count(ecx))
+      && (allocator()->count(edx) == frame()->register_count(edx))
+      && (allocator()->count(edi) == frame()->register_count(edi));
 }
 #endif
 
 
 class DeferredReferenceGetKeyedValue: public DeferredCode {
  public:
   DeferredReferenceGetKeyedValue(CodeGenerator* generator, bool is_global)
       : DeferredCode(generator), is_global_(is_global) {
     set_comment("[ DeferredReferenceGetKeyedValue");
   }
@@ skipping 1619 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal