[StoreIC] Use StoreIC_Uninitialized for 0->PRE transitions

src/ic/keyed-store-generic.cc

 // Copyright 2016 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/keyed-store-generic.h"
 
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/contexts.h"
 #include "src/ic/accessor-assembler.h"
 #include "src/interface-descriptors.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 using compiler::Node;
 
 class KeyedStoreGenericAssembler : public AccessorAssembler {
  public:
   explicit KeyedStoreGenericAssembler(compiler::CodeAssemblerState* state)
       : AccessorAssembler(state) {}
 
   void KeyedStoreGeneric(LanguageMode language_mode);
 
+  void StoreIC_Uninitialized(LanguageMode language_mode);
+
  private:
   enum UpdateLength {
     kDontChangeLength,
     kIncrementLengthByOne,
     kBumpLengthWithGap
   };
 
+  enum UseStubCache { kUseStubCache, kDontUseStubCache };
+
   void EmitGenericElementStore(Node* receiver, Node* receiver_map,
                                Node* instance_type, Node* intptr_index,
                                Node* value, Node* context, Label* slow);
 
   void EmitGenericPropertyStore(Node* receiver, Node* receiver_map,
                                 const StoreICParameters* p, Label* slow,
-                                LanguageMode language_mode);
+                                LanguageMode language_mode,
+                                UseStubCache use_stub_cache = kUseStubCache);
 
   void BranchIfPrototypesHaveNonFastElements(Node* receiver_map,
                                              Label* non_fast_elements,
                                              Label* only_fast_elements);
 
   void TryRewriteElements(Node* receiver, Node* receiver_map, Node* elements,
                           Node* native_context, ElementsKind from_kind,
                           ElementsKind to_kind, Label* bailout);
 
   void StoreElementWithCapacity(Node* receiver, Node* receiver_map,
@@ skipping 29 matching lines @@
                                      Node* descriptor_name_index, Node* details,
                                      Node* value, Label* slow);
 };
 
 void KeyedStoreGenericGenerator::Generate(compiler::CodeAssemblerState* state,
                                           LanguageMode language_mode) {
   KeyedStoreGenericAssembler assembler(state);
   assembler.KeyedStoreGeneric(language_mode);
 }
 
+void StoreICUninitializedGenerator::Generate(
+    compiler::CodeAssemblerState* state, LanguageMode language_mode) {
+  KeyedStoreGenericAssembler assembler(state);
+  assembler.StoreIC_Uninitialized(language_mode);
+}
+
 void KeyedStoreGenericAssembler::BranchIfPrototypesHaveNonFastElements(
     Node* receiver_map, Label* non_fast_elements, Label* only_fast_elements) {
   Variable var_map(this, MachineRepresentation::kTagged);
   var_map.Bind(receiver_map);
   Label loop_body(this, &var_map);
   Goto(&loop_body);
 
   Bind(&loop_body);
   {
     Node* map = var_map.value();
@@ skipping 631 matching lines @@
     {
       StoreFixedArrayElement(properties, backing_store_index, value);
       Goto(&done);
     }
   }
   Bind(&done);
 }
 
 void KeyedStoreGenericAssembler::EmitGenericPropertyStore(
     Node* receiver, Node* receiver_map, const StoreICParameters* p, Label* slow,
-    LanguageMode language_mode) {
+    LanguageMode language_mode, UseStubCache use_stub_cache) {
   Variable var_accessor_pair(this, MachineRepresentation::kTagged);
   Variable var_accessor_holder(this, MachineRepresentation::kTagged);
   Label stub_cache(this), fast_properties(this), dictionary_properties(this),
       accessor(this), readonly(this);
   Node* properties = LoadProperties(receiver);
   Node* properties_map = LoadMap(properties);
   Branch(WordEqual(properties_map, LoadRoot(Heap::kHashTableMapRootIndex)),
          &dictionary_properties, &fast_properties);
 
   Bind(&fast_properties);
   {
     Comment("fast property store");
     Node* bitfield3 = LoadMapBitField3(receiver_map);
     Node* descriptors = LoadMapDescriptors(receiver_map);
     Label descriptor_found(this);
     Variable var_name_index(this, MachineType::PointerRepresentation());
     // TODO(jkummerow): Maybe look for existing map transitions?
-    Label* notfound = &stub_cache;
+    Label* notfound = use_stub_cache == kUseStubCache ? &stub_cache : slow;
     DescriptorLookup(p->name, descriptors, bitfield3, &descriptor_found,
                      &var_name_index, notfound);
 
     Bind(&descriptor_found);
     {
       Node* name_index = var_name_index.value();
       Node* details =
           LoadDetailsByKeyIndex<DescriptorArray>(descriptors, name_index);
       Label data_property(this);
       JumpIfDataProperty(details, &data_property, &readonly);
@@ skipping 42 matching lines @@
       Bind(&overwrite);
       {
         StoreValueByKeyIndex<NameDictionary>(properties, var_name_index.value(),
                                              p->value);
         Return(p->value);
       }
     }
 
     Bind(&not_found);
     {
+      Label extensible(this);
+      GotoIf(IsPrivateSymbol(p->name), &extensible);
+      Node* bitfield2 = LoadMapBitField2(receiver_map);
+      Branch(IsSetWord32(bitfield2, 1 << Map::kIsExtensible), &extensible,
+             slow);
+
+      Bind(&extensible);
       LookupPropertyOnPrototypeChain(receiver_map, p->name, &accessor,
                                      &var_accessor_pair, &var_accessor_holder,
                                      &readonly, slow);
       Add<NameDictionary>(properties, p->name, p->value, slow);
       Return(p->value);
     }
   }
 
   Bind(&accessor);
   {
@@ skipping 32 matching lines @@
           SmiConstant(Smi::FromInt(MessageTemplate::kStrictReadOnlyProperty));
       Node* type = Typeof(p->receiver);
       TailCallRuntime(Runtime::kThrowTypeError, p->context, message, p->name,
                       type, p->receiver);
     } else {
       DCHECK_EQ(SLOPPY, language_mode);
       Return(p->value);
     }
   }
 
