[turbofan] General consolidation of element access.

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 188 matching lines @@
   // Check if it is safe to inline element access for the {map}.
   if (!CanInlineElementAccess(map)) return false;
   ElementsKind const elements_kind = map->elements_kind();
   *access_info = ElementAccessInfo(MapList{map}, elements_kind);
   return true;
 }
 
 bool AccessInfoFactory::ComputeElementAccessInfos(
     MapHandleList const& maps, AccessMode access_mode,
     ZoneVector<ElementAccessInfo>* access_infos) {
-  if (access_mode == AccessMode::kLoad) {
-    // For polymorphic loads of similar elements kinds (i.e. all tagged or all
-    // double), always use the "worst case" code without a transition.  This is
-    // much faster than transitioning the elements to the worst case, trading a
-    // TransitionElementsKind for a CheckMaps, avoiding mutation of the array.
-    ElementAccessInfo access_info;
-    if (ConsolidateElementLoad(maps, &access_info)) {
-      access_infos->push_back(access_info);
-      return true;
-    }
+  // For polymorphic loads of similar elements kinds (i.e. all tagged or all
+  // double), always use the "worst case" code without a transition. This is
+  // much faster than transitioning the elements to the worst case, trading a
+  // TransitionElementsKind for a CheckMaps, avoiding mutation of the array.
+  //
+  // Similarly, for polymorphic stores of compatible elements kind that
+  // differ only in holeyness, always use the "holey case" code without a
+  // transition. This is beneficial, because CheckMaps can often be optimized
+  // whereas TransitionElementsKind can block optimizations. And as above, we
+  // avoid mutation of the array (we still mutate the array contents).
+  ElementAccessInfo access_info;
+  if (ConsolidateElementAccess(maps, access_mode, &access_info)) {
+    access_infos->push_back(access_info);
+    return true;
   }
 
   // Collect possible transition targets.
   MapHandleList possible_transition_targets(maps.length());
   for (Handle<Map> map : maps) {
     if (Map::TryUpdate(map).ToHandle(&map)) {
       if (CanInlineElementAccess(map) &&
           IsFastElementsKind(map->elements_kind()) &&
           GetInitialFastElementsKind() != map->elements_kind()) {
         possible_transition_targets.Add(map);
@@ skipping 239 matching lines @@
           merged = true;
           break;
         }
       }
       if (!merged) access_infos->push_back(access_info);
     }
   }
   return true;
 }
 
-namespace {
-
-Maybe<ElementsKind> GeneralizeElementsKind(ElementsKind this_kind,
-                                           ElementsKind that_kind) {
-  if (IsHoleyElementsKind(this_kind)) {
-    that_kind = GetHoleyElementsKind(that_kind);
-  } else if (IsHoleyElementsKind(that_kind)) {
-    this_kind = GetHoleyElementsKind(this_kind);
-  }
-  if (this_kind == that_kind) return Just(this_kind);
-  if (IsFastDoubleElementsKind(that_kind) ==
-      IsFastDoubleElementsKind(this_kind)) {
-    if (IsMoreGeneralElementsKindTransition(that_kind, this_kind)) {
-      return Just(this_kind);
-    }
-    if (IsMoreGeneralElementsKindTransition(this_kind, that_kind)) {
-      return Just(that_kind);
-    }
-  }
-  return Nothing<ElementsKind>();
-}
-
-}  // namespace
-
-bool AccessInfoFactory::ConsolidateElementLoad(MapHandleList const& maps,
-                                               ElementAccessInfo* access_info) {
+bool AccessInfoFactory::ConsolidateElementAccess(
+    MapHandleList const& maps, AccessMode access_mode,
+    ElementAccessInfo* access_info) {
   if (maps.is_empty()) return false;
   InstanceType instance_type = maps.first()->instance_type();
   ElementsKind elements_kind = maps.first()->elements_kind();
   MapList receiver_maps(maps.length());
   for (int i = 0; i < maps.length(); ++i) {
     Handle<Map> map = maps[i];
     if (!CanInlineElementAccess(map) || map->instance_type() != instance_type) {
       return false;
     }
-    if (!GeneralizeElementsKind(elements_kind, map->elements_kind())
-             .To(&elements_kind)) {
-      return false;
+    ElementsKind other_kind = map->elements_kind();
+    if (IsHoleyElementsKind(elements_kind)) {
+      other_kind = GetHoleyElementsKind(other_kind);
+    } else if (IsHoleyElementsKind(other_kind)) {
+      elements_kind = GetHoleyElementsKind(elements_kind);
+    }
+    if (elements_kind != other_kind) {
+      if (access_mode != AccessMode::kLoad) return false;
+      if (IsFastDoubleElementsKind(elements_kind) !=
+          IsFastDoubleElementsKind(other_kind)) {
+        return false;
+      }
+      if (IsMoreGeneralElementsKindTransition(elements_kind, other_kind)) {
+        elements_kind = other_kind;
+      } else if (!IsMoreGeneralElementsKindTransition(other_kind,
+                                                      elements_kind)) {
+        return false;
+      }
     }
     receiver_maps[i] = map;
   }
   *access_info = ElementAccessInfo(receiver_maps, elements_kind);
   return true;
 }
 
 bool AccessInfoFactory::LookupSpecialFieldAccessor(
     Handle<Map> map, Handle<Name> name, PropertyAccessInfo* access_info) {
   // Check for special JSObject field accessors.
@@ skipping 91 matching lines @@
   }
   return false;
 }
 
 
 Factory* AccessInfoFactory::factory() const { return isolate()->factory(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8