[runtime][ic] Constant field tracking support.

test/cctest/test-field-type-tracking.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 <stdlib.h>
 #include <utility>
 
 #include "test/cctest/test-api.h"
 
 #include "src/v8.h"
@@ skipping 157 matching lines @@
     Init(index, kAccessor, attrs, kConst, kDescriptor, Representation::Tagged(),
          FieldType::Any(isolate_));
   }
 
   void SetAccessorField(int index) {
     SetAccessorField(index, attributes_[index]);
   }
 
   void SetDataConstant(int index, PropertyAttributes attrs,
                        Handle<JSFunction> value) {
-    Init(index, kData, attrs, kConst, kDescriptor, Representation::HeapObject(),
-         value);
+    if (FLAG_track_constant_fields) {
+      Handle<FieldType> field_type(FieldType::Class(value->map()), isolate_);
+      Init(index, kData, attrs, kConst, kField, Representation::HeapObject(),
+           field_type);
+
+    } else {
+      Init(index, kData, attrs, kConst, kDescriptor,
+           Representation::HeapObject(), value);
+    }
   }
 
   void SetDataConstant(int index, Handle<JSFunction> value) {
     SetDataConstant(index, attributes_[index], value);
   }
 
   void SetAccessorConstant(int index, PropertyAttributes attrs,
                            Handle<Object> getter, Handle<Object> setter) {
     Init(index, kAccessor, attrs, kConst, kDescriptor, Representation::Tagged(),
          getter);
@@ skipping 59 matching lines @@
         FieldType* type = descriptors->GetFieldType(descriptor);
         return FieldType::cast(expected_value) == type;
       } else {
         // kAccessor
         UNREACHABLE();
         return false;
       }
     } else {
       // kDescriptor
       if (details.kind() == kData) {
+        CHECK(!FLAG_track_constant_fields);
         return value == expected_value;
       } else {
         // kAccessor
         if (value == expected_value) return true;
         if (!value->IsAccessorPair()) return false;
         AccessorPair* pair = AccessorPair::cast(value);
         return pair->Equals(expected_value, *setter_values_[descriptor]);
       }
     }
     UNREACHABLE();
