VectorICs: Lithium support for vector-based stores.

src/ic/ic.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.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/arguments.h"
 #include "src/base/bits.h"
@@ skipping 919 matching lines @@
       return isolate->builtins()->KeyedLoadIC_Initialize();
     case MEGAMORPHIC:
       return isolate->builtins()->KeyedLoadIC_Megamorphic();
     default:
       UNREACHABLE();
   }
   return Handle<Code>();
 }
 
 
-Handle<Code> KeyedStoreIC::initialize_stub(Isolate* isolate,
-                                           LanguageMode language_mode,
-                                           State initialization_state) {
+static Handle<Code> KeyedStoreICInitializeStubHelper(
+    Isolate* isolate, LanguageMode language_mode,
+    InlineCacheState initialization_state) {
   switch (initialization_state) {
     case UNINITIALIZED:
       return is_strict(language_mode)
                  ? isolate->builtins()->KeyedStoreIC_Initialize_Strict()
                  : isolate->builtins()->KeyedStoreIC_Initialize();
     case PREMONOMORPHIC:
       return is_strict(language_mode)
                  ? isolate->builtins()->KeyedStoreIC_PreMonomorphic_Strict()
                  : isolate->builtins()->KeyedStoreIC_PreMonomorphic();
     case MEGAMORPHIC:
       return is_strict(language_mode)
                  ? isolate->builtins()->KeyedStoreIC_Megamorphic_Strict()
                  : isolate->builtins()->KeyedStoreIC_Megamorphic();
     default:
       UNREACHABLE();
   }
   return Handle<Code>();
 }
 
 
+Handle<Code> KeyedStoreIC::initialize_stub(Isolate* isolate,
+                                           LanguageMode language_mode,
+                                           State initialization_state) {
+  if (FLAG_vector_stores) {
+    VectorKeyedStoreICTrampolineStub stub(isolate, StoreICState(language_mode));
+    return stub.GetCode();
+  }
+
+  return KeyedStoreICInitializeStubHelper(isolate, language_mode,
+                                          initialization_state);
+}
+
+
+Handle<Code> KeyedStoreIC::initialize_stub_in_optimized_code(
+    Isolate* isolate, LanguageMode language_mode, State initialization_state) {
+  if (FLAG_vector_stores && initialization_state != MEGAMORPHIC) {
+    VectorKeyedStoreICStub stub(isolate, StoreICState(language_mode));
+    return stub.GetCode();
+  }
+
+  return KeyedStoreICInitializeStubHelper(isolate, language_mode,
+                                          initialization_state);
+}
+
+
 Handle<Code> LoadIC::megamorphic_stub() {
   DCHECK_EQ(Code::KEYED_LOAD_IC, kind());
   return KeyedLoadIC::ChooseMegamorphicStub(isolate());
 }
 
 
 Handle<Code> LoadIC::SimpleFieldLoad(FieldIndex index) {
   LoadFieldStub stub(isolate(), index);
   return stub.GetCode();
 }
@@ skipping 343 matching lines @@
                                Object);
   } else if (FLAG_use_ic && !object->IsAccessCheckNeeded()) {
     if (object->IsJSObject() || (object->IsString() && key->IsNumber())) {
       Handle<HeapObject> receiver = Handle<HeapObject>::cast(object);
       if (object->IsString() || !Object::ToSmi(isolate(), key).is_null()) {
         stub = LoadElementStub(receiver);
       }
     }
   }
 
