[runtime][ic] Constant field tracking support.

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 67 matching lines @@
   if (location == kField) {
     return handle(descriptors->GetFieldType(descriptor), isolate_);
   } else {
     return descriptors->GetValue(descriptor)
         ->OptimalType(isolate_, representation);
   }
 }
 
 Handle<Map> MapUpdater::ReconfigureToDataField(int descriptor,
                                                PropertyAttributes attributes,
+                                               PropertyConstness constness,
                                                Representation representation,
                                                Handle<FieldType> field_type) {
   DCHECK_EQ(kInitialized, state_);
   DCHECK_LE(0, descriptor);
   DCHECK(!old_map_->is_dictionary_map());
   modified_descriptor_ = descriptor;
   new_kind_ = kData;
   new_attributes_ = attributes;
   new_location_ = kField;
 
   PropertyDetails old_details =
       old_descriptors_->GetDetails(modified_descriptor_);
 
   // If property kind is not reconfigured merge the result with
   // representation/field type from the old descriptor.
   if (old_details.kind() == new_kind_) {
-    new_constness_ = kMutable;
+    new_constness_ = GeneralizeConstness(constness, old_details.constness());
 
     Representation old_representation = old_details.representation();
     new_representation_ = representation.generalize(old_representation);
 
     Handle<FieldType> old_field_type =
         GetOrComputeFieldType(old_descriptors_, modified_descriptor_,
                               old_details.location(), new_representation_);
 
     new_field_type_ =
         Map::GeneralizeFieldType(old_representation, old_field_type,
@@ skipping 30 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_;
 }
 
+void MapUpdater::GeneralizeField(Handle<Map> map, int modify_index,
+                                 PropertyConstness new_constness,
+                                 Representation new_representation,
+                                 Handle<FieldType> new_field_type) {
+  Map::GeneralizeField(map, modify_index, new_constness, new_representation,
+                       new_field_type);
+
+  DCHECK_EQ(*old_descriptors_, old_map_->instance_descriptors());
+}
+
 MapUpdater::State MapUpdater::CopyGeneralizeAllFields(const char* reason) {
   result_map_ = Map::CopyGeneralizeAllFields(old_map_, new_elements_kind_,
                                              modified_descriptor_, 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
@@ skipping 18 matching lines @@
   if (FLAG_trace_generalization) {
     old_map_->PrintGeneralization(
         stdout, "uninitialized field", modified_descriptor_, old_nof_, old_nof_,
         false, old_representation, new_representation_,
         handle(old_descriptors_->GetFieldType(modified_descriptor_), isolate_),
         MaybeHandle<Object>(), new_field_type_, MaybeHandle<Object>());
   }
   Handle<Map> field_owner(old_map_->FindFieldOwner(modified_descriptor_),
                           isolate_);
 
-  Map::GeneralizeField(field_owner, modified_descriptor_, new_representation_,
-                       new_field_type_);
+  GeneralizeField(field_owner, modified_descriptor_, new_constness_,
+                  new_representation_, new_field_type_);
   // Check that the descriptor array was updated.
   DCHECK(old_descriptors_->GetDetails(modified_descriptor_)
              .representation()
              .Equals(new_representation_));
   DCHECK(old_descriptors_->GetFieldType(modified_descriptor_)
              ->NowIs(new_field_type_));
 
   result_map_ = old_map_;
   state_ = kEnd;
   return state_;  // Done.
@@ skipping 22 matching lines @@
   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 CopyGeneralizeAllFields("GenAll_RootModification1");
     }
     if (old_details.location() != kField) {
       return CopyGeneralizeAllFields("GenAll_RootModification2");
     }
-    DCHECK_EQ(kMutable, old_details.constness());
-    if (!new_representation_.fits_into(old_details.representation())) {
+    if (new_constness_ != old_details.constness()) {
       return CopyGeneralizeAllFields("GenAll_RootModification3");
     }
+    if (!new_representation_.fits_into(old_details.representation())) {
+      return CopyGeneralizeAllFields("GenAll_RootModification4");
+    }
+
     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 CopyGeneralizeAllFields("GenAll_RootModification4");
+      return CopyGeneralizeAllFields("GenAll_RootModification5");
     }
   }
 
   // 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 15 matching lines @@
 
     // 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 CopyGeneralizeAllFields("GenAll_Incompatible");
     }
-    // Check if old constness fits into tmp constness.
-    if (!IsGeneralizableTo(old_details.constness(), tmp_details.constness())) {
+    PropertyConstness tmp_constness = tmp_details.constness();
+    if (!IsGeneralizableTo(old_details.constness(), tmp_constness)) {
       break;
     }
-    // Check if old location fits into tmp location.
     if (!IsGeneralizableTo(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;
     }
 
     if (tmp_details.location() == kField) {
       Handle<FieldType> old_field_type =
           GetOrComputeFieldType(i, old_details.location(), tmp_representation);
-      Map::GeneralizeField(tmp_map, i, tmp_representation, old_field_type);
+      GeneralizeField(tmp_map, i, tmp_constness, tmp_representation,
+                      old_field_type);
     } else {
       // kDescriptor: Check that the value matches.
       if (!EqualImmutableValues(GetValue(i), tmp_descriptors->GetValue(i))) {
         break;
       }
     }
     DCHECK(!tmp_map->is_deprecated());
     target_map_ = tmp_map;
   }
 
   // Directly change the map if the target map is more general.
   int target_nof = target_map_->NumberOfOwnDescriptors();
   if (target_nof == old_nof_) {
 #ifdef DEBUG
     if (modified_descriptor_ >= 0) {
       DescriptorArray* target_descriptors = target_map_->instance_descriptors();
       PropertyDetails details =
           target_descriptors->GetDetails(modified_descriptor_);
       DCHECK_EQ(new_kind_, details.kind());
       DCHECK_EQ(new_attributes_, details.attributes());
+      DCHECK(IsGeneralizableTo(new_constness_, details.constness()));
       DCHECK_EQ(new_location_, details.location());
       DCHECK(new_representation_.fits_into(details.representation()));
       if (new_location_ == kField) {
         DCHECK_EQ(kField, details.location());
         DCHECK(new_field_type_->NowIs(
             target_descriptors->GetFieldType(modified_descriptor_)));
       } else {
         DCHECK(details.location() == kField ||
                EqualImmutableValues(*new_value_, target_descriptors->GetValue(
                                                      modified_descriptor_)));
@@ skipping 88 matching lines @@
     // Note: failed values equality check does not invalidate per-object
     // property constness.
     PropertyLocation next_location =
         old_details.location() == kField ||
                 target_details.location() == kField ||
                 !EqualImmutableValues(target_descriptors->GetValue(i),
                                       GetValue(i))
             ? kField
             : kDescriptor;
 
-    // TODO(ishell): remove once constant field tracking is done.
-    if (next_location == kField) next_constness = kMutable;
+    if (!FLAG_track_constant_fields && next_location == kField) {
+      next_constness = kMutable;
+    }
     // Ensure that mutable values are stored in fields.
     DCHECK_IMPLIES(next_constness == kMutable, next_location == kField);
 
     Representation next_representation =
         old_details.representation().generalize(
             target_details.representation());
 
     if (next_location == kField) {
       Handle<FieldType> old_field_type =
           GetOrComputeFieldType(i, old_details.location(), next_representation);
@@ skipping 18 matching lines @@
       }
       current_offset += d.GetDetails().field_width_in_words();
       new_descriptors->Set(i, &d);
     } else {
       DCHECK_EQ(kDescriptor, next_location);
       DCHECK_EQ(kConst, next_constness);
 
       Handle<Object> value(GetValue(i), isolate_);
       Descriptor d;
       if (next_kind == kData) {
+        DCHECK(!FLAG_track_constant_fields);
         d = Descriptor::DataConstant(key, value, next_attributes);
       } else {
         DCHECK_EQ(kAccessor, next_kind);
         d = Descriptor::AccessorConstant(key, value, next_attributes);
       }
       new_descriptors->Set(i, &d);
     }
   }
 
   // Take "updated" old_descriptor entries.
   // |target_nof| -> |old_nof|
   for (int i = target_nof; i < old_nof_; ++i) {
     PropertyDetails old_details = GetDetails(i);
     Handle<Name> key(GetKey(i), isolate_);
 
     PropertyKind next_kind = old_details.kind();
     PropertyAttributes next_attributes = old_details.attributes();
     PropertyConstness next_constness = old_details.constness();
     PropertyLocation next_location = old_details.location();
     Representation next_representation = old_details.representation();
 
     Descriptor d;
     if (next_location == kField) {
-      DCHECK_EQ(kMutable, next_constness);
       Handle<FieldType> old_field_type =
           GetOrComputeFieldType(i, old_details.location(), next_representation);
 
       Handle<Object> wrapped_type(Map::WrapFieldType(old_field_type));
       Descriptor d;
       if (next_kind == kData) {
+        DCHECK_IMPLIES(!FLAG_track_constant_fields, next_constness == kMutable);
         d = Descriptor::DataField(key, current_offset, next_attributes,
                                   next_constness, next_representation,
                                   wrapped_type);
       } else {
         // TODO(ishell): mutable accessors are not implemented yet.
         UNIMPLEMENTED();
       }
       current_offset += d.GetDetails().field_width_in_words();
       new_descriptors->Set(i, &d);
     } else {
@@ skipping 120 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