Experimental: three small codegen changes....

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 201 matching lines @@
 
 // Clear the dirty bits for the range of elements in [begin, end).
 void VirtualFrame::SyncRange(int begin, int end) {
   ASSERT(begin >= 0);
   ASSERT(end <= elements_.length());
   for (int i = begin; i < end; i++) {
     SyncElementAt(i);
   }
 }
 
+
 // Make the type of all elements be MEMORY.
 void VirtualFrame::SpillAll() {
   for (int i = 0; i < elements_.length(); i++) {
     SpillElementAt(i);
   }
 }
 
 
 void VirtualFrame::PrepareForCall(int frame_arg_count) {
   ASSERT(height() >= frame_arg_count);
@@ skipping 58 matching lines @@
     FrameElement element = elements_[i];
     if (element.is_constant() ||
         (element.is_register() &&
          frame_registers_.count(element.reg().code()) > 1)) {
       // A simple strategy is to locate these elements in memory if they are
       // synced (avoiding a spill right now) and otherwise to prefer a
       // register for them.
       if (element.is_synced()) {
         new_elements[i] = memory_element;
       } else {
-        // This code path is currently not triggered.  UNIMPLEMENTED is
-        // temporarily used to trap when it becomes active so we can test
-        // it.
-        UNIMPLEMENTED();
         Register reg = cgen_->allocator()->AllocateWithoutSpilling();
         if (reg.is(no_reg)) {
           new_elements[i] = memory_element;
         } else {
           FrameElement register_element(reg, FrameElement::NOT_SYNCED);
           new_elements[i] = register_element;
         }
       }
 
       // We have not moved register references, but record that we will so
@@ skipping 90 matching lines @@
               ASSERT(!elements_[j].is_memory());
             }
 #endif
             stack_pointer_ = i + 1;
             __ add(Operand(esp),
                    Immediate((stack_pointer_ - i) * kPointerSize));
           }
           stack_pointer_--;
           __ pop(target.reg());
         }
-        Use(target.reg());
-      } else if (source.is_constant()) {
-        // Not yet implemented.  When done, code in common with the
-        // memory-to-register just above case can be factored out.
-        UNIMPLEMENTED();
+      } else {
+        // Source is constant.
+        __ Set(target.reg(), Immediate(source.handle()));
       }
+      Use(target.reg());
       elements_[i] = target;
     }
   }
 
+  // At this point, the frames should be identical.
   ASSERT(stack_pointer_ == expected->stack_pointer_);
+#ifdef DEBUG
+  for (int i = 0; i < elements_.length(); i++) {
+    FrameElement expect = expected->elements_[i];
+    if (expect.is_memory()) {
+      ASSERT(elements_[i].is_memory());
+      ASSERT(elements_[i].is_synced() && expect.is_synced());
+    } else if (expect.is_register()) {
+      ASSERT(elements_[i].is_register());
+      ASSERT(elements_[i].reg().is(expect.reg()));
+      ASSERT(elements_[i].is_synced() == expect.is_synced());
+    } else {
+      ASSERT(expect.is_constant());
+      ASSERT(elements_[i].is_constant());
+      ASSERT(elements_[i].handle().location() ==
+             expect.handle().location());
+      ASSERT(elements_[i].is_synced() == expect.is_synced());
+    }
+  }
+#endif
 }
 
 
 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 and the function in the frame.
-  Push(esi);
-  // The frame owns the register reference now.
-  cgen_->allocator()->Unuse(esi);
+  // 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 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");
   // Record the location of the JS exit code for patching when setting
   // break point.
   __ RecordJSReturn();
@@ skipping 204 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal