[turbofan] Use feedback from StoreDataPropertyInLiteral.

src/compiler/access-info.cc

 // Copyright 2015 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 <ostream>
 
 #include "src/accessors.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-info.h"
 #include "src/compiler/type-cache.h"
@@ skipping 34 matching lines @@
 
 }  // namespace
 
 
 std::ostream& operator<<(std::ostream& os, AccessMode access_mode) {
   switch (access_mode) {
     case AccessMode::kLoad:
       return os << "Load";
     case AccessMode::kStore:
       return os << "Store";
+    case AccessMode::kStoreInLiteral:
+      return os << "StoreInLiteral";
   }
   UNREACHABLE();
   return os;
 }
 
 ElementAccessInfo::ElementAccessInfo() {}
 
 ElementAccessInfo::ElementAccessInfo(MapList const& receiver_maps,
                                      ElementsKind elements_kind)
     : elements_kind_(elements_kind), receiver_maps_(receiver_maps) {}
@@ skipping 210 matching lines @@
     return true;
   }
 
   MaybeHandle<JSObject> holder;
   do {
     // Lookup the named property on the {map}.
     Handle<DescriptorArray> descriptors(map->instance_descriptors(), isolate());
     int const number = descriptors->SearchWithCache(isolate(), *name, *map);
     if (number != DescriptorArray::kNotFound) {
       PropertyDetails const details = descriptors->GetDetails(number);
-      if (access_mode == AccessMode::kStore) {
+      if (access_mode == AccessMode::kStore ||
+          access_mode == AccessMode::kStoreInLiteral) {
         // Don't bother optimizing stores to read-only properties.
         if (details.IsReadOnly()) {
           return false;
         }
         // Check for store to data property on a prototype.
         if (details.kind() == kData && !holder.is_null()) {
           // Store to property not found on the receiver but on a prototype, we
           // need to transition to a new data property.
           // Implemented according to ES6 section 9.1.9 [[Set]] (P, V, Receiver)
           return LookupTransition(receiver_map, name, holder, access_info);
@@ skipping 79 matching lines @@
       return false;
     }
 
     // Don't search on the prototype chain for special indices in case of
     // integer indexed exotic objects (see ES6 section 9.4.5).
     if (map->IsJSTypedArrayMap() && name->IsString() &&
         IsSpecialIndex(isolate()->unicode_cache(), String::cast(*name))) {
       return false;
     }
 
+    // Don't search on the prototype when storing in literals
+    if (access_mode == AccessMode::kStoreInLiteral) {
+      return false;
+    }
+
     // Don't lookup private symbols on the prototype chain.
     if (name->IsPrivate()) return false;
 
     // Walk up the prototype chain.
     if (!map->prototype()->IsJSObject()) {
       // Perform the implicit ToObject for primitives here.
       // Implemented according to ES6 section 7.3.2 GetV (V, P).
       Handle<JSFunction> constructor;
       if (Map::GetConstructorFunction(map, native_context())
               .ToHandle(&constructor)) {
@@ skipping 151 matching lines @@
   }
   return false;
 }
 
 
 Factory* AccessInfoFactory::factory() const { return isolate()->factory(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8