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 class 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 ? PropertyConstness::kConst 84 : PropertyConstness::kMutable; 85 86 class Representation { 87 public: 88 enum Kind { 89 kNone, 90 kInteger8, 91 kUInteger8, 92 kInteger16, 93 kUInteger16, 94 kSmi, 95 kInteger32, 96 kDouble, 97 kHeapObject, 98 kTagged, 99 kExternal, 100 kNumRepresentations 101 }; 102 103 Representation() : kind_(kNone) { } 104 105 static Representation None() { return Representation(kNone); } 106 static Representation Tagged() { return Representation(kTagged); } 107 static Representation Integer8() { return Representation(kInteger8); } 108 static Representation UInteger8() { return Representation(kUInteger8); } 109 static Representation Integer16() { return Representation(kInteger16); } 110 static Representation UInteger16() { return Representation(kUInteger16); } 111 static Representation Smi() { return Representation(kSmi); } 112 static Representation Integer32() { return Representation(kInteger32); } 113 static Representation Double() { return Representation(kDouble); } 114 static Representation HeapObject() { return Representation(kHeapObject); } 115 static Representation External() { return Representation(kExternal); } 116 117 static Representation FromKind(Kind kind) { return Representation(kind); } 118 119 bool Equals(const Representation& other) const { 120 return kind_ == other.kind_; 121 } 122 123 bool IsCompatibleForLoad(const Representation& other) const { 124 return (IsDouble() && other.IsDouble()) || 125 (!IsDouble() && !other.IsDouble()); 126 } 127 128 bool IsCompatibleForStore(const Representation& other) const { 129 return Equals(other); 130 } 131 132 bool is_more_general_than(const Representation& other) const { 133 if (kind_ == kExternal && other.kind_ == kNone) return true; 134 if (kind_ == kExternal && other.kind_ == kExternal) return false; 135 if (kind_ == kNone && other.kind_ == kExternal) return false; 136 137 DCHECK_NE(kind_, kExternal); 138 DCHECK_NE(other.kind_, kExternal); 139 if (IsHeapObject()) return other.IsNone(); 140 if (kind_ == kUInteger8 && other.kind_ == kInteger8) return false; 141 if (kind_ == kUInteger16 && other.kind_ == kInteger16) return false; 142 return kind_ > other.kind_; 143 } 144 145 bool fits_into(const Representation& other) const { 146 return other.is_more_general_than(*this) || other.Equals(*this); 147 } 148 149 Representation generalize(Representation other) { 150 if (other.fits_into(*this)) return *this; 151 if (other.is_more_general_than(*this)) return other; 152 return Representation::Tagged(); 153 } 154 155 int size() const { 156 DCHECK(!IsNone()); 157 if (IsInteger8() || IsUInteger8()) { 158 return sizeof(uint8_t); 159 } 160 if (IsInteger16() || IsUInteger16()) { 161 return sizeof(uint16_t); 162 } 163 if (IsInteger32()) { 164 return sizeof(uint32_t); 165 } 166 return kPointerSize; 167 } 168 169 Kind kind() const { return static_cast<Kind>(kind_); } 170 bool IsNone() const { return kind_ == kNone; } 171 bool IsInteger8() const { return kind_ == kInteger8; } 172 bool IsUInteger8() const { return kind_ == kUInteger8; } 173 bool IsInteger16() const { return kind_ == kInteger16; } 174 bool IsUInteger16() const { return kind_ == kUInteger16; } 175 bool IsTagged() const { return kind_ == kTagged; } 176 bool IsSmi() const { return kind_ == kSmi; } 177 bool IsSmiOrTagged() const { return IsSmi() || IsTagged(); } 178 bool IsInteger32() const { return kind_ == kInteger32; } 179 bool IsSmiOrInteger32() const { return IsSmi() || IsInteger32(); } 180 bool IsDouble() const { return kind_ == kDouble; } 181 bool IsHeapObject() const { return kind_ == kHeapObject; } 182 bool IsExternal() const { return kind_ == kExternal; } 183 bool IsSpecialization() const { 184 return IsInteger8() || IsUInteger8() || 185 IsInteger16() || IsUInteger16() || 186 IsSmi() || IsInteger32() || IsDouble(); 187 } 188 const char* Mnemonic() const; 189 190 private: 191 explicit Representation(Kind k) : kind_(k) { } 192 193 // Make sure kind fits in int8. 194 STATIC_ASSERT(kNumRepresentations <= (1 << kBitsPerByte)); 195 196 int8_t kind_; 197 }; 198 199 200 static const int kDescriptorIndexBitCount = 10; 201 static const int kFirstInobjectPropertyOffsetBitCount = 7; 202 // The maximum number of descriptors we want in a descriptor array. It should 203 // fit in a page and also the following should hold: 204 // kMaxNumberOfDescriptors + kFieldsAdded <= PropertyArray::kMaxLength. 205 static const int kMaxNumberOfDescriptors = (1 << kDescriptorIndexBitCount) - 4; 206 static const int kInvalidEnumCacheSentinel = 207 (1 << kDescriptorIndexBitCount) - 1; 208 209 enum class PropertyCellType { 210 // Meaningful when a property cell does not contain the hole. 211 kUndefined, // The PREMONOMORPHIC of property cells. 212 kConstant, // Cell has been assigned only once. 213 kConstantType, // Cell has been assigned only one type. 214 kMutable, // Cell will no longer be tracked as constant. 215 216 // Meaningful when a property cell contains the hole. 217 kUninitialized = kUndefined, // Cell has never been initialized. 218 kInvalidated = kConstant, // Cell has been deleted, invalidated or never 219 // existed. 220 221 // For dictionaries not holding cells. 222 kNoCell = kMutable, 223 }; 224 225 enum class PropertyCellConstantType { 226 kSmi, 227 kStableMap, 228 }; 229 230 231 // PropertyDetails captures type and attributes for a property. 232 // They are used both in property dictionaries and instance descriptors. 233 class PropertyDetails BASE_EMBEDDED { 234 public: 235 // Property details for dictionary mode properties/elements. 236 PropertyDetails(PropertyKind kind, PropertyAttributes attributes, 237 PropertyCellType cell_type, int dictionary_index = 0) { 238 value_ = KindField::encode(kind) | LocationField::encode(kField) | 239 AttributesField::encode(attributes) | 240 DictionaryStorageField::encode(dictionary_index) | 241 PropertyCellTypeField::encode(cell_type); 242 } 243 244 // Property details for fast mode properties. 245 PropertyDetails(PropertyKind kind, PropertyAttributes attributes, 246 PropertyLocation location, PropertyConstness constness, 247 Representation representation, int field_index = 0) { 248 value_ = KindField::encode(kind) | AttributesField::encode(attributes) | 249 LocationField::encode(location) | 250 ConstnessField::encode(constness) | 251 RepresentationField::encode(EncodeRepresentation(representation)) | 252 FieldIndexField::encode(field_index); 253 } 254 255 static PropertyDetails Empty( 256 PropertyCellType cell_type = PropertyCellType::kNoCell) { 257 return PropertyDetails(kData, NONE, cell_type); 258 } 259 260 int pointer() const { return DescriptorPointer::decode(value_); } 261 262 PropertyDetails set_pointer(int i) const { 263 return PropertyDetails(value_, i); 264 } 265 266 PropertyDetails set_cell_type(PropertyCellType type) const { 267 PropertyDetails details = *this; 268 details.value_ = PropertyCellTypeField::update(details.value_, type); 269 return details; 270 } 271 272 PropertyDetails set_index(int index) const { 273 PropertyDetails details = *this; 274 details.value_ = DictionaryStorageField::update(details.value_, index); 275 return details; 276 } 277 278 PropertyDetails CopyWithRepresentation(Representation representation) const { 279 return PropertyDetails(value_, representation); 280 } 281 PropertyDetails CopyWithConstness(PropertyConstness constness) const { 282 return PropertyDetails(value_, constness); 283 } 284 PropertyDetails CopyAddAttributes(PropertyAttributes new_attributes) const { 285 new_attributes = 286 static_cast<PropertyAttributes>(attributes() | new_attributes); 287 return PropertyDetails(value_, new_attributes); 288 } 289 290 // Conversion for storing details as Object*. 291 explicit inline PropertyDetails(Smi* smi); 292 inline Smi* AsSmi() const; 293 294 static uint8_t EncodeRepresentation(Representation representation) { 295 return representation.kind(); 296 } 297 298 static Representation DecodeRepresentation(uint32_t bits) { 299 return Representation::FromKind(static_cast<Representation::Kind>(bits)); 300 } 301 302 PropertyKind kind() const { return KindField::decode(value_); } 303 PropertyLocation location() const { return LocationField::decode(value_); } 304 PropertyConstness constness() const { return ConstnessField::decode(value_); } 305 306 PropertyAttributes attributes() const { 307 return AttributesField::decode(value_); 308 } 309 310 int dictionary_index() const { 311 return DictionaryStorageField::decode(value_); 312 } 313 314 Representation representation() const { 315 return DecodeRepresentation(RepresentationField::decode(value_)); 316 } 317 318 int field_index() const { return FieldIndexField::decode(value_); } 319 320 inline int field_width_in_words() const; 321 322 static bool IsValidIndex(int index) { 323 return DictionaryStorageField::is_valid(index); 324 } 325 326 bool IsReadOnly() const { return (attributes() & READ_ONLY) != 0; } 327 bool IsConfigurable() const { return (attributes() & DONT_DELETE) == 0; } 328 bool IsDontEnum() const { return (attributes() & DONT_ENUM) != 0; } 329 bool IsEnumerable() const { return !IsDontEnum(); } 330 PropertyCellType cell_type() const { 331 return PropertyCellTypeField::decode(value_); 332 } 333 334 // Bit fields in value_ (type, shift, size). Must be public so the 335 // constants can be embedded in generated code. 336 class KindField : public BitField<PropertyKind, 0, 1> {}; 337 class LocationField : public BitField<PropertyLocation, KindField::kNext, 1> { 338 }; 339 class ConstnessField 340 : public BitField<PropertyConstness, LocationField::kNext, 1> {}; 341 class AttributesField 342 : public BitField<PropertyAttributes, ConstnessField::kNext, 3> {}; 343 static const int kAttributesReadOnlyMask = 344 (READ_ONLY << AttributesField::kShift); 345 static const int kAttributesDontDeleteMask = 346 (DONT_DELETE << AttributesField::kShift); 347 static const int kAttributesDontEnumMask = 348 (DONT_ENUM << AttributesField::kShift); 349 350 // Bit fields for normalized objects. 351 class PropertyCellTypeField 352 : public BitField<PropertyCellType, AttributesField::kNext, 2> {}; 353 class DictionaryStorageField 354 : public BitField<uint32_t, PropertyCellTypeField::kNext, 23> {}; 355 356 // Bit fields for fast objects. 357 class RepresentationField 358 : public BitField<uint32_t, AttributesField::kNext, 4> {}; 359 class DescriptorPointer 360 : public BitField<uint32_t, RepresentationField::kNext, 361 kDescriptorIndexBitCount> {}; // NOLINT 362 class FieldIndexField : public BitField<uint32_t, DescriptorPointer::kNext, 363 kDescriptorIndexBitCount> { 364 }; // NOLINT 365 366 // All bits for both fast and slow objects must fit in a smi. 367 STATIC_ASSERT(DictionaryStorageField::kNext <= 31); 368 STATIC_ASSERT(FieldIndexField::kNext <= 31); 369 370 static const int kInitialIndex = 1; 371 372 #ifdef OBJECT_PRINT 373 // For our gdb macros, we should perhaps change these in the future. 374 void Print(bool dictionary_mode); 375 #endif 376 377 enum PrintMode { 378 kPrintAttributes = 1 << 0, 379 kPrintFieldIndex = 1 << 1, 380 kPrintRepresentation = 1 << 2, 381 kPrintPointer = 1 << 3, 382 383 kForProperties = kPrintFieldIndex, 384 kForTransitions = kPrintAttributes, 385 kPrintFull = -1, 386 }; 387 void PrintAsSlowTo(std::ostream& out); 388 void PrintAsFastTo(std::ostream& out, PrintMode mode = kPrintFull); 389 390 private: 391 PropertyDetails(int value, int pointer) { 392 value_ = DescriptorPointer::update(value, pointer); 393 } 394 PropertyDetails(int value, Representation representation) { 395 value_ = RepresentationField::update( 396 value, EncodeRepresentation(representation)); 397 } 398 PropertyDetails(int value, PropertyConstness constness) { 399 value_ = ConstnessField::update(value, constness); 400 } 401 PropertyDetails(int value, PropertyAttributes attributes) { 402 value_ = AttributesField::update(value, attributes); 403 } 404 405 uint32_t value_; 406 }; 407 408 // kField location is more general than kDescriptor, kDescriptor generalizes 409 // only to itself. 410 inline bool IsGeneralizableTo(PropertyLocation a, PropertyLocation b) { 411 return b == kField || a == kDescriptor; 412 } 413 414 // PropertyConstness::kMutable constness is more general than 415 // VariableMode::kConst, VariableMode::kConst generalizes only to itself. 416 inline bool IsGeneralizableTo(PropertyConstness a, PropertyConstness b) { 417 return b == PropertyConstness::kMutable || a == PropertyConstness::kConst; 418 } 419 420 inline PropertyConstness GeneralizeConstness(PropertyConstness a, 421 PropertyConstness b) { 422 return a == PropertyConstness::kMutable ? PropertyConstness::kMutable : b; 423 } 424 425 std::ostream& operator<<(std::ostream& os, 426 const PropertyAttributes& attributes); 427 } // namespace internal 428 } // namespace v8 429 430 #endif // V8_PROPERTY_DETAILS_H_ 431