X87: Reland VectorICs: ia32 store ics need a virtual register.

src/x87/code-stubs-x87.cc

 // Copyright 2012 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.
 
 #if V8_TARGET_ARCH_X87
 
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
@@ skipping 4229 matching lines @@
 
 // value is on the stack already.
 static void HandlePolymorphicStoreCase(MacroAssembler* masm, Register receiver,
                                        Register key, Register vector,
                                        Register slot, Register feedback,
                                        Label* miss) {
   // feedback initially contains the feedback array
   Label next, next_loop, prepare_next;
   Label load_smi_map, compare_map;
   Label start_polymorphic;
+  ExternalReference virtual_register =
+      ExternalReference::vector_store_virtual_register(masm->isolate());
 
   __ push(receiver);
   __ push(vector);
 
   Register receiver_map = receiver;
   Register cached_map = vector;
 
   // Receiver might not be a heap object.
   __ JumpIfSmi(receiver, &load_smi_map);
   __ mov(receiver_map, FieldOperand(receiver, 0));
   __ bind(&compare_map);
   __ mov(cached_map, FieldOperand(feedback, FixedArray::OffsetOfElementAt(0)));
 
   // A named keyed store might have a 2 element array, all other cases can count
   // on an array with at least 2 {map, handler} pairs, so they can go right
   // into polymorphic array handling.
   __ cmp(receiver_map, FieldOperand(cached_map, WeakCell::kValueOffset));
   __ j(not_equal, &start_polymorphic);
 
   // found, now call handler.
   Register handler = feedback;
   DCHECK(handler.is(VectorStoreICDescriptor::ValueRegister()));
   __ mov(handler, FieldOperand(feedback, FixedArray::OffsetOfElementAt(1)));
   __ pop(vector);
   __ pop(receiver);
   __ lea(handler, FieldOperand(handler, Code::kHeaderSize));
-  __ xchg(handler, Operand(esp, 0));
-  __ ret(0);
+  __ mov(Operand::StaticVariable(virtual_register), handler);
+  __ pop(handler);  // Pop "value".
+  __ jmp(Operand::StaticVariable(virtual_register));
 
   // Polymorphic, we have to loop from 2 to N
 
   // TODO(mvstanton): I think there is a bug here, we are assuming the
   // array has more than one map/handler pair, but we call this function in the
   // keyed store with a string key case, where it might be just an array of two
   // elements.
 
   __ bind(&start_polymorphic);
   __ push(key);
   Register counter = key;
   __ mov(counter, Immediate(Smi::FromInt(2)));
   __ bind(&next_loop);
   __ mov(cached_map, FieldOperand(feedback, counter, times_half_pointer_size,
                                   FixedArray::kHeaderSize));
   __ cmp(receiver_map, FieldOperand(cached_map, WeakCell::kValueOffset));
   __ j(not_equal, &prepare_next);
   __ mov(handler, FieldOperand(feedback, counter, times_half_pointer_size,
                                FixedArray::kHeaderSize + kPointerSize));
+  __ lea(handler, FieldOperand(handler, Code::kHeaderSize));
   __ pop(key);
   __ pop(vector);
   __ pop(receiver);
-  __ lea(handler, FieldOperand(handler, Code::kHeaderSize));
-  __ xchg(handler, Operand(esp, 0));
-  __ ret(0);
+  __ mov(Operand::StaticVariable(virtual_register), handler);
+  __ pop(handler);  // Pop "value".
+  __ jmp(Operand::StaticVariable(virtual_register));
 
   __ bind(&prepare_next);
   __ add(counter, Immediate(Smi::FromInt(2)));
   __ cmp(counter, FieldOperand(feedback, FixedArray::kLengthOffset));
   __ j(less, &next_loop);
 
   // We exhausted our array of map handler pairs.
   __ pop(key);
   __ pop(vector);
   __ pop(receiver);
   __ jmp(miss);
 
   __ bind(&load_smi_map);
   __ LoadRoot(receiver_map, Heap::kHeapNumberMapRootIndex);
   __ jmp(&compare_map);
 }
 
 
 static void HandleMonomorphicStoreCase(MacroAssembler* masm, Register receiver,
                                        Register key, Register vector,
                                        Register slot, Register weak_cell,
                                        Label* miss) {
   // The store ic value is on the stack.
   DCHECK(weak_cell.is(VectorStoreICDescriptor::ValueRegister()));
+  ExternalReference virtual_register =
+      ExternalReference::vector_store_virtual_register(masm->isolate());
 
   // feedback initially contains the feedback array
   Label compare_smi_map;
 
   // Move the weak map into the weak_cell register.
   Register ic_map = weak_cell;
   __ mov(ic_map, FieldOperand(weak_cell, WeakCell::kValueOffset));
 
   // Receiver might not be a heap object.
   __ JumpIfSmi(receiver, &compare_smi_map);
   __ cmp(ic_map, FieldOperand(receiver, 0));
   __ j(not_equal, miss);
   __ mov(weak_cell, FieldOperand(vector, slot, times_half_pointer_size,
                                  FixedArray::kHeaderSize + kPointerSize));
   __ lea(weak_cell, FieldOperand(weak_cell, Code::kHeaderSize));
   // Put the store ic value back in it's register.
-  __ xchg(weak_cell, Operand(esp, 0));
-  // "return" to the handler.
-  __ ret(0);
+  __ mov(Operand::StaticVariable(virtual_register), weak_cell);
+  __ pop(weak_cell);  // Pop "value".
+  // jump to the handler.
+  __ jmp(Operand::StaticVariable(virtual_register));
 
   // In microbenchmarks, it made sense to unroll this code so that the call to
   // the handler is duplicated for a HeapObject receiver and a Smi receiver.
   __ bind(&compare_smi_map);
   __ CompareRoot(ic_map, Heap::kHeapNumberMapRootIndex);
   __ j(not_equal, miss);
   __ mov(weak_cell, FieldOperand(vector, slot, times_half_pointer_size,
                                  FixedArray::kHeaderSize + kPointerSize));
   __ lea(weak_cell, FieldOperand(weak_cell, Code::kHeaderSize));
-  // Put the store ic value back in it's register.
-  __ xchg(weak_cell, Operand(esp, 0));
-  // "return" to the handler.
-  __ ret(0);
+  __ mov(Operand::StaticVariable(virtual_register), weak_cell);
+  __ pop(weak_cell);  // Pop "value".
+  // jump to the handler.
+  __ jmp(Operand::StaticVariable(virtual_register));
 }
 
 
 void VectorStoreICStub::GenerateImpl(MacroAssembler* masm, bool in_frame) {
   Register receiver = VectorStoreICDescriptor::ReceiverRegister();  // edx
   Register key = VectorStoreICDescriptor::NameRegister();           // ecx
   Register value = VectorStoreICDescriptor::ValueRegister();        // eax
   Register vector = VectorStoreICDescriptor::VectorRegister();      // ebx
   Register slot = VectorStoreICDescriptor::SlotRegister();          // edi
   Label miss;
@@ skipping 52 matching lines @@
 
 static void HandlePolymorphicKeyedStoreCase(MacroAssembler* masm,
                                             Register receiver, Register key,
                                             Register vector, Register slot,
                                             Register feedback, Label* miss) {
   // feedback initially contains the feedback array
   Label next, next_loop, prepare_next;
   Label load_smi_map, compare_map;
   Label transition_call;
   Label pop_and_miss;
+  ExternalReference virtual_register =
+      ExternalReference::vector_store_virtual_register(masm->isolate());
 
   __ push(receiver);
   __ push(vector);
 
   Register receiver_map = receiver;
   Register cached_map = vector;
 
   // Receiver might not be a heap object.
   __ JumpIfSmi(receiver, &load_smi_map);
   __ mov(receiver_map, FieldOperand(receiver, 0));
@@ skipping 16 matching lines @@
   __ mov(cached_map, FieldOperand(feedback, counter, times_half_pointer_size,
                                   FixedArray::kHeaderSize + kPointerSize));
   __ CompareRoot(cached_map, Heap::kUndefinedValueRootIndex);
   __ j(not_equal, &transition_call);
   __ mov(feedback, FieldOperand(feedback, counter, times_half_pointer_size,
                                 FixedArray::kHeaderSize + 2 * kPointerSize));
   __ pop(key);
   __ pop(vector);
   __ pop(receiver);
   __ lea(feedback, FieldOperand(feedback, Code::kHeaderSize));
-  __ xchg(feedback, Operand(esp, 0));
-  __ ret(0);
+  __ mov(Operand::StaticVariable(virtual_register), feedback);
+  __ pop(feedback);  // Pop "value".
+  __ jmp(Operand::StaticVariable(virtual_register));
 
   __ bind(&transition_call);
   // Oh holy hell this will be tough.
   // The map goes in vector register.
   __ mov(receiver, FieldOperand(cached_map, WeakCell::kValueOffset));
   // The weak cell may have been cleared.
   __ JumpIfSmi(receiver, &pop_and_miss);
   // slot goes on the stack, and holds return address.
   __ xchg(slot, Operand(esp, 4 * kPointerSize));
   // Get the handler in value.
@@ skipping 1007 matching lines @@
                            Operand(ebp, 7 * kPointerSize), NULL);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X87