Experimental: begin using the register allocator across entering and...

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 176 matching lines @@
 
       if (kDebug) {
         JumpTarget verified_true(this);
         // Verify eax and esi are the same in debug mode
         __ cmp(eax, Operand(esi));
         verified_true.Branch(equal);
         __ int3();
         verified_true.Bind();
       }
       // Update context local.
-      __ mov(frame_->Context(), esi);
+      frame_->SaveContextRegister();
     }
 
     // TODO(1241774): Improve this code:
     // 1) only needed if we have a context
     // 2) no need to recompute context ptr every single time
     // 3) don't copy parameter operand code from SlotOperand!
     {
       Comment cmnt2(masm_, "[ copy context parameters into .context");
 
       // Note that iteration order is relevant here! If we have the same
@@ skipping 1136 matching lines @@
   }
 
   // Record the position for debugging purposes.
   CodeForSourcePosition(position);
 
   // Use the shared code stub to call the function.
   CallFunctionStub call_function(arg_count);
   frame_->CallStub(&call_function, arg_count + 1);
 
   // Restore context and pop function from the stack.
-  __ mov(esi, frame_->Context());
+  frame_->RestoreContextRegister();
   __ mov(frame_->Top(), eax);
 }
 
 
 void CodeGenerator::Branch(bool if_true, JumpTarget* target) {
   ASSERT(has_cc());
   Condition cc = if_true ? cc_reg_ : NegateCondition(cc_reg_);
   target->Branch(cc);
   cc_reg_ = no_condition;
 }
@@ skipping 288 matching lines @@
     // 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());
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ WithEnterStatement");
   CodeForStatement(node);
-  LoadAndSpill(node->expression());
+  Load(node->expression());
+  Result context(this);
   if (node->is_catch_block()) {
-    frame_->CallRuntime(Runtime::kPushCatchContext, 1);
+    context = frame_->CallRuntime(Runtime::kPushCatchContext, 1);
   } else {
-    frame_->CallRuntime(Runtime::kPushContext, 1);
+    context = frame_->CallRuntime(Runtime::kPushContext, 1);
   }
 
   if (kDebug) {
     JumpTarget verified_true(this);
-    // Verify eax and esi are the same in debug mode
-    __ cmp(eax, Operand(esi));
-    verified_true.Branch(equal);
+    // Verify that the result of the runtime call and the esi register are
+    // the same in debug mode.
+    __ cmp(context.reg(), Operand(esi));

[William Hesse, 2009/01/06 12:04:08]

Can't context.Unuse() go directly after the cmp instruction?

[Kevin Millikin (Chromium), 2009/01/06 12:10:28]

Yes.  Fixed.

+    verified_true.Branch(equal, &context);
+    frame_->SpillAll();
     __ int3();
-    verified_true.Bind();
+    verified_true.Bind(&context);
   }
+  context.Unuse();
 
   // Update context local.
-  __ mov(frame_->Context(), esi);
+  frame_->SaveContextRegister();
 }
 
 
 void CodeGenerator::VisitWithExitStatement(WithExitStatement* node) {
   ASSERT(!in_spilled_code());
-  VirtualFrame::SpilledScope spilled_scope(this);
   Comment cmnt(masm_, "[ WithExitStatement");
   CodeForStatement(node);
   // Pop context.
   __ mov(esi, ContextOperand(esi, Context::PREVIOUS_INDEX));
   // Update context local.
-  __ mov(frame_->Context(), esi);
+  frame_->SaveContextRegister();
 }
 
 
 int CodeGenerator::FastCaseSwitchMaxOverheadFactor() {
     return kFastSwitchMaxOverheadFactor;
 }
 
 
 int CodeGenerator::FastCaseSwitchMinCaseCount() {
     return kFastSwitchMinCaseCount;
@@ skipping 927 matching lines @@
   }
 }
 
 
 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.
     VirtualFrame::SpilledScope spilled_scope(this);