-  Bind(&stub_cache);
-  {
+  if (use_stub_cache == kUseStubCache) {
+    Bind(&stub_cache);
     Comment("stub cache probe");
     Variable var_handler(this, MachineRepresentation::kTagged);
     Label found_handler(this, &var_handler), stub_cache_miss(this);
     TryProbeStubCache(isolate()->store_stub_cache(), receiver, p->name,
                       &found_handler, &var_handler, &stub_cache_miss);
     Bind(&found_handler);
     {
       Comment("KeyedStoreGeneric found handler");
       HandleStoreICHandlerCase(p, var_handler.value(), &stub_cache_miss);
     }
@@ skipping 48 matching lines @@
   }
 
   Bind(&slow);
   {
     Comment("KeyedStoreGeneric_slow");
     TailCallRuntime(Runtime::kSetProperty, context, receiver, name, value,
                     SmiConstant(language_mode));
   }
 }
 
+void KeyedStoreGenericAssembler::StoreIC_Uninitialized(
+    LanguageMode language_mode) {
+  typedef StoreWithVectorDescriptor Descriptor;
+
+  Node* receiver = Parameter(Descriptor::kReceiver);
+  Node* name = Parameter(Descriptor::kName);
+  Node* value = Parameter(Descriptor::kValue);
+  Node* slot = Parameter(Descriptor::kSlot);
+  Node* vector = Parameter(Descriptor::kVector);
+  Node* context = Parameter(Descriptor::kContext);
+
+  Label miss(this);
+
+  GotoIf(TaggedIsSmi(receiver), &miss);
+  Node* receiver_map = LoadMap(receiver);
+  Node* instance_type = LoadMapInstanceType(receiver_map);
+  // Receivers requiring non-standard element accesses (interceptors, access
+  // checks, strings and string wrappers, proxies) are handled in the runtime.
+  GotoIf(Int32LessThanOrEqual(instance_type,
+                              Int32Constant(LAST_SPECIAL_RECEIVER_TYPE)),
+         &miss);
+
+  // Optimistically write the state transition to the vector.
+  StoreFixedArrayElement(vector, slot,
+                         LoadRoot(Heap::kpremonomorphic_symbolRootIndex),
+                         SKIP_WRITE_BARRIER, 0, SMI_PARAMETERS);
+
+  StoreICParameters p(context, receiver, name, value, slot, vector);
+  EmitGenericPropertyStore(receiver, receiver_map, &p, &miss, language_mode,
+                           kDontUseStubCache);
+
+  Bind(&miss);
+  {
+    // Undo the optimistic state transition.
+    StoreFixedArrayElement(vector, slot,
+                           LoadRoot(Heap::kuninitialized_symbolRootIndex),
+                           SKIP_WRITE_BARRIER, 0, SMI_PARAMETERS);
+    TailCallRuntime(Runtime::kStoreIC_Miss, context, value, slot, vector,
+                    receiver, name);
+  }
+}
+
 }  // namespace internal
 }  // namespace v8