Track representations of fields

src/objects-inl.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 40 matching lines @@
 
 namespace v8 {
 namespace internal {
 
 PropertyDetails::PropertyDetails(Smi* smi) {
   value_ = smi->value();
 }
 
 
 Smi* PropertyDetails::AsSmi() {
-  return Smi::FromInt(value_);
+  int value = value_ << 1;
+  return Smi::FromInt(value >> 1);
 }
 
 
 PropertyDetails PropertyDetails::AsDeleted() {
   Smi* smi = Smi::FromInt(value_ | DeletedField::encode(1));
   return PropertyDetails(smi);
 }
 
 
 #define TYPE_CHECKER(type, instancetype)                                \
@@ skipping 1396 matching lines @@
   MaybeObject* maybe = GetElementsTransitionMap(GetIsolate(), elements_kind);
   Map* map;
   if (!maybe->To(&map)) return maybe;
   set_map(map);
   initialize_elements();
 
   return this;
 }
 
 
-MaybeObject* JSObject::AddFastPropertyUsingMap(Map* map) {
-  ASSERT(this->map()->NumberOfOwnDescriptors() + 1 ==
-         map->NumberOfOwnDescriptors());
-  if (this->map()->unused_property_fields() == 0) {
-    int new_size = properties()->length() + map->unused_property_fields() + 1;
-    FixedArray* new_properties;
-    MaybeObject* maybe_properties = properties()->CopySize(new_size);
-    if (!maybe_properties->To(&new_properties)) return maybe_properties;
-    set_properties(new_properties);
-  }
-  set_map(map);
-  return this;
-}
-
-
 MaybeObject* JSObject::TransitionToMap(Map* map) {
   ASSERT(this->map()->inobject_properties() == map->inobject_properties());
   ElementsKind expected_kind = this->map()->elements_kind();
   if (map->elements_kind() != expected_kind) {
     MaybeObject* maybe_map = map->AsElementsKind(expected_kind);
     if (!maybe_map->To(&map)) return maybe_map;
   }
   int total_size =
       map->NumberOfOwnDescriptors() + map->unused_property_fields();
   int out_of_object = total_size - map->inobject_properties();
   if (out_of_object != properties()->length()) {
     FixedArray* new_properties;
     MaybeObject* maybe_properties = properties()->CopySize(out_of_object);
     if (!maybe_properties->To(&new_properties)) return maybe_properties;
     set_properties(new_properties);
   }
   set_map(map);
   return this;
 }
 
 
+MaybeObject* JSObject::MigrateInstance() {
+  // Converting any field to the most specific type will cause the
+  // GeneralizeFieldStorage algorithm to create the most general existing
+  // transition that matches the object. This achieves what is needed.
+  return GeneralizeFieldStorage(0, SMI);
+}
+
+
 Handle<String> JSObject::ExpectedTransitionKey(Handle<Map> map) {
   AssertNoAllocation no_gc;
   if (!map->HasTransitionArray()) return Handle<String>::null();
   TransitionArray* transitions = map->transitions();
   if (!transitions->IsSimpleTransition()) return Handle<String>::null();
   int transition = TransitionArray::kSimpleTransitionIndex;
   PropertyDetails details = transitions->GetTargetDetails(transition);
   Name* name = transitions->GetKey(transition);
   if (details.type() != FIELD) return Handle<String>::null();
   if (details.attributes() != NONE) return Handle<String>::null();
@@ skipping 708 matching lines @@
   return GetKey(GetSortedKeyIndex(descriptor_number));
 }
 
 
 void DescriptorArray::SetSortedKey(int descriptor_index, int pointer) {
   PropertyDetails details = GetDetails(descriptor_index);
   set(ToDetailsIndex(descriptor_index), details.set_pointer(pointer).AsSmi());
 }
 
 
+void DescriptorArray::SetStorageType(int descriptor_index, StorageType type) {
+  PropertyDetails details = GetDetails(descriptor_index);
+  set(ToDetailsIndex(descriptor_index), details.set_storage_type(type).AsSmi());
+}
+
+
+void DescriptorArray::InitializeStorageTypes(StorageType storage_type) {
+  int length = number_of_descriptors();
+  for (int i = 0; i < length; i++) {
+    PropertyDetails details = GetDetails(i);
+    set(ToDetailsIndex(i), details.set_storage_type(storage_type).AsSmi());
+  }
+}
+
+
 Object** DescriptorArray::GetValueSlot(int descriptor_number) {
   ASSERT(descriptor_number < number_of_descriptors());
   return HeapObject::RawField(
       reinterpret_cast<HeapObject*>(this),
       OffsetOfElementAt(ToValueIndex(descriptor_number)));
 }
 
 
 Object* DescriptorArray::GetValue(int descriptor_number) {
   ASSERT(descriptor_number < number_of_descriptors());
@@ skipping 1276 matching lines @@
          has_slow_elements_kind() || has_external_array_elements());
   set_bit_field3(IsObserved::update(bit_field3(), is_observed));
 }
 
 
 bool Map::is_observed() {
   return IsObserved::decode(bit_field3());
 }
 
 
+void Map::invalidate_transition() {
+  set_bit_field3(InvalidTransition::update(bit_field3(), true));
+}
+
+
+bool Map::is_invalid_transition() {
+  if (!FLAG_track_fields) return false;
+  return InvalidTransition::decode(bit_field3());
+}
+
+
+bool Map::CanTransitionBeInvalidated() {
+  if (!FLAG_track_fields) return false;
+  int descriptor = LastAdded();
+  for (int i = 0; i <= descriptor; i++) {
+    PropertyDetails details = instance_descriptors()->GetDetails(i);
+    if (details.storage_type() != TAGGED) return true;
+  }
+  return false;
+}
+
+
 void Map::NotifyLeafMapLayoutChange() {
   dependent_code()->DeoptimizeDependentCodeGroup(
       GetIsolate(),
       DependentCode::kPrototypeCheckGroup);
 }
 
 
 bool Map::CanOmitPrototypeChecks() {
   return !HasTransitionArray() && !is_dictionary_map() &&
          FLAG_omit_prototype_checks_for_leaf_maps;
@@ skipping 2571 matching lines @@
 #undef WRITE_UINT32_FIELD
 #undef READ_SHORT_FIELD
 #undef WRITE_SHORT_FIELD
 #undef READ_BYTE_FIELD
 #undef WRITE_BYTE_FIELD
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_OBJECTS_INL_H_