Unify implementations of Map handles vectors and lists

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 43 matching lines @@
       return os << "Store";
     case AccessMode::kStoreInLiteral:
       return os << "StoreInLiteral";
   }
   UNREACHABLE();
   return os;
 }
 
 ElementAccessInfo::ElementAccessInfo() {}
 
-ElementAccessInfo::ElementAccessInfo(MapList const& receiver_maps,
+ElementAccessInfo::ElementAccessInfo(MapHandles const& receiver_maps,
                                      ElementsKind elements_kind)
     : elements_kind_(elements_kind), receiver_maps_(receiver_maps) {}
 
 // static
-PropertyAccessInfo PropertyAccessInfo::NotFound(MapList const& receiver_maps,
+PropertyAccessInfo PropertyAccessInfo::NotFound(MapHandles const& receiver_maps,
                                                 MaybeHandle<JSObject> holder) {
   return PropertyAccessInfo(holder, receiver_maps);
 }
 
 // static
 PropertyAccessInfo PropertyAccessInfo::DataConstant(
-    MapList const& receiver_maps, Handle<Object> constant,
+    MapHandles const& receiver_maps, Handle<Object> constant,
     MaybeHandle<JSObject> holder) {
   return PropertyAccessInfo(kDataConstant, holder, constant, receiver_maps);
 }
 
 // static
 PropertyAccessInfo PropertyAccessInfo::DataField(
-    PropertyConstness constness, MapList const& receiver_maps,
+    PropertyConstness constness, MapHandles const& receiver_maps,
     FieldIndex field_index, MachineRepresentation field_representation,
     Type* field_type, MaybeHandle<Map> field_map, MaybeHandle<JSObject> holder,
     MaybeHandle<Map> transition_map) {
   Kind kind = constness == kConst ? kDataConstantField : kDataField;
   return PropertyAccessInfo(kind, holder, transition_map, field_index,
                             field_representation, field_type, field_map,
                             receiver_maps);
 }
 
 // static
 PropertyAccessInfo PropertyAccessInfo::AccessorConstant(
-    MapList const& receiver_maps, Handle<Object> constant,
+    MapHandles const& receiver_maps, Handle<Object> constant,
     MaybeHandle<JSObject> holder) {
   return PropertyAccessInfo(kAccessorConstant, holder, constant, receiver_maps);
 }
 
 PropertyAccessInfo::PropertyAccessInfo()
     : kind_(kInvalid),
       field_representation_(MachineRepresentation::kNone),
       field_type_(Type::None()) {}
 
 PropertyAccessInfo::PropertyAccessInfo(MaybeHandle<JSObject> holder,
-                                       MapList const& receiver_maps)
+                                       MapHandles const& receiver_maps)
     : kind_(kNotFound),
       receiver_maps_(receiver_maps),
       holder_(holder),
       field_representation_(MachineRepresentation::kNone),
       field_type_(Type::None()) {}
 
 PropertyAccessInfo::PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
                                        Handle<Object> constant,
-                                       MapList const& receiver_maps)
+                                       MapHandles const& receiver_maps)
     : kind_(kind),
       receiver_maps_(receiver_maps),
       constant_(constant),
       holder_(holder),
       field_representation_(MachineRepresentation::kNone),
       field_type_(Type::Any()) {}
 
 PropertyAccessInfo::PropertyAccessInfo(
     Kind kind, MaybeHandle<JSObject> holder, MaybeHandle<Map> transition_map,
     FieldIndex field_index, MachineRepresentation field_representation,
-    Type* field_type, MaybeHandle<Map> field_map, MapList const& receiver_maps)
+    Type* field_type, MaybeHandle<Map> field_map,
+    MapHandles const& receiver_maps)
     : kind_(kind),
       receiver_maps_(receiver_maps),
       transition_map_(transition_map),
       holder_(holder),
       field_index_(field_index),
       field_representation_(field_representation),
       field_type_(field_type),
       field_map_(field_map) {}
 
 bool PropertyAccessInfo::Merge(PropertyAccessInfo const* that,
@@ skipping 84 matching lines @@
       zone_(zone) {
   DCHECK(native_context->IsNativeContext());
 }
 
 
 bool AccessInfoFactory::ComputeElementAccessInfo(
     Handle<Map> map, AccessMode access_mode, ElementAccessInfo* access_info) {
   // 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);
+  *access_info = ElementAccessInfo(MapHandles{map}, elements_kind);
   return true;
 }
 
 bool AccessInfoFactory::ComputeElementAccessInfos(
-    MapHandleList const& maps, AccessMode access_mode,
+    MapHandles 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;
     }
   }
 
   // Collect possible transition targets.