@@ skipping 39 matching lines @@
   Handle<Map> AddDataField(Handle<Map> map, PropertyAttributes attributes,
                            PropertyConstness constness,
                            Representation representation,
                            Handle<FieldType> heap_type) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataField(property_index, attributes, constness, representation,
                  heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
-    return Map::CopyWithField(map, name, heap_type, attributes, representation,
-                              INSERT_TRANSITION)
+    return Map::CopyWithField(map, name, heap_type, attributes, constness,
+                              representation, INSERT_TRANSITION)
         .ToHandleChecked();
   }
 
   Handle<Map> AddDataConstant(Handle<Map> map, PropertyAttributes attributes,
                               Handle<JSFunction> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataConstant(property_index, attributes, value);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::CopyWithConstant(map, name, value, attributes,
                                  INSERT_TRANSITION)
         .ToHandleChecked();
   }
 
   Handle<Map> TransitionToDataField(Handle<Map> map,
                                     PropertyAttributes attributes,
                                     PropertyConstness constness,
                                     Representation representation,
                                     Handle<FieldType> heap_type,
                                     Handle<Object> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataField(property_index, attributes, constness, representation,
                  heap_type);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::TransitionToDataProperty(
-        map, name, value, attributes, Object::CERTAINLY_NOT_STORE_FROM_KEYED);
+        map, name, value, attributes, constness,
+        Object::CERTAINLY_NOT_STORE_FROM_KEYED);
   }
 
   Handle<Map> TransitionToDataConstant(Handle<Map> map,
                                        PropertyAttributes attributes,
                                        Handle<JSFunction> value) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataConstant(property_index, attributes, value);
 
     Handle<String> name = MakeName("prop", property_index);
     return Map::TransitionToDataProperty(
-        map, name, value, attributes, Object::CERTAINLY_NOT_STORE_FROM_KEYED);
+        map, name, value, attributes, kConst,
+        Object::CERTAINLY_NOT_STORE_FROM_KEYED);
   }
 
   Handle<Map> FollowDataTransition(Handle<Map> map,
                                    PropertyAttributes attributes,
                                    PropertyConstness constness,
                                    Representation representation,
                                    Handle<FieldType> heap_type) {
     CHECK_EQ(number_of_properties_, map->NumberOfOwnDescriptors());
     int property_index = number_of_properties_++;
     SetDataField(property_index, attributes, constness, representation,
@@ skipping 108 matching lines @@
 
   CHECK(!new_map->is_deprecated());
   CHECK(new_map->is_stable());
   CHECK(expectations.Check(*new_map));
 
   Handle<Map> new_map2 = Map::ReconfigureProperty(
       map, 0, kData, NONE, Representation::None(), none_type);
   CHECK_EQ(*new_map, *new_map2);
 
   Handle<Object> value(Smi::kZero, isolate);
-  Handle<Map> prepared_map = Map::PrepareForDataProperty(new_map, 0, value);
+  Handle<Map> prepared_map =
+      Map::PrepareForDataProperty(new_map, 0, kConst, value);
   // None to Smi generalization is trivial, map does not change.
   CHECK_EQ(*new_map, *prepared_map);
 
   expectations.SetDataField(0, NONE, kMutable, Representation::Smi(), any_type);
   CHECK(prepared_map->is_stable());
   CHECK(expectations.Check(*prepared_map));
 
   // Now create an object with |map|, migrate it to |prepared_map| and ensure
   // that the data property is uninitialized.
   Factory* factory = isolate->factory();
@@ skipping 89 matching lines @@
 
   // Create a map, add required properties to it and initialize expectations.
   Handle<Map> initial_map = Map::Create(isolate, 0);
   Handle<Map> map = initial_map;
   Handle<Map> detach_point_map;
   for (int i = 0; i < kPropCount; i++) {
     if (i == property_index) {
       map = expectations.AddDataField(map, NONE, from.constness,
                                       from.representation, from.type);
     } else {
-      map = expectations.AddDataField(map, NONE, kMutable,
+      map = expectations.AddDataField(map, NONE, kDefaultFieldConstness,
                                       Representation::Smi(), any_type);
       if (i == detach_property_at_index) {
         detach_point_map = map;
       }
     }
   }
   CHECK(!map->is_deprecated());
   CHECK(map->is_stable());
   CHECK(expectations.Check(*map));
 
   Zone zone(isolate->allocator(), ZONE_NAME);
 
   if (is_detached_map) {
     detach_point_map = Map::ReconfigureProperty(
         detach_point_map, detach_property_at_index, kData, NONE,
         Representation::Tagged(), any_type);
-    expectations.SetDataField(detach_property_at_index, kMutable,
+    expectations.SetDataField(detach_property_at_index, kDefaultFieldConstness,
                               Representation::Tagged(), any_type);
     CHECK(map->is_deprecated());
     CHECK(expectations.Check(*detach_point_map,
                              detach_point_map->NumberOfOwnDescriptors()));
   }
 
   // Create new maps by generalizing representation of propX field.
   Handle<Map> field_owner(map->FindFieldOwner(property_index), isolate);
   CompilationDependencies dependencies(isolate, &zone);
   CHECK(!dependencies.HasAborted());
@@ skipping 467 matching lines @@
   Handle<Map> updated_map = Map::Update(map);
   CHECK_EQ(*new_map, *updated_map);
 }
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeSmiFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kConst, Representation::Double(), any_type},
+        {kConst, Representation::Double(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kMutable, Representation::Double(), any_type},
+        {kMutable, Representation::Double(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kMutable, Representation::Smi(), any_type},
+        {kConst, Representation::Double(), any_type},
+        {kMutable, Representation::Double(), any_type});
+  }
+
   TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::Double(), any_type});
 }
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeSmiFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kConst, Representation::Tagged(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kMutable, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kMutable, Representation::Smi(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+  }
+
   TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeDoubleFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Double(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kConst, Representation::Tagged(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::Double(), any_type},
+        {kMutable, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kMutable, Representation::Double(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+  }
+
   TestReconfigureDataFieldAttribute_GeneralizeField(
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeHeapObjFieldToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
+  // Check generalizations that trigger deopts.
+  if (FLAG_track_constant_fields) {
+    TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
+        {kConst, Representation::HeapObject(), current_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kConst, Representation::HeapObject(), expected_type});
+
+    // Currently, kConst to kMutable migration causes map change, therefore
+    // non-trivial generalization.
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::HeapObject(), current_type},
+        {kMutable, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), expected_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
+        {kMutable, Representation::HeapObject(), current_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), expected_type});
+  }
   TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), current_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