-    frame_->EmitPush(frame_->Context());
+    frame_->EmitPush(esi);
     frame_->EmitPush(Immediate(slot->var()->name()));
 
     if (init_state == CONST_INIT) {
       // Same as the case for a normal store, but ignores attribute
       // (e.g. READ_ONLY) of context slot so that we can initialize const
       // properties (introduced via eval("const foo = (some expr);")). Also,
       // uses the current function context instead of the top context.
       //
       // Note that we must declare the foo upon entry of eval(), via a
       // context slot declaration, but we cannot initialize it at the same
@@ skipping 461 matching lines @@
       LoadAndSpill(args->at(i));
     }
 
     // Setup the receiver register and call the IC initialization code.
     Handle<Code> stub = (loop_nesting() > 0)
         ? ComputeCallInitializeInLoop(arg_count)
         : ComputeCallInitialize(arg_count);
     CodeForSourcePosition(node->position());
     frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET_CONTEXT,
                            arg_count + 1);
-    __ mov(esi, frame_->Context());
+    frame_->RestoreContextRegister();
 
     // Overwrite the function on the stack with the result.
     __ mov(frame_->Top(), eax);
 
   } else if (var != NULL && var->slot() != NULL &&
              var->slot()->type() == Slot::LOOKUP) {
     // ----------------------------------
     // JavaScript example: 'with (obj) foo(1, 2, 3)'  // foo is in obj
     // ----------------------------------
 
@@ skipping 28 matching lines @@
       for (int i = 0; i < arg_count; i++) {
         LoadAndSpill(args->at(i));
       }
 
       // Call the IC initialization code.
       Handle<Code> stub = (loop_nesting() > 0)
         ? ComputeCallInitializeInLoop(arg_count)
         : ComputeCallInitialize(arg_count);
       CodeForSourcePosition(node->position());
       frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
-      __ mov(esi, frame_->Context());
+      frame_->RestoreContextRegister();
 
       // Overwrite the function on the stack with the result.
       __ mov(frame_->Top(), eax);
 
     } else {
       // -------------------------------------------
       // JavaScript example: 'array[index](1, 2, 3)'
       // -------------------------------------------
 
       // Load the function to call from the property through a reference.
@@ skipping 107 matching lines @@
   __ mov(edx, FieldOperand(eax, FixedArray::kHeaderSize + kPointerSize));
   __ mov(frame_->ElementAt(arg_count), edx);
 
   // Call the function.
   CodeForSourcePosition(node->position());
 
   CallFunctionStub call_function(arg_count);
   frame_->CallStub(&call_function, arg_count + 1);
 
   // Restore context and pop function from the stack.
-  __ mov(esi, frame_->Context());
+  frame_->RestoreContextRegister();
   __ mov(frame_->Top(), eax);
 }
 
 
 void CodeGenerator::GenerateIsSmi(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 1);
   LoadAndSpill(args->at(0));
   frame_->EmitPop(eax);
   __ test(eax, Immediate(kSmiTagMask));
   cc_reg_ = zero;
@@ skipping 262 matching lines @@
   int arg_count = args->length();
   for (int i = 0; i < arg_count; i++) {
     LoadAndSpill(args->at(i));
   }
 
   if (function == NULL) {
     // Call the JS runtime function.
     Handle<Code> stub = ComputeCallInitialize(arg_count);
     __ Set(eax, Immediate(args->length()));
     frame_->CallCodeObject(stub, RelocInfo::CODE_TARGET, arg_count + 1);
-    __ mov(esi, frame_->Context());
+    frame_->RestoreContextRegister();
     __ mov(frame_->Top(), eax);
   } else {
     // Call the C runtime function.
     frame_->CallRuntime(function, arg_count);
     frame_->EmitPush(eax);
   }
 }
 
 
 void CodeGenerator::VisitUnaryOperation(UnaryOperation* node) {
@@ skipping 2201 matching lines @@
 
   // Slow-case: Go through the JavaScript implementation.
   __ bind(&slow);
   __ InvokeBuiltin(Builtins::INSTANCE_OF, JUMP_FUNCTION);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal