Hydrogen code stubs for vector-based ICs.

src/ic/ia32/handler-compiler-ia32.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/v8.h"
 
 #if V8_TARGET_ARCH_IA32
 
 #include "src/ic/call-optimization.h"
 #include "src/ic/handler-compiler.h"
@@ skipping 29 matching lines @@
       masm->isolate()->heap()->SetGetterStubDeoptPCOffset(masm->pc_offset());
     }
 
     // Restore context register.
     __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset));
   }
   __ ret(0);
 }
 
 
+void PropertyHandlerCompiler::PushVectorAndSlot() {
+  MacroAssembler* masm = this->masm();
+  __ push(VectorLoadICDescriptor::VectorRegister());
+  __ push(VectorLoadICDescriptor::SlotRegister());
+}
+
+
+void PropertyHandlerCompiler::PopVectorAndSlot() {
+  MacroAssembler* masm = this->masm();
+  __ pop(VectorLoadICDescriptor::SlotRegister());
+  __ pop(VectorLoadICDescriptor::VectorRegister());
+}
+
+
+void PropertyHandlerCompiler::PushVectorAndSlot(Register vector,
+                                                Register slot) {
+  MacroAssembler* masm = this->masm();
+  __ push(vector);
+  __ push(slot);
+}
+
+
+void PropertyHandlerCompiler::PopVectorAndSlot(Register vector, Register slot) {
+  MacroAssembler* masm = this->masm();
+  __ pop(slot);
+  __ pop(vector);
+}
+
+
+void PropertyHandlerCompiler::DiscardVectorAndSlot() {
+  MacroAssembler* masm = this->masm();
+  __ add(esp, Immediate(2 * kPointerSize));  // remove vector and slot

[Jakob Kummerow, 2014/12/02 08:43:07]

nit: Capitalization and punctuation, please.

[mvstanton, 2014/12/03 11:48:30]

Done.

+}
+
+
 void PropertyHandlerCompiler::GenerateDictionaryNegativeLookup(
     MacroAssembler* masm, Label* miss_label, Register receiver,
     Handle<Name> name, Register scratch0, Register scratch1) {
   DCHECK(name->IsUniqueName());
   DCHECK(!receiver.is(scratch0));
   Counters* counters = masm->isolate()->counters();
   __ IncrementCounter(counters->negative_lookups(), 1);
   __ IncrementCounter(counters->negative_lookups_miss(), 1);
 
   __ mov(scratch0, FieldOperand(receiver, HeapObject::kMapOffset));
@@ skipping 43 matching lines @@
   // Load its initial map. The global functions all have initial maps.
   __ Move(prototype, Immediate(Handle<Map>(function->initial_map())));
   // Load the prototype from the initial map.
   __ mov(prototype, FieldOperand(prototype, Map::kPrototypeOffset));
 }
 
 
 void NamedLoadHandlerCompiler::GenerateLoadFunctionPrototype(
     MacroAssembler* masm, Register receiver, Register scratch1,
     Register scratch2, Label* miss_label) {
+  DCHECK(!FLAG_vector_ics);
   __ TryGetFunctionPrototype(receiver, scratch1, scratch2, miss_label);
   __ mov(eax, scratch1);
   __ ret(0);
 }
 
 
 // Generate call to api function.
 // This function uses push() to generate smaller, faster code than
 // the version above. It is an optimization that should will be removed
 // when api call ICs are generated in hydrogen.