+  // Check generalizations that do not trigger deopts.
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
+        {kConst, Representation::HeapObject(), any_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kConst, Representation::HeapObject(), any_type}, false);
+
+    // Currently, kConst to kMutable migration causes map change, therefore
+    // non-trivial generalization.
+    TestReconfigureDataFieldAttribute_GeneralizeField(
+        {kConst, Representation::HeapObject(), any_type},
+        {kMutable, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), any_type});
+
+    TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
+        {kMutable, Representation::HeapObject(), any_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), any_type}, false);
+  }
   TestReconfigureDataFieldAttribute_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), any_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
 TEST(ReconfigureDataFieldAttribute_GeneralizeHeapObjectFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
@@ skipping 229 matching lines @@
     }
 
     Handle<Map> AddPropertyAtBranch(int branch_id, Expectations& expectations,
                                     Handle<Map> map) {
       CHECK(branch_id == 1 || branch_id == 2);
       Handle<JSFunction> js_func = branch_id == 1 ? js_func1_ : js_func2_;
       return expectations.AddDataConstant(map, NONE, js_func);
     }
 
     void UpdateExpectations(int property_index, Expectations& expectations) {
-      expectations.SetDataField(property_index, kMutable,
+      PropertyConstness expected_constness =
+          FLAG_track_constant_fields ? kConst : kMutable;
+      expectations.SetDataField(property_index, expected_constness,
                                 Representation::HeapObject(), function_type_);
     }
   };
 
   TestConfig config;
-  // Two branches are "incompatible" so the |map1| should be deprecated.
-  CheckDeprecated checker;
-  TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
+  if (FLAG_track_constant_fields) {
+    CheckSameMap checker;
+    TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
+
+  } else {
+    // Two branches are "incompatible" so the |map1| should be deprecated.
+    CheckDeprecated checker;
+    TestReconfigureProperty_CustomPropertyAfterTargetMap(config, checker);
+  }
 }
 
 
 TEST(ReconfigureDataFieldAttribute_DataConstantToAccConstantAfterTargetMap) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   struct TestConfig {
     Handle<JSFunction> js_func_;
     Handle<AccessorPair> pair_;
@@ skipping 102 matching lines @@
     TestConfig() { pair_ = CreateAccessorPair(true, true); }
 
     Handle<Map> AddPropertyAtBranch(int branch_id, Expectations& expectations,
                                     Handle<Map> map) {
       CHECK(branch_id == 1 || branch_id == 2);
       if (branch_id == 1) {
         return expectations.AddAccessorConstant(map, NONE, pair_);
       } else {
         Isolate* isolate = CcTest::i_isolate();
         Handle<FieldType> any_type = FieldType::Any(isolate);
-        return expectations.AddDataField(map, NONE, kMutable,
+        return expectations.AddDataField(map, NONE, kDefaultFieldConstness,
                                          Representation::Smi(), any_type);
       }
     }
 
     void UpdateExpectations(int property_index, Expectations& expectations) {}
   };
 
   TestConfig config;
   // These are completely separate branches in transition tree.
   CheckUnrelated checker;
@@ skipping 191 matching lines @@
     CHECK_EQ(*updated_map, transitioned_map);
   }
 }
 
 TEST(ReconfigureElementsKind_GeneralizeSmiFieldToDouble) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kConst, Representation::Double(), any_type},