-  MapHandleList possible_transition_targets(maps.length());
+  MapHandles possible_transition_targets;
+  possible_transition_targets.reserve(maps.size());
   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);
+        possible_transition_targets.push_back(map);
       }
     }
   }
 
   // Separate the actual receiver maps and the possible transition sources.
-  MapHandleList receiver_maps(maps.length());
-  MapTransitionList transitions(maps.length());
+  MapHandles receiver_maps;
+  receiver_maps.reserve(maps.size());
+  MapTransitionList transitions(maps.size());
   for (Handle<Map> map : maps) {
     if (Map::TryUpdate(map).ToHandle(&map)) {
       Map* transition_target =
-          map->FindElementsKindTransitionedMap(&possible_transition_targets);
+          map->FindElementsKindTransitionedMap(possible_transition_targets);
       if (transition_target == nullptr) {
-        receiver_maps.Add(map);
+        receiver_maps.push_back(map);
       } else {
         DCHECK(!map->is_stable());
         transitions.push_back(std::make_pair(map, handle(transition_target)));
       }
     }
   }
 
   for (Handle<Map> receiver_map : receiver_maps) {
     // Compute the element access information.
     ElementAccessInfo access_info;
@@ skipping 87 matching lines @@
               Handle<Map> field_owner_map(map->FindFieldOwner(number),
                                           isolate());
               dependencies()->AssumeFieldOwner(field_owner_map);
 
               // Remember the field map, and try to infer a useful type.
               field_type = Type::For(descriptors_field_type->AsClass());
               field_map = descriptors_field_type->AsClass();
             }
           }
           *access_info = PropertyAccessInfo::DataField(
-              details.constness(), MapList{receiver_map}, field_index,
+              details.constness(), MapHandles{receiver_map}, field_index,
               field_representation, field_type, field_map, holder);
           return true;
         } else {
           DCHECK_EQ(kAccessor, details.kind());
           // TODO(turbofan): Add support for general accessors?
           return false;
         }
 
       } else {
         DCHECK_EQ(kDescriptor, details.location());
         if (details.kind() == kData) {
           DCHECK(!FLAG_track_constant_fields);
           *access_info = PropertyAccessInfo::DataConstant(
-              MapList{receiver_map},
+              MapHandles{receiver_map},
               handle(descriptors->GetValue(number), isolate()), holder);
           return true;
         } else {
           DCHECK_EQ(kAccessor, details.kind());
           Handle<Object> accessors(descriptors->GetValue(number), isolate());
           if (!accessors->IsAccessorPair()) return false;
           Handle<Object> accessor(
               access_mode == AccessMode::kLoad
                   ? Handle<AccessorPair>::cast(accessors)->getter()
                   : Handle<AccessorPair>::cast(accessors)->setter(),
@@ skipping 10 matching lines @@
             if (FunctionTemplateInfo::TryGetCachedPropertyName(isolate(),
                                                                accessor)
                     .ToHandle(&cached_property_name)) {
               if (ComputePropertyAccessInfo(map, cached_property_name,
                                             access_mode, access_info)) {
                 return true;
               }
             }
           }
           *access_info = PropertyAccessInfo::AccessorConstant(
-              MapList{receiver_map}, accessor, holder);
+              MapHandles{receiver_map}, accessor, holder);
           return true;
         }
       }
       UNREACHABLE();
       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() &&
@@ skipping 22 matching lines @@
         // Store to property not found on the receiver or any prototype, we need
         // to transition to a new data property.
         // Implemented according to ES6 section 9.1.9 [[Set]] (P, V, Receiver)
         if (access_mode == AccessMode::kStore) {
           return LookupTransition(receiver_map, name, holder, access_info);
         }
         // The property was not found, return undefined or throw depending
         // on the language mode of the load operation.
         // Implemented according to ES6 section 9.1.8 [[Get]] (P, Receiver)
         *access_info =