@@ skipping 337 matching lines @@
   // Return the register containing the holder.
   return reg;
 }
 
 
 void NamedLoadHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
   if (!miss->is_unused()) {
     Label success;
     __ jmp(&success);
     __ bind(miss);
+    if (FLAG_vector_ics) {
+      DCHECK(kind() == Code::LOAD_IC);
+      PopVectorAndSlot();
+    }
     TailCallBuiltin(masm(), MissBuiltin(kind()));
     __ bind(&success);
   }
 }
 
 
 void NamedStoreHandlerCompiler::FrontendFooter(Handle<Name> name, Label* miss) {
   if (!miss->is_unused()) {
     Label success;
     __ jmp(&success);
@@ skipping 79 matching lines @@
   // Save necessary data before invoking an interceptor.
   // Requires a frame to make GC aware of pushed pointers.
   {
     FrameScope frame_scope(masm(), StackFrame::INTERNAL);
 
     if (must_preserve_receiver_reg) {
       __ push(receiver());
     }
     __ push(holder_reg);
     __ push(this->name());
-
+    if (FLAG_vector_ics &&
+        (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {

[Jakob Kummerow, 2014/12/02 08:43:07]

Again, can we re-use IC::ICUseVector() instead of duplicating the kinds list?

[mvstanton, 2014/12/03 11:48:30]

Done.

+      // The vector and slot values are already saved on the stack.
+      if (!holder_reg.is(receiver())) {
+        PushVectorAndSlot(scratch2(), scratch3());

[Jakob Kummerow, 2014/12/02 08:43:07]

Why the case distinction? Pushing scratch registers isn't any faster than
pushing the real things, or is it? Do they contain useful values at this point?
Also, it's not evident why slot and vector being on the stack is related to
holder and receiver registers being identical. Can you please add that to the
comment (if you keep the distinction)?

[mvstanton, 2014/12/03 11:48:30]

My earlier lengthy comment and the code changes answer these good questions.

+      } else {
+        PushVectorAndSlot();
+      }
+    }
     // Invoke an interceptor.  Note: map checks from receiver to
     // interceptor's holder has been compiled before (see a caller
     // of this method.)
     CompileCallLoadPropertyWithInterceptor(
         masm(), receiver(), holder_reg, this->name(), holder(),
         IC::kLoadPropertyWithInterceptorOnly);
 
     // Check if interceptor provided a value for property.  If it's
     // the case, return immediately.
     Label interceptor_failed;
     __ cmp(eax, factory()->no_interceptor_result_sentinel());
     __ j(equal, &interceptor_failed);
     frame_scope.GenerateLeaveFrame();
     __ ret(0);
 
     // Clobber registers when generating debug-code to provoke errors.
     __ bind(&interceptor_failed);
     if (FLAG_debug_code) {
       __ mov(receiver(), Immediate(bit_cast<int32_t>(kZapValue)));
       __ mov(holder_reg, Immediate(bit_cast<int32_t>(kZapValue)));
       __ mov(this->name(), Immediate(bit_cast<int32_t>(kZapValue)));
     }
 
+    if (FLAG_vector_ics &&
+        (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+      if (!holder_reg.is(receiver())) {
+        PopVectorAndSlot(scratch2(), scratch3());
+      } else {
+        PopVectorAndSlot();
+      }
+    }
     __ pop(this->name());
     __ pop(holder_reg);
     if (must_preserve_receiver_reg) {
       __ pop(receiver());
     }
 
     // Leave the internal frame.
   }
 
   GenerateLoadPostInterceptor(it, holder_reg);
@@ skipping 58 matching lines @@
 
 
 Register NamedStoreHandlerCompiler::value() {
   return StoreDescriptor::ValueRegister();
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadGlobal(
     Handle<PropertyCell> cell, Handle<Name> name, bool is_configurable) {
   Label miss;
-
+  if (FLAG_vector_ics &&
+      (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+    PushVectorAndSlot();
+  }
   FrontendHeader(receiver(), name, &miss);
   // Get the value from the cell.
   Register result = StoreDescriptor::ValueRegister();
   if (masm()->serializer_enabled()) {
     __ mov(result, Immediate(cell));
     __ mov(result, FieldOperand(result, PropertyCell::kValueOffset));
   } else {
     __ mov(result, Operand::ForCell(cell));
   }
 
   // Check for deleted property if property can actually be deleted.
   if (is_configurable) {
     __ cmp(result, factory()->the_hole_value());
     __ j(equal, &miss);
   } else if (FLAG_debug_code) {
     __ cmp(result, factory()->the_hole_value());
     __ Check(not_equal, kDontDeleteCellsCannotContainTheHole);
   }
 
   Counters* counters = isolate()->counters();
   __ IncrementCounter(counters->named_load_global_stub(), 1);
   // The code above already loads the result into the return register.
+  if (FLAG_vector_ics &&
+      (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+    DiscardVectorAndSlot();
+  }
   __ ret(0);
 
   FrontendFooter(name, &miss);
 
   // Return the generated code.
   return GetCode(kind(), Code::NORMAL, name);
 }
 
 
 #undef __
 }
 }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32