1 // Copyright 2012 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_PROPERTY_DETAILS_H_ 6 #define V8_PROPERTY_DETAILS_H_ 7 8 #include "include/v8.h" 9 #include "src/allocation.h" 10 // TODO(ishell): remove once FLAG_track_constant_fields is removed. 11 #include "src/flags.h" 12 #include "src/utils.h" 13 14 namespace v8 { 15 namespace internal { 16 17 // ES6 6.1.7.1 18 enum PropertyAttributes { 19 NONE = ::v8::None, 20 READ_ONLY = ::v8::ReadOnly, 21 DONT_ENUM = ::v8::DontEnum, 22 DONT_DELETE = ::v8::DontDelete, 23 24 ALL_ATTRIBUTES_MASK = READ_ONLY | DONT_ENUM | DONT_DELETE, 25 26 SEALED = DONT_DELETE, 27 FROZEN = SEALED | READ_ONLY, 28 29 ABSENT = 64, // Used in runtime to indicate a property is absent. 30 // ABSENT can never be stored in or returned from a descriptor's attributes 31 // bitfield. It is only used as a return value meaning the attributes of 32 // a non-existent property. 33 }; 34 35 36 enum PropertyFilter { 37 ALL_PROPERTIES = 0, 38 ONLY_WRITABLE = 1, 39 ONLY_ENUMERABLE = 2, 40 ONLY_CONFIGURABLE = 4, 41 SKIP_STRINGS = 8, 42 SKIP_SYMBOLS = 16, 43 ONLY_ALL_CAN_READ = 32, 44 ENUMERABLE_STRINGS = ONLY_ENUMERABLE | SKIP_SYMBOLS, 45 }; 46 // Enable fast comparisons of PropertyAttributes against PropertyFilters. 47 STATIC_ASSERT(ALL_PROPERTIES == static_cast<PropertyFilter>(NONE)); 48 STATIC_ASSERT(ONLY_WRITABLE == static_cast<PropertyFilter>(READ_ONLY)); 49 STATIC_ASSERT(ONLY_ENUMERABLE == static_cast<PropertyFilter>(DONT_ENUM)); 50 STATIC_ASSERT(ONLY_CONFIGURABLE == static_cast<PropertyFilter>(DONT_DELETE)); 51 STATIC_ASSERT(((SKIP_STRINGS | SKIP_SYMBOLS | ONLY_ALL_CAN_READ) & 52 ALL_ATTRIBUTES_MASK) == 0); 53 STATIC_ASSERT(ALL_PROPERTIES == 54 static_cast<PropertyFilter>(v8::PropertyFilter::ALL_PROPERTIES)); 55 STATIC_ASSERT(ONLY_WRITABLE == 56 static_cast<PropertyFilter>(v8::PropertyFilter::ONLY_WRITABLE)); 57 STATIC_ASSERT(ONLY_ENUMERABLE == 58 static_cast<PropertyFilter>(v8::PropertyFilter::ONLY_ENUMERABLE)); 59 STATIC_ASSERT(ONLY_CONFIGURABLE == static_cast<PropertyFilter>( 60 v8::PropertyFilter::ONLY_CONFIGURABLE)); 61 STATIC_ASSERT(SKIP_STRINGS == 62 static_cast<PropertyFilter>(v8::PropertyFilter::SKIP_STRINGS)); 63 STATIC_ASSERT(SKIP_SYMBOLS == 64 static_cast<PropertyFilter>(v8::PropertyFilter::SKIP_SYMBOLS)); 65 66 class Smi; 67 class TypeInfo; 68 69 // Order of kinds is significant. 70 // Must fit in the BitField PropertyDetails::KindField. 71 enum PropertyKind { kData = 0, kAccessor = 1 }; 72 73 // Order of modes is significant. 74 // Must fit in the BitField PropertyDetails::LocationField. 75 enum PropertyLocation { kField = 0, kDescriptor = 1 }; 76 77 // Order of modes is significant. 78 // Must fit in the BitField PropertyDetails::ConstnessField. 79 enum PropertyConstness { kMutable = 0, kConst = 1 }; 80 81 // TODO(ishell): remove once constant field tracking is done. 82 const PropertyConstness kDefaultFieldConstness = 83 FLAG_track_constant_fields ? kConst : kMutable; 84 85 class Representation { 86 public: 87 enum Kind { 88 kNone, 89 kInteger8, 90 kUInteger8, 91 kInteger16, 92 kUInteger16, 93 kSmi, 94 kInteger32, 95 kDouble, 96 kHeapObject, 97 kTagged, 98 kExternal, 99 kNumRepresentations 100 }; 101 102 Representation() : kind_(kNone) { } 103 104 static Representation None() { return Representation(kNone); } 105 static Representation Tagged() { return Representation(kTagged); } 106 static Representation Integer8() { return Representation(kInteger8); } 107 static Representation UInteger8() { return Representation(kUInteger8); } 108 static Representation Integer16() { return Representation(kInteger16); } 109 static Representation UInteger16() { return Representation(kUInteger16); } 110 static Representation Smi() { return Representation(kSmi); } 111 static Representation Integer32() { return Representation(kInteger32); } 112 static Representation Double() { return Representation(kDouble); } 113 static Representation HeapObject() { return Representation(kHeapObject); } 114 static Representation External() { return Representation(kExternal); } 115 116 static Representation FromKind(Kind kind) { return Representation(kind); } 117 118 bool Equals(const Representation& other) const { 119 return kind_ == other.kind_; 120 } 121 122 bool IsCompatibleForLoad(const Representation& other) const { 123 return (IsDouble() && other.IsDouble()) || 124 (!IsDouble() && !other.IsDouble()); 125 } 126 127 bool IsCompatibleForStore(const Representation& other) const { 128 return Equals(other); 129 } 130 131 bool is_more_general_than(const Representation& other) const { 132 if (kind_ == kExternal && other.kind_ == kNone) return true; 133 if (kind_ == kExternal && other.kind_ == kExternal) return false; 134 if (kind_ == kNone && other.kind_ == kExternal) return false; 135 136 DCHECK(kind_ != kExternal); 137 DCHECK(other.kind_ != kExternal); 138 if (IsHeapObject()) return other.IsNone(); 139 if (kind_ == kUInteger8 && other.kind_ == kInteger8) return false; 140 if (kind_ == kUInteger16 && other.kind_ == kInteger16) return false; 141 return kind_ > other.kind_; 142 } 143 144 bool fits_into(const Representation& other) const { 145 return other.is_more_general_than(*this) || other.Equals(*this); 146 } 147 148 Representation generalize(Representation other) { 149 if (other.fits_into(*this)) return *this; 150 if (other.is_more_general_than(*this)) return other; 151 return Representation::Tagged(); 152 } 153 154 int size() const { 155 DCHECK(!IsNone()); 156 if (IsInteger8() || IsUInteger8()) { 157 return sizeof(uint8_t); 158 } 159 if (IsInteger16() || IsUInteger16()) { 160 return sizeof(uint16_t); 161 } 162 if (IsInteger32()) { 163 return sizeof(uint32_t); 164 } 165 return kPointerSize; 166 } 167 168 Kind kind() const { return static_cast<Kind>(kind_); } 169 bool IsNone() const { return kind_ == kNone; } 170 bool IsInteger8() const { return kind_ == kInteger8; } 171 bool IsUInteger8() const { return kind_ == kUInteger8; } 172 bool IsInteger16() const { return kind_ == kInteger16; } 173 bool IsUInteger16() const { return kind_ == kUInteger16; } 174 bool IsTagged() const { return kind_ == kTagged; } 175 bool IsSmi() const { return kind_ == kSmi; } 176 bool IsSmiOrTagged() const { return IsSmi() || IsTagged(); } 177 bool IsInteger32() const { return kind_ == kInteger32; } 178 bool IsSmiOrInteger32() const { return IsSmi() || IsInteger32(); } 179 bool IsDouble() const { return kind_ == kDouble; } 180 bool IsHeapObject() const { return kind_ == kHeapObject; } 181 bool IsExternal() const { return kind_ == kExternal; } 182 bool IsSpecialization() const { 183 return IsInteger8() || IsUInteger8() || 184 IsInteger16() || IsUInteger16() || 185 IsSmi() || IsInteger32() || IsDouble(); 186 } 187 const char* Mnemonic() const; 188 189 private: 190 explicit Representation(Kind k) : kind_(k) { } 191 192 // Make sure kind fits in int8. 193 STATIC_ASSERT(kNumRepresentations <= (1 << kBitsPerByte)); 194 195 int8_t kind_; 196 }; 197 198 199 static const int kDescriptorIndexBitCount = 10; 200 // The maximum number of descriptors we want in a descriptor array (should 201 // fit in a page). 202 static const int kMaxNumberOfDescriptors = 203 (1 << kDescriptorIndexBitCount) - 2; 204 static const int kInvalidEnumCacheSentinel = 205 (1 << kDescriptorIndexBitCount) - 1; 206 207 enum class PropertyCellType { 208 // Meaningful when a property cell does not contain the hole. 209 kUndefined, // The PREMONOMORPHIC of property cells. 210 kConstant, // Cell has been assigned only once. 211 kConstantType, // Cell has been assigned only one type. 212 kMutable, // Cell will no longer be tracked as constant. 213 214 // Meaningful when a property cell contains the hole. 215 kUninitialized = kUndefined, // Cell has never been initialized. 216 kInvalidated = kConstant, // Cell has been deleted, invalidated or never 217 // existed. 218 219 // For dictionaries not holding cells. 220 kNoCell = kMutable, 221 }; 222 223 enum class PropertyCellConstantType { 224 kSmi, 225 kStableMap, 226 }; 227 228 229 // PropertyDetails captures type and attributes for a property. 230 // They are used both in property dictionaries and instance descriptors. 231 class PropertyDetails BASE_EMBEDDED { 232 public: 233 // Property details for dictionary mode properties/elements. 234 PropertyDetails(PropertyKind kind, PropertyAttributes attributes, int index, 235 PropertyCellType cell_type) { 236 value_ = KindField::encode(kind) | LocationField::encode(kField) | 237 AttributesField::encode(attributes) | 238 DictionaryStorageField::encode(index) | 239 PropertyCellTypeField::encode(cell_type); 240 } 241 242 // Property details for fast mode properties. 243 PropertyDetails(PropertyKind kind, PropertyAttributes attributes, 244 PropertyLocation location, PropertyConstness constness, 245 Representation representation, int field_index = 0) { 246 value_ = KindField::encode(kind) | AttributesField::encode(attributes) | 247 LocationField::encode(location) | 248 ConstnessField::encode(constness) | 249 RepresentationField::encode(EncodeRepresentation(representation)) | 250 FieldIndexField::encode(field_index); 251 } 252 253 static PropertyDetails Empty( 254 PropertyCellType cell_type = PropertyCellType::kNoCell) { 255 return PropertyDetails(kData, NONE, 0, cell_type); 256 } 257 258 int pointer() const { return DescriptorPointer::decode(value_); } 259 260 PropertyDetails set_pointer(int i) const { 261 return PropertyDetails(value_, i); 262 } 263 264 PropertyDetails set_cell_type(PropertyCellType type) const { 265 PropertyDetails details = *this; 266 details.value_ = PropertyCellTypeField::update(details.value_, type); 267 return details; 268 } 269 270 PropertyDetails set_index(int index) const { 271 PropertyDetails details = *this; 272 details.value_ = DictionaryStorageField::update(details.value_, index); 273 return details; 274 } 275 276 PropertyDetails CopyWithRepresentation(Representation representation) const { 277 return PropertyDetails(value_, representation); 278 } 279 PropertyDetails CopyWithConstness(PropertyConstness constness) const { 280 return PropertyDetails(value_, constness); 281 } 282 PropertyDetails CopyAddAttributes(PropertyAttributes new_attributes) const { 283 new_attributes = 284 static_cast<PropertyAttributes>(attributes() | new_attributes); 285 return PropertyDetails(value_, new_attributes); 286 } 287 288 // Conversion for storing details as Object*. 289 explicit inline PropertyDetails(Smi* smi); 290 inline Smi* AsSmi() const; 291 292 static uint8_t EncodeRepresentation(Representation representation) { 293 return representation.kind(); 294 } 295 296 static Representation DecodeRepresentation(uint32_t bits) { 297 return Representation::FromKind(static_cast<Representation::Kind>(bits)); 298 } 299 300 PropertyKind kind() const { return KindField::decode(value_); } 301 PropertyLocation location() const { return LocationField::decode(value_); } 302 PropertyConstness constness() const { return ConstnessField::decode(value_); } 303 304 PropertyAttributes attributes() const { 305 return AttributesField::decode(value_); 306 } 307 308 int dictionary_index() const { 309 return DictionaryStorageField::decode(value_); 310 } 311 312 Representation representation() const { 313 return DecodeRepresentation(RepresentationField::decode(value_)); 314 } 315 316 int field_index() const { return FieldIndexField::decode(value_); } 317 318 inline int field_width_in_words() const; 319 320 static bool IsValidIndex(int index) { 321 return DictionaryStorageField::is_valid(index); 322 } 323 324 bool IsReadOnly() const { return (attributes() & READ_ONLY) != 0; } 325 bool IsConfigurable() const { return (attributes() & DONT_DELETE) == 0; } 326 bool IsDontEnum() const { return (attributes() & DONT_ENUM) != 0; } 327 bool IsEnumerable() const { return !IsDontEnum(); } 328 PropertyCellType cell_type() const { 329 return PropertyCellTypeField::decode(value_); 330 } 331 332 // Bit fields in value_ (type, shift, size). Must be public so the 333 // constants can be embedded in generated code. 334 class KindField : public BitField<PropertyKind, 0, 1> {}; 335 class LocationField : public BitField<PropertyLocation, KindField::kNext, 1> { 336 }; 337 class ConstnessField 338 : public BitField<PropertyConstness, LocationField::kNext, 1> {}; 339 class AttributesField 340 : public BitField<PropertyAttributes, ConstnessField::kNext, 3> {}; 341 static const int kAttributesReadOnlyMask = 342 (READ_ONLY << AttributesField::kShift); 343 344 // Bit fields for normalized objects. 345 class PropertyCellTypeField 346 : public BitField<PropertyCellType, AttributesField::kNext, 2> {}; 347 class DictionaryStorageField 348 : public BitField<uint32_t, PropertyCellTypeField::kNext, 23> {}; 349 350 // Bit fields for fast objects. 351 class RepresentationField 352 : public BitField<uint32_t, AttributesField::kNext, 4> {}; 353 class DescriptorPointer 354 : public BitField<uint32_t, RepresentationField::kNext, 355 kDescriptorIndexBitCount> {}; // NOLINT 356 class FieldIndexField : public BitField<uint32_t, DescriptorPointer::kNext, 357 kDescriptorIndexBitCount> { 358 }; // NOLINT 359 360 // All bits for both fast and slow objects must fit in a smi. 361 STATIC_ASSERT(DictionaryStorageField::kNext <= 31); 362 STATIC_ASSERT(FieldIndexField::kNext <= 31); 363 364 static const int kInitialIndex = 1; 365 366 #ifdef OBJECT_PRINT 367 // For our gdb macros, we should perhaps change these in the future. 368 void Print(bool dictionary_mode); 369 #endif 370 371 enum PrintMode { 372 kPrintAttributes = 1 << 0, 373 kPrintFieldIndex = 1 << 1, 374 kPrintRepresentation = 1 << 2, 375 kPrintPointer = 1 << 3, 376 377 kForProperties = kPrintFieldIndex, 378 kForTransitions = kPrintAttributes, 379 kPrintFull = -1, 380 }; 381 void PrintAsSlowTo(std::ostream& out); 382 void PrintAsFastTo(std::ostream& out, PrintMode mode = kPrintFull); 383 384 private: 385 PropertyDetails(int value, int pointer) { 386 value_ = DescriptorPointer::update(value, pointer); 387 } 388 PropertyDetails(int value, Representation representation) { 389 value_ = RepresentationField::update( 390 value, EncodeRepresentation(representation)); 391 } 392 PropertyDetails(int value, PropertyConstness constness) { 393 value_ = ConstnessField::update(value, constness); 394 } 395 PropertyDetails(int value, PropertyAttributes attributes) { 396 value_ = AttributesField::update(value, attributes); 397 } 398 399 uint32_t value_; 400 }; 401 402 // kField location is more general than kDescriptor, kDescriptor generalizes 403 // only to itself. 404 inline bool IsGeneralizableTo(PropertyLocation a, PropertyLocation b) { 405 return b == kField || a == kDescriptor; 406 } 407 408 // kMutable constness is more general than kConst, kConst generalizes only to 409 // itself. 410 inline bool IsGeneralizableTo(PropertyConstness a, PropertyConstness b) { 411 return b == kMutable || a == kConst; 412 } 413 414 inline PropertyConstness GeneralizeConstness(PropertyConstness a, 415 PropertyConstness b) { 416 return a == kMutable ? kMutable : b; 417 } 418 419 std::ostream& operator<<(std::ostream& os, 420 const PropertyAttributes& attributes); 421 } // namespace internal 422 } // namespace v8 423 424 #endif // V8_PROPERTY_DETAILS_H_ 425