+        {kConst, Representation::Double(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kMutable, Representation::Double(), any_type},
+        {kMutable, Representation::Double(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kMutable, Representation::Smi(), any_type},
+        {kConst, Representation::Double(), any_type},
+        {kMutable, Representation::Double(), any_type});
+  }
   TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::Double(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeSmiFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kConst, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Smi(), any_type},
+        {kMutable, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kMutable, Representation::Smi(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+  }
   TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeDoubleFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Double(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kConst, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::Double(), any_type},
+        {kMutable, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kMutable, Representation::Double(), any_type},
+        {kConst, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Tagged(), any_type});
+  }
   TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::Double(), any_type},
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 TEST(ReconfigureElementsKind_GeneralizeHeapObjFieldToHeapObj) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
   Handle<FieldType> current_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> new_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   Handle<FieldType> expected_type = any_type;
 
+  // Check generalizations that trigger deopts.
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeFieldTrivial(
+        {kConst, Representation::HeapObject(), current_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kConst, Representation::HeapObject(), expected_type});
+
+    // Currently, kConst to kMutable migration causes map change, therefore
+    // non-trivial generalization.
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::HeapObject(), current_type},
+        {kMutable, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), expected_type});
+
+    TestReconfigureElementsKind_GeneralizeFieldTrivial(
+        {kMutable, Representation::HeapObject(), current_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), expected_type});
+  }
   TestReconfigureElementsKind_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), current_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), expected_type});
   current_type = expected_type;
 
+  // Check generalizations that do not trigger deopts.
   new_type = FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeFieldTrivial(
+        {kConst, Representation::HeapObject(), any_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kConst, Representation::HeapObject(), any_type}, false);
+
+    // Currently, kConst to kMutable migration causes map change, therefore
+    // non-trivial generalization.
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::HeapObject(), any_type},
+        {kMutable, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeFieldTrivial(
+        {kMutable, Representation::HeapObject(), any_type},
+        {kConst, Representation::HeapObject(), new_type},
+        {kMutable, Representation::HeapObject(), any_type}, false);
+  }
   TestReconfigureElementsKind_GeneralizeFieldTrivial(
       {kMutable, Representation::HeapObject(), any_type},
       {kMutable, Representation::HeapObject(), new_type},
       {kMutable, Representation::HeapObject(), any_type}, false);
 }
 
 TEST(ReconfigureElementsKind_GeneralizeHeapObjectFieldToTagged) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Handle<FieldType> any_type = FieldType::Any(isolate);
   Handle<FieldType> value_type =
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
+  if (FLAG_track_constant_fields) {
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::HeapObject(), value_type},
+        {kConst, Representation::Smi(), any_type},
+        {kConst, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kConst, Representation::HeapObject(), value_type},
+        {kMutable, Representation::Smi(), any_type},
+        {kMutable, Representation::Tagged(), any_type});
+
+    TestReconfigureElementsKind_GeneralizeField(
+        {kMutable, Representation::HeapObject(), value_type},
+        {kConst, Representation::Smi(), any_type},
+        {kMutable, Representation::Tagged(), any_type});
+  }
   TestReconfigureElementsKind_GeneralizeField(
       {kMutable, Representation::HeapObject(), value_type},
       {kMutable, Representation::Smi(), any_type},
       {kMutable, Representation::Tagged(), any_type});
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // A set of tests checking split map deprecation.
 //
 
