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

src/virtual-frame-ia32.cc

 // Copyright 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 572 matching lines @@
 
 
 void VirtualFrame::Enter() {
   // Registers live on entry: esp, ebp, esi, edi.
   Comment cmnt(masm_, "[ Enter JS frame");
   EmitPush(ebp);
 
   frame_pointer_ = stack_pointer_;
   __ mov(ebp, Operand(esp));
 
-  // Store the context in the frame.  The context is kept in esi, so the
-  // register reference is not owned by the frame (ie, the frame is not free
-  // to spill it).  This is implemented by making the in-frame value be
-  // memory.
-  EmitPush(esi);
+  // Store the context in the frame.  The context is kept in esi and a
+  // copy is stored in the frame.  The external reference to esi
+  // remains in addition to the cached copy in the frame.
+  Push(esi);
 
   // Store the function in the frame.  The frame owns the register reference
   // now (ie, it can keep it in edi or spill it later).
   Push(edi);
   cgen_->allocator()->Unuse(edi);
 }
 
 
 void VirtualFrame::Exit() {
   Comment cmnt(masm_, "[ Exit JS frame");
@@ skipping 66 matching lines @@
     ASSERT(value->is_constant());
     elements_[frame_index] =
         FrameElement::ConstantElement(value->handle(),
                                       FrameElement::NOT_SYNCED);
   }
 
   value->Unuse();
 }
 
 
+void VirtualFrame::SaveContextRegister() {
+  FrameElement current = elements_[context_index()];
+  ASSERT(current.is_register() || current.is_memory());
+  if (!current.is_register() || !current.reg().is(esi)) {
+    if (current.is_register()) {
+      Unuse(current.reg());
+    }
+    Use(esi);
+    elements_[context_index()] =
+        FrameElement::RegisterElement(esi, FrameElement::NOT_SYNCED);
+  }
+}
+
+
+void VirtualFrame::RestoreContextRegister() {
+  FrameElement current = elements_[context_index()];
+  ASSERT(current.is_register() || current.is_memory());
+  if (current.is_register() && !current.reg().is(esi)) {
+    Unuse(current.reg());
+    Use(esi);
+    __ mov(esi, current.reg());
+    elements_[context_index()] =
+        FrameElement::RegisterElement(esi, FrameElement::NOT_SYNCED);
+  } else if (current.is_memory()) {
+    Use(esi);
+    __ mov(esi, Operand(ebp, fp_relative(context_index())));
+    elements_[context_index()] =
+        FrameElement::RegisterElement(esi, FrameElement::SYNCED);
+  }
+}
+
+
 void VirtualFrame::LoadFrameSlotAt(int index) {
   ASSERT(index >= 0);
   ASSERT(index < elements_.length());
 
   FrameElement element = elements_[index];
 
   if (element.is_memory()) {
     ASSERT(index <= stack_pointer_);
     // Eagerly load memory elements into a register.  The element at
     // the index and the new top of the frame are backed by the same
@@ skipping 105 matching lines @@
                               int frame_arg_count) {
   arg0->Unuse();
   arg1->Unuse();
   CallStub(stub, frame_arg_count);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
-void VirtualFrame::CallRuntime(Runtime::Function* f, int frame_arg_count) {
+Result VirtualFrame::CallRuntime(Runtime::Function* f,
+                                 int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallRuntime(f, frame_arg_count);
+  Result result = cgen_->allocator()->Allocate(eax);
+  ASSERT(result.is_valid());
+  return result;
 }
 
 
-void VirtualFrame::CallRuntime(Runtime::FunctionId id, int frame_arg_count) {
+Result VirtualFrame::CallRuntime(Runtime::FunctionId id,
+                                 int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ CallRuntime(id, frame_arg_count);
+  Result result = cgen_->allocator()->Allocate(eax);
+  ASSERT(result.is_valid());
+  return result;
 }
 
 
 void VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
                                  InvokeFlag flag,
                                  int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ InvokeBuiltin(id, flag);
 }
@@ skipping 132 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal