[ic] Support data handlers that represent simple field 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/ic/ic.h"
 
 #include "src/accessors.h"
 #include "src/api-arguments-inl.h"
 #include "src/api.h"
 #include "src/arguments.h"
@@ skipping 549 matching lines @@
     LoadICNexus* nexus = casted_nexus<LoadICNexus>();
     nexus->ConfigureMonomorphic(map, handler);
   } else if (kind() == Code::LOAD_GLOBAL_IC) {
     LoadGlobalICNexus* nexus = casted_nexus<LoadGlobalICNexus>();
     nexus->ConfigureHandlerMode(Handle<Code>::cast(handler));
   } else if (kind() == Code::KEYED_LOAD_IC) {
     KeyedLoadICNexus* nexus = casted_nexus<KeyedLoadICNexus>();
     nexus->ConfigureMonomorphic(name, map, handler);
   } else if (kind() == Code::STORE_IC) {
     StoreICNexus* nexus = casted_nexus<StoreICNexus>();
-    nexus->ConfigureMonomorphic(map, Handle<Code>::cast(handler));
+    nexus->ConfigureMonomorphic(map, handler);
   } else {
     DCHECK(kind() == Code::KEYED_STORE_IC);
     KeyedStoreICNexus* nexus = casted_nexus<KeyedStoreICNexus>();
-    nexus->ConfigureMonomorphic(name, map, Handle<Code>::cast(handler));
+    nexus->ConfigureMonomorphic(name, map, handler);
   }
 
   vector_set_ = true;
   OnTypeFeedbackChanged(isolate(), get_host());
 }
 
 void IC::ConfigureVectorState(Handle<Name> name, MapHandleList* maps,
                               List<Handle<Object>>* handlers) {
   DCHECK(UseVector());
   if (kind() == Code::LOAD_IC) {
@@ skipping 198 matching lines @@
     MapHandleList map_list;
     map_list.Add(handle(target_map));
     transitioned_map = source_map->FindElementsKindTransitionedMap(&map_list);
   }
   return transitioned_map == target_map;
 }
 
 void IC::PatchCache(Handle<Name> name, Handle<Object> handler) {
   DCHECK(IsHandler(*handler));
   // Currently only LoadIC and KeyedLoadIC support non-code handlers.
-  DCHECK_IMPLIES(!handler->IsCode(),
-                 kind() == Code::LOAD_IC || kind() == Code::KEYED_LOAD_IC);
+  DCHECK_IMPLIES(!handler->IsCode(), kind() == Code::LOAD_IC ||
+                                         kind() == Code::KEYED_LOAD_IC ||
+                                         kind() == Code::STORE_IC ||
+                                         kind() == Code::KEYED_STORE_IC);
   switch (state()) {
     case UNINITIALIZED:
     case PREMONOMORPHIC:
       UpdateMonomorphicIC(handler, name);
       break;
     case RECOMPUTE_HANDLER:
     case MONOMORPHIC:
       if (kind() == Code::LOAD_GLOBAL_IC) {
         UpdateMonomorphicIC(handler, name);
         break;
@@ skipping 198 matching lines @@
       return isolate()->store_stub_cache();
 
     default:
       break;
   }
   UNREACHABLE();
   return nullptr;
 }
 
 void IC::UpdateMegamorphicCache(Map* map, Name* name, Object* handler) {
+  if (FLAG_store_ic_smi_handlers && handler->IsSmi() &&
+      (kind() == Code::STORE_IC || kind() == Code::KEYED_STORE_IC)) {
+    // TODO(ishell, jkummerow): Implement data handlers support in
+    // KeyedStoreIC_Megamorphic.
+    Handle<Map> map_handle(map, isolate());
+    Handle<Name> name_handle(name, isolate());
+    int config = Smi::cast(handler)->value();
+    int value_index = StoreHandler::DescriptorValueIndexBits::decode(config);
+    int descriptor = (value_index - DescriptorArray::kDescriptorValue -
+                      DescriptorArray::kFirstIndex) /
+                     DescriptorArray::kDescriptorSize;
+    if (map->instance_descriptors()->length()) {
+      PropertyDetails details =
+          map->instance_descriptors()->GetDetails(descriptor);
+      DCHECK_EQ(DATA, details.type());
+      DCHECK_EQ(name, map->instance_descriptors()->GetKey(descriptor));
+      Representation representation = details.representation();
+      FieldIndex index = FieldIndex::ForDescriptor(map, descriptor);
+      TRACE_HANDLER_STATS(isolate(), StoreIC_StoreFieldStub);
+      StoreFieldStub stub(isolate(), index, representation);
+      handler = *stub.GetCode();
+    } else {
+      // It must be a prototype map that some prototype used to have. This map
+      // check will never succeed so write a dummy smi to the cache.
+      DCHECK(!map->is_dictionary_map());
+      DCHECK(map->is_prototype_map());
+      handler = Smi::FromInt(1);

[Jakob Kummerow, 2016/10/24 09:56:19]

Come to think of it: why is this line not "return;"? What's the advantage of
putting dummy values into the cache?

[Igor Sheludko, 2016/12/05 07:30:07]

Actually, we should have not even got here with such a map. It should be
filtered out with all the other dead maps. I'll address that in next CL.

+    }
+    stub_cache()->Set(*name_handle, *map_handle, handler);
+    return;
+  }
   stub_cache()->Set(name, map, handler);
 }
 
 Handle<Object> IC::ComputeHandler(LookupIterator* lookup,
                                   Handle<Object> value) {
   // Try to find a globally shared handler stub.
   Handle<Object> handler = GetMapIndependentHandler(lookup);
   if (!handler.is_null()) {
     DCHECK(IC::IsHandler(*handler));
     return handler;
@@ skipping 611 matching lines @@
     // the pre monomorphic stub to delay setting the monomorphic state.
     ConfigureVectorState(PREMONOMORPHIC, Handle<Object>());
     TRACE_IC("StoreIC", lookup->name());
     return;
   }
 
   bool use_ic = LookupForWrite(lookup, value, store_mode);
   if (!use_ic) {
     TRACE_GENERIC_IC(isolate(), "StoreIC", "LookupForWrite said 'false'");
   }
-  Handle<Code> code =
-      use_ic ? Handle<Code>::cast(ComputeHandler(lookup, value)) : slow_stub();
+  Handle<Object> handler = use_ic ? ComputeHandler(lookup, value)
+                                  : Handle<Object>::cast(slow_stub());
 
-  PatchCache(lookup->name(), code);
+  PatchCache(lookup->name(), handler);
   TRACE_IC("StoreIC", lookup->name());
 }
 
 
 static Handle<Code> PropertyCellStoreHandler(
     Isolate* isolate, Handle<JSObject> receiver, Handle<JSGlobalObject> holder,
     Handle<Name> name, Handle<PropertyCell> cell, PropertyCellType type) {
   auto constant_type = Nothing<PropertyCellConstantType>();
   if (type == PropertyCellType::kConstantType) {
     constant_type = Just(cell->GetConstantType());
@@ skipping 105 matching lines @@
 
       // -------------- Fields --------------
       if (lookup->property_details().type() == DATA) {
         bool use_stub = true;
         if (lookup->representation().IsHeapObject()) {
           // Only use a generic stub if no types need to be tracked.
           Handle<FieldType> field_type = lookup->GetFieldType();
           use_stub = !field_type->IsClass();
         }
         if (use_stub) {
-          TRACE_HANDLER_STATS(isolate(), StoreIC_StoreFieldStub);
-          StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
-                              lookup->representation());
-          return stub.GetCode();
+          if (FLAG_store_ic_smi_handlers) {
+            TRACE_HANDLER_STATS(isolate(), StoreIC_StoreFieldDH);
+            int descriptor = lookup->GetFieldDescriptorIndex();
+            FieldIndex index = lookup->GetFieldIndex();
+            return StoreHandler::StoreField(isolate(), descriptor, index,
+                                            lookup->representation());
+          } else {
+            TRACE_HANDLER_STATS(isolate(), StoreIC_StoreFieldStub);
+            StoreFieldStub stub(isolate(), lookup->GetFieldIndex(),
+                                lookup->representation());
+            return stub.GetCode();
+          }
         }
         break;  // Custom-compiled handler.
       }
 
       // -------------- Constant properties --------------
       DCHECK(lookup->property_details().type() == DATA_CONSTANT);
       TRACE_GENERIC_IC(isolate(), "StoreIC", "constant property");
       TRACE_HANDLER_STATS(isolate(), StoreIC_SlowStub);
       return slow_stub();
     }
@@ skipping 1178 matching lines @@
     DCHECK_EQ(LookupIterator::INTERCEPTOR, it.state());
     it.Next();
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
                                        Object::GetProperty(&it));
   }
 
   return *result;
 }
 }  // namespace internal
 }  // namespace v8