-  if (!UseVector()) {
-    if (!is_target_set()) {
-      Code* generic = *megamorphic_stub();
-      if (*stub == generic) {
-        TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic");
-      }
+  DCHECK(UseVector());
+  if (!is_vector_set() || stub.is_null()) {
+    Code* generic = *megamorphic_stub();
+    if (!stub.is_null() && *stub == generic) {
+      ConfigureVectorState(MEGAMORPHIC);
+      TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic");
+    }
 
-      set_target(*stub);
-      TRACE_IC("LoadIC", key);
-    }
-  } else {
-    if (!is_vector_set() || stub.is_null()) {
-      Code* generic = *megamorphic_stub();
-      if (!stub.is_null() && *stub == generic) {
-        ConfigureVectorState(MEGAMORPHIC);
-        TRACE_GENERIC_IC(isolate(), "KeyedLoadIC", "set generic");
-      }
-
-      TRACE_IC("LoadIC", key);
-    }
+    TRACE_IC("LoadIC", key);
   }
 
   if (!load_handle.is_null()) return load_handle;
   Handle<Object> result;
   ASSIGN_RETURN_ON_EXCEPTION(isolate(), result,
                              Runtime::GetObjectProperty(isolate(), object, key),
                              Object);
   return result;
 }
 
@@ skipping 160 matching lines @@
 
 
 Handle<Code> CallIC::initialize_stub_in_optimized_code(
     Isolate* isolate, int argc, CallICState::CallType call_type) {
   CallICStub stub(isolate, CallICState(argc, call_type));
   Handle<Code> code = stub.GetCode();
   return code;
 }
 
 
+static Handle<Code> StoreICInitializeStubHelper(
+    Isolate* isolate, ExtraICState extra_state,
+    InlineCacheState initialization_state) {
+  Handle<Code> ic = PropertyICCompiler::ComputeStore(
+      isolate, initialization_state, extra_state);
+  return ic;
+}
+
+
 Handle<Code> StoreIC::initialize_stub(Isolate* isolate,
                                       LanguageMode language_mode,
                                       State initialization_state) {
   DCHECK(initialization_state == UNINITIALIZED ||
          initialization_state == PREMONOMORPHIC ||
          initialization_state == MEGAMORPHIC);
-  ExtraICState extra_state = ComputeExtraICState(language_mode);
-  Handle<Code> ic = PropertyICCompiler::ComputeStore(
-      isolate, initialization_state, extra_state);
-  return ic;
+  if (FLAG_vector_stores) {
+    VectorStoreICTrampolineStub stub(isolate, StoreICState(language_mode));
+    return stub.GetCode();
+  }
+
+  return StoreICInitializeStubHelper(
+      isolate, ComputeExtraICState(language_mode), initialization_state);
 }
 
 
+Handle<Code> StoreIC::initialize_stub_in_optimized_code(
+    Isolate* isolate, LanguageMode language_mode, State initialization_state) {
+  DCHECK(initialization_state == UNINITIALIZED ||
+         initialization_state == PREMONOMORPHIC ||
+         initialization_state == MEGAMORPHIC);
+  if (FLAG_vector_stores && initialization_state != MEGAMORPHIC) {
+    VectorStoreICStub stub(isolate, StoreICState(language_mode));
+    return stub.GetCode();
+  }
+
+  return StoreICInitializeStubHelper(
+      isolate, ComputeExtraICState(language_mode), initialization_state);
+}
+
+
 Handle<Code> StoreIC::megamorphic_stub() {
   if (kind() == Code::STORE_IC) {
     return PropertyICCompiler::ComputeStore(isolate(), MEGAMORPHIC,
                                             extra_ic_state());
   } else {
     DCHECK(kind() == Code::KEYED_STORE_IC);
     if (is_strict(language_mode())) {
       return isolate()->builtins()->KeyedStoreIC_Megamorphic_Strict();
     } else {
       return isolate()->builtins()->KeyedStoreIC_Megamorphic();
@@ skipping 1348 matching lines @@
 static const Address IC_utilities[] = {
 #define ADDR(name) FUNCTION_ADDR(name),
     IC_UTIL_LIST(ADDR) NULL
 #undef ADDR
 };
 
 
 Address IC::AddressFromUtilityId(IC::UtilityId id) { return IC_utilities[id]; }
 }  // namespace internal
 }  // namespace v8