-            PropertyAccessInfo::NotFound(MapList{receiver_map}, holder);
+            PropertyAccessInfo::NotFound(MapHandles{receiver_map}, holder);
         return true;
       } else {
         return false;
       }
     }
     Handle<JSObject> map_prototype(JSObject::cast(map->prototype()), isolate());
     if (map_prototype->map()->is_deprecated()) {
       // Try to migrate the prototype object so we don't embed the deprecated
       // map into the optimized code.
       JSObject::TryMigrateInstance(map_prototype);
     }
     map = handle(map_prototype->map(), isolate());
     holder = map_prototype;
   } while (CanInlinePropertyAccess(map));
   return false;
 }
 
 bool AccessInfoFactory::ComputePropertyAccessInfos(
-    MapHandleList const& maps, Handle<Name> name, AccessMode access_mode,
+    MapHandles const& maps, Handle<Name> name, AccessMode access_mode,
     ZoneVector<PropertyAccessInfo>* access_infos) {
   for (Handle<Map> map : maps) {
     if (Map::TryUpdate(map).ToHandle(&map)) {
       PropertyAccessInfo access_info;
       if (!ComputePropertyAccessInfo(map, name, access_mode, &access_info)) {
         return false;
       }
       // Try to merge the {access_info} with an existing one.
       bool merged = false;
       for (PropertyAccessInfo& other_info : *access_infos) {
@@ skipping 25 matching lines @@
     }
     if (IsMoreGeneralElementsKindTransition(this_kind, that_kind)) {
       return Just(that_kind);
     }
   }
   return Nothing<ElementsKind>();
 }
 
 }  // namespace
 
-bool AccessInfoFactory::ConsolidateElementLoad(MapHandleList const& maps,
+bool AccessInfoFactory::ConsolidateElementLoad(MapHandles const& maps,
                                                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 (maps.empty()) return false;
+  InstanceType instance_type = maps.front()->instance_type();
+  ElementsKind elements_kind = maps.front()->elements_kind();
+  for (auto map : maps) {

[Franzi, 2017/05/02 16:29:32]

Can we make map const?

[danno, 2017/05/03 15:10:30]

Instead I changed all the autos to Handle<Map>. This matches the original code.
I didn't make them const, since it doesn't add any value here (you can't assign
to Handle<Map>s anyway).

     if (!CanInlineElementAccess(map) || map->instance_type() != instance_type) {
       return false;
     }
     if (!GeneralizeElementsKind(elements_kind, map->elements_kind())
              .To(&elements_kind)) {
       return false;
     }
-    receiver_maps[i] = map;
   }
-  *access_info = ElementAccessInfo(receiver_maps, elements_kind);
+  *access_info = ElementAccessInfo(maps, elements_kind);
   return true;
 }
 
 bool AccessInfoFactory::LookupSpecialFieldAccessor(
     Handle<Map> map, Handle<Name> name, PropertyAccessInfo* access_info) {
   // Check for special JSObject field accessors.
   int offset;
   if (Accessors::IsJSObjectFieldAccessor(map, name, &offset)) {
     FieldIndex field_index = FieldIndex::ForInObjectOffset(offset);
     Type* field_type = Type::NonInternal();
@@ skipping 15 matching lines @@
         field_type = type_cache_.kFixedDoubleArrayLengthType;
         field_representation = MachineRepresentation::kTaggedSigned;
       } else if (IsFastElementsKind(map->elements_kind())) {
         field_type = type_cache_.kFixedArrayLengthType;
         field_representation = MachineRepresentation::kTaggedSigned;
       } else {
         field_type = type_cache_.kJSArrayLengthType;
       }
     }
     // Special fields are always mutable.
-    *access_info = PropertyAccessInfo::DataField(
-        kMutable, MapList{map}, field_index, field_representation, field_type);
+    *access_info =
+        PropertyAccessInfo::DataField(kMutable, MapHandles{map}, field_index,
+                                      field_representation, field_type);
     return true;
   }
   return false;
 }
 
 
 bool AccessInfoFactory::LookupTransition(Handle<Map> map, Handle<Name> name,
                                          MaybeHandle<JSObject> holder,
                                          PropertyAccessInfo* access_info) {
   // Check if the {map} has a data transition with the given {name}.
@@ skipping 37 matching lines @@
         dependencies()->AssumeFieldOwner(field_owner_map);
 
         // Remember the field map, and try to infer a useful type.
         field_type = Type::For(descriptors_field_type->AsClass());
         field_map = descriptors_field_type->AsClass();
       }
     }
     dependencies()->AssumeMapNotDeprecated(transition_map);
     // Transitioning stores are never stores to constant fields.
     *access_info = PropertyAccessInfo::DataField(
-        kMutable, MapList{map}, field_index, field_representation, field_type,
-        field_map, holder, transition_map);
+        kMutable, MapHandles{map}, field_index, field_representation,
+        field_type, field_map, holder, transition_map);
     return true;
   }
   return false;
 }
 
 
 Factory* AccessInfoFactory::factory() const { return isolate()->factory(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8