[ic][ia32][x87] Don't push/pop value/slot/vector in store handlers.

src/ic/handler-compiler.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/ic/handler-compiler.h"
 
 #include "src/field-type.h"
 #include "src/ic/call-optimization.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/ic-inl.h"
@@ skipping 423 matching lines @@
 
 
 // TODO(verwaest): Cleanup. holder() is actually the receiver.
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreTransition(
     Handle<Map> transition, Handle<Name> name) {
   Label miss;
 
   // Ensure that the StoreTransitionStub we are going to call has the same
   // number of stack arguments. This means that we don't have to adapt them
   // if we decide to call the transition or miss stub.
-  STATIC_ASSERT(StoreWithVectorDescriptor::kStackArgumentsCount ==
+  STATIC_ASSERT(Descriptor::kStackArgumentsCount ==
                 StoreTransitionDescriptor::kStackArgumentsCount);
-  STATIC_ASSERT(StoreWithVectorDescriptor::kStackArgumentsCount == 0 ||
-                StoreWithVectorDescriptor::kStackArgumentsCount == 3);
-  STATIC_ASSERT(StoreWithVectorDescriptor::kParameterCount -
-                    StoreWithVectorDescriptor::kValue ==
+  STATIC_ASSERT(Descriptor::kStackArgumentsCount == 0 ||
+                Descriptor::kStackArgumentsCount == 3);
+  STATIC_ASSERT(Descriptor::kParameterCount - Descriptor::kValue ==
                 StoreTransitionDescriptor::kParameterCount -
                     StoreTransitionDescriptor::kValue);
-  STATIC_ASSERT(StoreWithVectorDescriptor::kParameterCount -
-                    StoreWithVectorDescriptor::kSlot ==
+  STATIC_ASSERT(Descriptor::kParameterCount - Descriptor::kSlot ==
                 StoreTransitionDescriptor::kParameterCount -
                     StoreTransitionDescriptor::kSlot);
-  STATIC_ASSERT(StoreWithVectorDescriptor::kParameterCount -
-                    StoreWithVectorDescriptor::kVector ==
+  STATIC_ASSERT(Descriptor::kParameterCount - Descriptor::kVector ==
                 StoreTransitionDescriptor::kParameterCount -
                     StoreTransitionDescriptor::kVector);
 
+  if (Descriptor::kPassLastArgsOnStack) {
+    __ LoadParameterFromStack<Descriptor>(value(), Descriptor::kValue);
+  }
+
   bool need_save_restore = IC::ShouldPushPopSlotAndVector(kind());
   if (need_save_restore) {
     PushVectorAndSlot();
   }
 
   // Check that we are allowed to write this.
   bool is_nonexistent = holder()->map() == transition->GetBackPointer();
   if (is_nonexistent) {
     // Find the top object.
     Handle<JSObject> last;
@@ skipping 72 matching lines @@
 
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreField(LookupIterator* it) {
   Label miss;
   DCHECK(it->representation().IsHeapObject());
 
   FieldType* field_type = *it->GetFieldType();
   bool need_save_restore = false;
   if (RequiresFieldTypeChecks(field_type)) {
     need_save_restore = IC::ShouldPushPopSlotAndVector(kind());
+    if (Descriptor::kPassLastArgsOnStack) {
+      __ LoadParameterFromStack<Descriptor>(value(), Descriptor::kValue);
+    }
     if (need_save_restore) PushVectorAndSlot();
     GenerateFieldTypeChecks(field_type, value(), &miss);
     if (need_save_restore) PopVectorAndSlot();
   }
 
   StoreFieldStub stub(isolate(), it->GetFieldIndex(), it->representation());
   GenerateTailCall(masm(), stub.GetCode());
 
   __ bind(&miss);
   if (need_save_restore) PopVectorAndSlot();
@@ skipping 13 matching lines @@
 }
 
 Handle<Code> NamedStoreHandlerCompiler::CompileStoreCallback(
     Handle<JSObject> object, Handle<Name> name,
     const CallOptimization& call_optimization, int accessor_index,
     Handle<Code> slow_stub) {
   if (FLAG_runtime_call_stats) {
     GenerateTailCall(masm(), slow_stub);
   }
   Register holder = Frontend(name);
+  if (Descriptor::kPassLastArgsOnStack) {
+    __ LoadParameterFromStack<Descriptor>(value(), Descriptor::kValue);
+  }
   GenerateApiAccessorCall(masm(), call_optimization, handle(object->map()),
                           receiver(), scratch2(), true, value(), holder,
                           accessor_index);
   return GetCode(kind(), name);
 }
 
 
 #undef __
 
 // static
@@ skipping 53 matching lines @@
 }
 
 void ElementHandlerCompiler::CompileElementHandlers(
     MapHandleList* receiver_maps, List<Handle<Object>>* handlers) {
   for (int i = 0; i < receiver_maps->length(); ++i) {
     handlers->Add(GetKeyedLoadHandler(receiver_maps->at(i), isolate()));
   }
 }
 }  // namespace internal
 }  // namespace v8