@@ skipping 45 matching lines @@
   // transition tree.
   CHECK(map->is_deprecated());
   CHECK(!split_map->is_deprecated());
   CHECK(map2->is_stable());
   CHECK(!map2->is_deprecated());
 
   // Fill in transition tree of |map2| so that it can't have more transitions.
   for (int i = 0; i < TransitionArray::kMaxNumberOfTransitions; i++) {
     CHECK(TransitionArray::CanHaveMoreTransitions(map2));
     Handle<String> name = MakeName("foo", i);
-    Map::CopyWithField(map2, name, any_type, NONE, Representation::Smi(),
-                       INSERT_TRANSITION)
+    Map::CopyWithField(map2, name, any_type, NONE, kMutable,
+                       Representation::Smi(), INSERT_TRANSITION)
         .ToHandleChecked();
   }
   CHECK(!TransitionArray::CanHaveMoreTransitions(map2));
 
   // Try to update |map|, since there is no place for propX transition at |map2|
   // |map| should become "copy-generalized".
   Handle<Map> updated_map = Map::Update(map);
   CHECK(updated_map->GetBackPointer()->IsUndefined(isolate));
 
   for (int i = 0; i < kPropCount; i++) {
@@ skipping 152 matching lines @@
       FieldType::Class(Map::Create(isolate, 0), isolate);
 
   struct TestConfig {
     Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
       Isolate* isolate = CcTest::i_isolate();
       Handle<FieldType> any_type = FieldType::Any(isolate);
 
       // Add one more transition to |map| in order to prevent descriptors
       // ownership.
       CHECK(map->owns_descriptors());
-      Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
+      Map::CopyWithField(map, MakeString("foo"), any_type, NONE, kMutable,
                          Representation::Smi(), INSERT_TRANSITION)
           .ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       Handle<Symbol> frozen_symbol(map->GetHeap()->frozen_symbol());
       expectations.SetElementsKind(DICTIONARY_ELEMENTS);
       return Map::CopyForPreventExtensions(map, NONE, frozen_symbol,
                                            "CopyForPreventExtensions");
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
@@ skipping 61 matching lines @@
       prototype_ = factory->NewJSObjectFromMap(Map::Create(isolate, 0));
     }
 
     Handle<Map> Transition(Handle<Map> map, Expectations& expectations) {
       Isolate* isolate = CcTest::i_isolate();
       Handle<FieldType> any_type = FieldType::Any(isolate);
 
       // Add one more transition to |map| in order to prevent descriptors
       // ownership.
       CHECK(map->owns_descriptors());
-      Map::CopyWithField(map, MakeString("foo"), any_type, NONE,
+      Map::CopyWithField(map, MakeString("foo"), any_type, NONE, kMutable,
                          Representation::Smi(), INSERT_TRANSITION)
           .ToHandleChecked();
       CHECK(!map->owns_descriptors());
 
       return Map::TransitionToPrototype(map, prototype_, REGULAR_PROTOTYPE);
     }
     // TODO(ishell): remove once IS_PROTO_TRANS_ISSUE_FIXED is removed.
     bool generalizes_representations() const {
       return !IS_PROTO_TRANS_ISSUE_FIXED;
     }
@@ skipping 250 matching lines @@
   CHECK(sloppy_map->is_stable());
 
   Handle<JSFunction> js_func1 =
       factory->NewFunction(sloppy_map, info, isolate->native_context());
   TransitionToDataConstantOperator transition_op1(js_func1);
 
   Handle<JSFunction> js_func2 =
       factory->NewFunction(sloppy_map, info, isolate->native_context());
   TransitionToDataConstantOperator transition_op2(js_func2);
 
-  FieldGeneralizationChecker checker(
-      kPropCount - 1, kMutable, Representation::HeapObject(), function_type);
-  TestTransitionTo(transition_op1, transition_op2, checker);
+  if (FLAG_track_constant_fields) {
+    SameMapChecker checker;
+    TestTransitionTo(transition_op1, transition_op2, checker);
+
+  } else {
+    FieldGeneralizationChecker checker(
+        kPropCount - 1, kMutable, Representation::HeapObject(), function_type);
+    TestTransitionTo(transition_op1, transition_op2, checker);
+  }
 }
 
 
 TEST(TransitionDataConstantToDataField) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Handle<FieldType> any_type = FieldType::Any(isolate);
 
@@ skipping 55 matching lines @@
   Handle<Object> obj =
       Object::NewStorageFor(isolate, isolate->factory()->uninitialized_value(),
                             Representation::Double());
   CHECK(obj->IsMutableHeapNumber());
   CHECK_EQ(kHoleNanInt64, HeapNumber::cast(*obj)->value_as_bits());
 
   obj = Object::NewStorageFor(isolate, mhn, Representation::Double());
   CHECK(obj->IsMutableHeapNumber());
   CHECK_EQ(kHoleNanInt64, HeapNumber::cast(*obj)->value_as_bits());
 }