correctly invalidate global cells

src/property-details.h

 // Copyright 2012 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.
 
 #ifndef V8_PROPERTY_DETAILS_H_
 #define V8_PROPERTY_DETAILS_H_
 
 #include "include/v8.h"
 #include "src/allocation.h"
 #include "src/utils.h"
@@ skipping 169 matching lines @@
 
 static const int kDescriptorIndexBitCount = 10;
 // The maximum number of descriptors we want in a descriptor array (should
 // fit in a page).
 static const int kMaxNumberOfDescriptors =
     (1 << kDescriptorIndexBitCount) - 2;
 static const int kInvalidEnumCacheSentinel =
     (1 << kDescriptorIndexBitCount) - 1;
 
 
+enum class PropertyCellType {
+  kUninitialized,        // Cell is deleted or not yet defined.
+  kUndefined,            // The PREMONOMORPHIC of property cells.
+  kConstant,             // Cell has been assigned only once.
+  kMutable,              // Cell will no longer be tracked as constant.
+  kDeleted = kConstant,  // like kUninitialized, but for cells already deleted.
+  kInvalid = kMutable,   // For dictionaries not holding cells.
+};
+
+
 // PropertyDetails captures type and attributes for a property.
 // They are used both in property dictionaries and instance descriptors.
 class PropertyDetails BASE_EMBEDDED {
  public:
-  PropertyDetails(PropertyAttributes attributes,
-                  PropertyType type,
-                  int index) {
-    value_ = TypeField::encode(type)
-        | AttributesField::encode(attributes)
-        | DictionaryStorageField::encode(index);
+  PropertyDetails(PropertyAttributes attributes, PropertyType type, int index,
+                  PropertyCellType cell_type) {
+    value_ = TypeField::encode(type) | AttributesField::encode(attributes) |
+             DictionaryStorageField::encode(index) |
+             PropertyCellTypeField::encode(cell_type);
 
     DCHECK(type == this->type());
     DCHECK(attributes == this->attributes());
   }
 
   PropertyDetails(PropertyAttributes attributes,
                   PropertyType type,
                   Representation representation,
                   int field_index = 0) {
     value_ = TypeField::encode(type)
         | AttributesField::encode(attributes)
         | RepresentationField::encode(EncodeRepresentation(representation))
         | FieldIndexField::encode(field_index);
   }
 
   PropertyDetails(PropertyAttributes attributes, PropertyKind kind,
                   PropertyLocation location, Representation representation,
                   int field_index = 0) {
     value_ = KindField::encode(kind) | LocationField::encode(location) |
              AttributesField::encode(attributes) |
              RepresentationField::encode(EncodeRepresentation(representation)) |
              FieldIndexField::encode(field_index);
   }
 
+  static PropertyDetails Empty() {
+    return PropertyDetails(NONE, DATA, 0, PropertyCellType::kInvalid);
+  }
+
   int pointer() const { return DescriptorPointer::decode(value_); }
 
-  PropertyDetails set_pointer(int i) { return PropertyDetails(value_, i); }
+  PropertyDetails set_pointer(int i) const {
+    return PropertyDetails(value_, i);
+  }
+
+  PropertyDetails set_cell_type(PropertyCellType type) const {
+    PropertyDetails details = *this;
+    details.value_ = PropertyCellTypeField::update(details.value_, type);
+    return details;
+  }
+
+  PropertyDetails set_index(int index) const {
+    PropertyDetails details = *this;
+    details.value_ = DictionaryStorageField::update(details.value_, index);
+    return details;
+  }
 
   PropertyDetails CopyWithRepresentation(Representation representation) const {
     return PropertyDetails(value_, representation);
   }
-  PropertyDetails CopyAddAttributes(PropertyAttributes new_attributes) {
+  PropertyDetails CopyAddAttributes(PropertyAttributes new_attributes) const {
     new_attributes =
         static_cast<PropertyAttributes>(attributes() | new_attributes);
     return PropertyDetails(value_, new_attributes);
   }
 
   // Conversion for storing details as Object*.
   explicit inline PropertyDetails(Smi* smi);
   inline Smi* AsSmi() const;
 
   static uint8_t EncodeRepresentation(Representation representation) {
@@ skipping 25 matching lines @@
 
   inline int field_width_in_words() const;
 
   static bool IsValidIndex(int index) {
     return DictionaryStorageField::is_valid(index);
   }
 
   bool IsReadOnly() const { return (attributes() & READ_ONLY) != 0; }
   bool IsConfigurable() const { return (attributes() & DONT_DELETE) == 0; }
   bool IsDontEnum() const { return (attributes() & DONT_ENUM) != 0; }
+  PropertyCellType cell_type() const {
+    return PropertyCellTypeField::decode(value_);
+  }
 
   // Bit fields in value_ (type, shift, size). Must be public so the
   // constants can be embedded in generated code.
   class KindField : public BitField<PropertyKind, 0, 1> {};
   class LocationField : public BitField<PropertyLocation, 1, 1> {};
   class AttributesField : public BitField<PropertyAttributes, 2, 3> {};
 
   // Bit fields for normalized objects.
-  class DictionaryStorageField : public BitField<uint32_t, 5, 24> {};
+  class PropertyCellTypeField : public BitField<PropertyCellType, 5, 2> {};
+  class DictionaryStorageField : public BitField<uint32_t, 7, 24> {};
 
   // Bit fields for fast objects.
   class RepresentationField : public BitField<uint32_t, 5, 4> {};
   class DescriptorPointer
       : public BitField<uint32_t, 9, kDescriptorIndexBitCount> {};  // NOLINT
   class FieldIndexField
       : public BitField<uint32_t, 9 + kDescriptorIndexBitCount,
                         kDescriptorIndexBitCount> {};  // NOLINT
 
   // NOTE: TypeField overlaps with KindField and LocationField.
@@ skipping 28 matching lines @@
   uint32_t value_;
 };
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PropertyAttributes& attributes);
 std::ostream& operator<<(std::ostream& os, const PropertyDetails& details);
 } }  // namespace v8::internal
 
 #endif  // V8_PROPERTY_DETAILS_H_