[runtime] Add DescriptorArray::GeneralizeAllFields().

src/map-updater.cc

 // Copyright 2017 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/map-updater.h"
 
 #include "src/field-type.h"
 #include "src/handles.h"
 #include "src/isolate.h"
 #include "src/objects-inl.h"
@@ skipping 131 matching lines @@
   DCHECK_EQ(kInitialized, state_);
   DCHECK(old_map_->is_deprecated());
 
   if (FindRootMap() == kEnd) return result_map_;
   if (FindTargetMap() == kEnd) return result_map_;
   ConstructNewMap();
   DCHECK_EQ(kEnd, state_);
   return result_map_;
 }
 
-MapUpdater::State MapUpdater::CopyGeneralizeAllRepresentations(
-    const char* reason) {
+MapUpdater::State MapUpdater::CopyGeneralizeAllFields(const char* reason) {
   StoreMode store_mode =
       modified_descriptor_ >= 0 ? FORCE_FIELD : ALLOW_IN_DESCRIPTOR;
-  result_map_ = Map::CopyGeneralizeAllRepresentations(
+  result_map_ = Map::CopyGeneralizeAllFields(
       old_map_, new_elements_kind_, modified_descriptor_, store_mode, new_kind_,
       new_attributes_, reason);
   state_ = kEnd;
   return state_;  // Done.
 }
 
 MapUpdater::State MapUpdater::TryRecofigureToDataFieldInplace() {
   // If it's just a representation generalization case (i.e. property kind and
   // attributes stays unchanged) it's fine to transition from None to anything
   // but double without any modification to the object, because the default
@@ skipping 36 matching lines @@
   state_ = kEnd;
   return state_;  // Done.
 }
 
 MapUpdater::State MapUpdater::FindRootMap() {
   DCHECK_EQ(kInitialized, state_);
   // Check the state of the root map.
   root_map_ = handle(old_map_->FindRootMap(), isolate_);
   int root_nof = root_map_->NumberOfOwnDescriptors();
   if (!old_map_->EquivalentToForTransition(*root_map_)) {
-    return CopyGeneralizeAllRepresentations("GenAll_NotEquivalent");
+    return CopyGeneralizeAllFields("GenAll_NotEquivalent");
   }
 
   ElementsKind from_kind = root_map_->elements_kind();
   ElementsKind to_kind = new_elements_kind_;
   // TODO(ishell): Add a test for SLOW_SLOPPY_ARGUMENTS_ELEMENTS.
   if (from_kind != to_kind && to_kind != DICTIONARY_ELEMENTS &&
       to_kind != SLOW_STRING_WRAPPER_ELEMENTS &&
       to_kind != SLOW_SLOPPY_ARGUMENTS_ELEMENTS &&
       !(IsTransitionableFastElementsKind(from_kind) &&
         IsMoreGeneralElementsKindTransition(from_kind, to_kind))) {
-    return CopyGeneralizeAllRepresentations("GenAll_InvalidElementsTransition");
+    return CopyGeneralizeAllFields("GenAll_InvalidElementsTransition");
   }
 
   if (modified_descriptor_ >= 0 && modified_descriptor_ < root_nof) {
     PropertyDetails old_details =
         old_descriptors_->GetDetails(modified_descriptor_);
     if (old_details.kind() != new_kind_ ||
         old_details.attributes() != new_attributes_) {
-      return CopyGeneralizeAllRepresentations("GenAll_RootModification1");
+      return CopyGeneralizeAllFields("GenAll_RootModification1");
     }
     if (!new_representation_.fits_into(old_details.representation())) {
-      return CopyGeneralizeAllRepresentations("GenAll_RootModification2");
+      return CopyGeneralizeAllFields("GenAll_RootModification2");
     }
     if (old_details.location() != kField) {
-      return CopyGeneralizeAllRepresentations("GenAll_RootModification3");
+      return CopyGeneralizeAllFields("GenAll_RootModification3");
     }
     DCHECK_EQ(kData, old_details.kind());
     DCHECK_EQ(kData, new_kind_);
     DCHECK_EQ(kField, new_location_);
     FieldType* old_field_type =
         old_descriptors_->GetFieldType(modified_descriptor_);
     if (!new_field_type_->NowIs(old_field_type)) {
-      return CopyGeneralizeAllRepresentations("GenAll_RootModification4");
+      return CopyGeneralizeAllFields("GenAll_RootModification4");
     }
   }
 
   // From here on, use the map with correct elements kind as root map.
   if (from_kind != to_kind) {
     root_map_ = Map::AsElementsKind(root_map_, to_kind);
   }
   state_ = kAtRootMap;
   return state_;  // Not done yet.
 }
@@ skipping 13 matching lines @@
     Handle<DescriptorArray> tmp_descriptors(tmp_map->instance_descriptors(),
                                             isolate_);
 
     // Check if target map is incompatible.
     PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
     DCHECK_EQ(old_details.kind(), tmp_details.kind());
     DCHECK_EQ(old_details.attributes(), tmp_details.attributes());
     if (old_details.kind() == kAccessor &&
         !EqualImmutableValues(GetValue(i), tmp_descriptors->GetValue(i))) {
       // TODO(ishell): mutable accessors are not implemented yet.
-      return CopyGeneralizeAllRepresentations("GenAll_Incompatible");
+      return CopyGeneralizeAllFields("GenAll_Incompatible");
     }
     // Check if old location fits into tmp location.
     if (!LocationFitsInto(old_details.location(), tmp_details.location())) {
       break;
     }
 
     // Check if old representation fits into tmp representation.
     Representation tmp_representation = tmp_details.representation();
     if (!old_details.representation().fits_into(tmp_representation)) {
       break;
@@ skipping 55 matching lines @@
                                             isolate_);
 
 #ifdef DEBUG
     // Check that target map is compatible.
     PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
     DCHECK_EQ(old_details.kind(), tmp_details.kind());
     DCHECK_EQ(old_details.attributes(), tmp_details.attributes());
 #endif
     if (old_details.kind() == kAccessor &&
         !EqualImmutableValues(GetValue(i), tmp_descriptors->GetValue(i))) {
-      return CopyGeneralizeAllRepresentations("GenAll_Incompatible");
+      return CopyGeneralizeAllFields("GenAll_Incompatible");
     }
     DCHECK(!tmp_map->is_deprecated());
     target_map_ = tmp_map;
   }
 
   state_ = kAtTargetMap;
   return state_;  // Not done yet.
 }
 
 Handle<DescriptorArray> MapUpdater::BuildDescriptorArray() {
@@ skipping 188 matching lines @@
       split_details.attributes());
   if (maybe_transition != NULL) {
     maybe_transition->DeprecateTransitionTree();
   }
 
   // If |maybe_transition| is not NULL then the transition array already
   // contains entry for given descriptor. This means that the transition
   // could be inserted regardless of whether transitions array is full or not.
   if (maybe_transition == NULL &&
       !TransitionArray::CanHaveMoreTransitions(split_map)) {
-    return CopyGeneralizeAllRepresentations("GenAll_CantHaveMoreTransitions");
+    return CopyGeneralizeAllFields("GenAll_CantHaveMoreTransitions");
   }
 
   old_map_->NotifyLeafMapLayoutChange();
 
   if (FLAG_trace_generalization && modified_descriptor_ >= 0) {
     PropertyDetails old_details =
         old_descriptors_->GetDetails(modified_descriptor_);
     PropertyDetails new_details =
         new_descriptors->GetDetails(modified_descriptor_);
     MaybeHandle<FieldType> old_field_type;
@@ skipping 33 matching lines @@
   // the new descriptors to maintain descriptors sharing invariant.
   split_map->ReplaceDescriptors(*new_descriptors, *new_layout_descriptor);
 
   result_map_ = new_map;
   state_ = kEnd;
   return state_;  // Done.
 }
 
 }  // namespace internal
 }  // namespace v8