Hydrogen code stubs for vector-based ICs.

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/v8.h"
 
 #include "src/ic/call-optimization.h"
 #include "src/ic/handler-compiler.h"
 #include "src/ic/ic.h"
 #include "src/ic/ic-inl.h"
@@ skipping 114 matching lines @@
                                                    Handle<Name> name,
                                                    Label* miss) {
   return CheckPrototypes(object_reg, this->name(), scratch1(), scratch2(), name,
                          miss, SKIP_RECEIVER);
 }
 
 
 Register PropertyHandlerCompiler::Frontend(Register object_reg,
                                            Handle<Name> name) {
   Label miss;
+  if (FLAG_vector_ics &&

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

Can we re-use IC::ICUseVector here and below?

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

Done.

+      (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+    if (object_reg.is(VectorLoadICDescriptor::VectorRegister())) {
+      PushVectorAndSlot(scratch2(), scratch3());
+    } else {
+      PushVectorAndSlot();
+    }
+  }
   Register reg = FrontendHeader(object_reg, name, &miss);
   FrontendFooter(name, &miss);
+  // The footer consumes the vector and slot from the stack if
+  // miss occurs

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

nit: Trailing full stop.

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

Done.

+  if (FLAG_vector_ics &&
+      (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+    if (reg.is(VectorLoadICDescriptor::VectorRegister()) &&
+        !reg.is(object_reg)) {

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

Uhm... you've pushed scratch2/scratch3 if object_reg == vector_reg. Now you're
popping them if object_reg != vector_reg. If that's intentional, then it's
confusing and deserves a comment.

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

Okay, I've refactored this. The problem is that Frontend() is usually used in a
simple way, with object_reg == receiver(). But the interceptor case plays some
tricks with it. I removed all these contortions here in favor of confining them
to interceptor handler compilation, where they've been reformulated to make more
sense.

The general idea is that the interceptor wants to store the holder in the vector
register, but MISS can still occur during that period. So code that maintains
the vector and slot may need to shift where it stores them to scratch2() and
scratch3() during that time.

This story can now be read in a straight line as a part of interceptor handler
compilation.

+      PopVectorAndSlot(scratch2(), scratch3());
+    } else {
+      DiscardVectorAndSlot();
+    }
+  }
   return reg;
 }
 
 
 void PropertyHandlerCompiler::NonexistentFrontendHeader(Handle<Name> name,
                                                         Label* miss,
                                                         Register scratch1,
                                                         Register scratch2) {
   Register holder_reg;
   Handle<Map> last_map;
@@ skipping 46 matching lines @@
   __ Move(receiver(), reg);
   LoadConstantStub stub(isolate(), constant_index);
   GenerateTailCall(masm(), stub.GetCode());
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadNonexistent(
     Handle<Name> name) {
   Label miss;
+  if (FLAG_vector_ics) {
+    DCHECK(kind() == Code::LOAD_IC);
+    PushVectorAndSlot();
+  }
   NonexistentFrontendHeader(name, &miss, scratch2(), scratch3());
+  if (FLAG_vector_ics &&
+      (kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC)) {
+    DiscardVectorAndSlot();
+  }
   GenerateLoadConstant(isolate()->factory()->undefined_value());
   FrontendFooter(name, &miss);
   return GetCode(kind(), Code::FAST, name);
 }
 
 
 Handle<Code> NamedLoadHandlerCompiler::CompileLoadCallback(
     Handle<Name> name, Handle<ExecutableAccessorInfo> callback) {
   Register reg = Frontend(receiver(), name);
   GenerateLoadCallback(reg, callback);
@@ skipping 222 matching lines @@
         DCHECK(elements_kind == DICTIONARY_ELEMENTS);
         cached_stub = LoadDictionaryElementStub(isolate()).GetCode();
       }
     }
 
     handlers->Add(cached_stub);
   }
 }
 }
 }  // namespace v8::internal