Use unspilled frames in unary operations.

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 232 matching lines @@
 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);
 
-  // Below the stack pointer, spill all registers and make sure that
-  // locals have the right values by sync'ing them. The sync'ing is
-  // necessary to give the debugger a consistent view of the values of
-  // locals in the frame.
-  for (int i = 0; i <= stack_pointer_; i++) {
+  // Below the arguments to the function being called, spill all registers and
+  // make sure that locals have the right values by synching them. The synching
+  // is necessary to give the debugger a consistent view of the values of
+  // locals in the frame.  Spill the arguments to the function being called.
+  int arg_base_index = elements_.length() - frame_arg_count;
+  for (int i = 0; i < arg_base_index; i++) {
     FrameElement element = elements_[i];
     if (element.is_register()) {
       SpillElementAt(i);
-    } else if (element.is_valid() && i < expression_base_index()) {
+    } else if (element.is_valid()) {
       SyncElementAt(i);
     }
   }
-
-  // Above the stack pointer, spill registers and sync everything else (ie,
-  // constants).
-  for (int i = stack_pointer_ + 1; i < elements_.length(); i++) {
-    if (elements_[i].is_register()) {
-      SpillElementAt(i);
-    } else {
-      SyncElementAt(i);
-    }
+  // The arguments are spilled.
+  for (int i = arg_base_index; i < elements_.length(); i++) {
+    SpillElementAt(i);
   }
 
   // Forget the frame elements that will be popped by the call.
   Forget(frame_arg_count);
 }
 
 
 bool VirtualFrame::RequiresMergeCode() {
   // A frame requires code to be generated to make the frame mergable if
   // there are duplicated non-synched registers or else valid elements not
@@ skipping 607 matching lines @@
                                  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) {
+Result VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
+                                   InvokeFlag flag,
+                                   int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ InvokeBuiltin(id, flag);
+  Result result = cgen_->allocator()->Allocate(eax);
+  ASSERT(result.is_valid());
+  return result;
 }
 
 
 Result VirtualFrame::CallCodeObject(Handle<Code> code,
                                     RelocInfo::Mode rmode,
                                     int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
   PrepareForCall(frame_arg_count);
   __ call(code, rmode);
   Result result = cgen_->allocator()->Allocate(eax);
@@ skipping 134 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal