Remove spilled code from SetValue and GetValue

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 229 matching lines @@
 
 
 // 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);
+void VirtualFrame::PrepareForCall(int spilled_args, int dropped_args) {
+  ASSERT(height() >= dropped_args);
+  ASSERT(height() >= spilled_args);
+  ASSERT(dropped_args <= spilled_args);
 
   // 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;
+  int arg_base_index = elements_.length() - spilled_args;
   for (int i = 0; i < arg_base_index; i++) {
     FrameElement element = elements_[i];
     if (element.is_register()) {
       SpillElementAt(i);
     } else if (element.is_valid()) {
       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);
+  Forget(dropped_args);
 }
 
 
 void VirtualFrame::MakeMergable() {
   Comment cmnt(masm_, "[ Make frame mergable");
   // We should always be merging the code generator's current frame to an
   // expected frame.
   ASSERT(cgen_->frame() == this);
   ASSERT(cgen_->HasValidEntryRegisters());
 
@@ skipping 534 matching lines @@
   // pushed separately).
   Adjust(kHandlerSize - 2);
   __ PushTryHandler(IN_JAVASCRIPT, type);
   // TODO(1222589): remove the reliance of PushTryHandler on a cached TOS
   EmitPush(eax);
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub, int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
-  PrepareForCall(frame_arg_count);
+  PrepareForCall(frame_arg_count, frame_arg_count);
   __ CallStub(stub);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub,
                               Result* arg,
                               int frame_arg_count) {
   arg->Unuse();
   return CallStub(stub, frame_arg_count);
 }
 
 
 Result VirtualFrame::CallStub(CodeStub* stub,
                               Result* arg0,
                               Result* arg1,
                               int frame_arg_count) {
   arg0->Unuse();
   arg1->Unuse();
   return CallStub(stub, frame_arg_count);
 }
 
 
 Result VirtualFrame::CallRuntime(Runtime::Function* f,
                                  int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
-  PrepareForCall(frame_arg_count);
+  PrepareForCall(frame_arg_count, frame_arg_count);
   __ CallRuntime(f, frame_arg_count);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::CallRuntime(Runtime::FunctionId id,
                                  int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
-  PrepareForCall(frame_arg_count);
+  PrepareForCall(frame_arg_count, frame_arg_count);
   __ CallRuntime(id, frame_arg_count);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
 Result VirtualFrame::InvokeBuiltin(Builtins::JavaScript id,
                                    InvokeFlag flag,
                                    int frame_arg_count) {
   ASSERT(cgen_->HasValidEntryRegisters());
-  PrepareForCall(frame_arg_count);
+  PrepareForCall(frame_arg_count, 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) {
+Result VirtualFrame::RawCallCodeObject(Handle<Code> code,
+                                       RelocInfo::Mode rmode,
+                                       int spilled_args,
+                                       int dropped_args) {
   ASSERT(cgen_->HasValidEntryRegisters());
-  PrepareForCall(frame_arg_count);
+  PrepareForCall(spilled_args, dropped_args);
   __ call(code, rmode);
   Result result = cgen_->allocator()->Allocate(eax);
   ASSERT(result.is_valid());
   return result;
 }
 
 
+Result VirtualFrame::CallCodeObject(Handle<Code> code,
+                                    RelocInfo::Mode rmode,
+                                    int dropped_args) {
+  int spilled_args = 0;
+  switch (code->kind()) {
+    case Code::CALL_IC:
+      spilled_args = dropped_args + 1;
+      break;
+    case Code::FUNCTION:
+      spilled_args = dropped_args + 1;
+      break;
+    case Code::KEYED_LOAD_IC:
+      ASSERT(dropped_args == 0);
+      spilled_args = 2;
+      break;
+    default:
+      // The other types of code objects are called with values
+      // in specific registers, and are handled in functions with
+      // a different signature.
+      UNREACHABLE();
+      break;
+  }
+  return RawCallCodeObject(code, rmode, spilled_args, dropped_args);
+}
+
+
+Result VirtualFrame::CallCodeObject(Handle<Code> code,
+                                    RelocInfo::Mode rmode,
+                                    Result* arg,
+                                    int dropped_args) {
+  int spilled_args = 0;
+  switch (code->kind()) {
+    case Code::CALL_IC:
+      ASSERT(arg->reg().is(eax));
+      spilled_args = dropped_args + 1;
+      break;
+    case Code::LOAD_IC:
+      ASSERT(arg->reg().is(ecx));
+      ASSERT(dropped_args == 0);
+      spilled_args = 1;
+      break;
+    case Code::KEYED_STORE_IC:
+      ASSERT(arg->reg().is(eax));
+      ASSERT(dropped_args == 0);
+      spilled_args = 2;
+      break;
+    default:
+      // No other types of code objects are called with values
+      // in exactly one register.
+      UNREACHABLE();
+      break;
+  }
+  arg->Unuse();
+  return RawCallCodeObject(code, rmode, spilled_args, dropped_args);
+}
+
+
+Result VirtualFrame::CallCodeObject(Handle<Code> code,
+                                    RelocInfo::Mode rmode,
+                                    Result* arg0,
+                                    Result* arg1,
+                                    int dropped_args) {
+  int spilled_args = 1;
+  switch (code->kind()) {
+    case Code::STORE_IC:
+      ASSERT(arg0->reg().is(eax));
+      ASSERT(arg1->reg().is(ecx));
+      ASSERT(dropped_args == 0);
+      spilled_args = 1;
+      break;
+    case Code::BUILTIN:
+      ASSERT(*code == Builtins::builtin(Builtins::JSConstructCall));
+      ASSERT(arg0->reg().is(eax));
+      ASSERT(arg1->reg().is(edi));
+      spilled_args = dropped_args + 1;
+      break;
+    default:
+      // No other types of code objects are called with values
+      // in exactly two registers.
+      UNREACHABLE();
+      break;
+  }
+  arg0->Unuse();
+  arg1->Unuse();
+  return RawCallCodeObject(code, rmode, spilled_args, dropped_args);
+}
+
+
 void VirtualFrame::Drop(int count) {
   ASSERT(height() >= count);
   int num_virtual_elements = (elements_.length() - 1) - stack_pointer_;
 
   // Emit code to lower the stack pointer if necessary.
   if (num_virtual_elements < count) {
     int num_dropped = count - num_virtual_elements;
     stack_pointer_ -= num_dropped;
     __ add(Operand(esp), Immediate(num_dropped * kPointerSize));
   }
@@ skipping 119 matching lines @@
       return false;
     }
   }
   return true;
 }
 #endif
 
 #undef __
 
 } }  // namespace v8::internal