diff options
Diffstat (limited to 'Source/JavaScriptCore/runtime/JSObject.h')
| -rw-r--r-- | Source/JavaScriptCore/runtime/JSObject.h | 570 |
1 files changed, 324 insertions, 246 deletions
diff --git a/Source/JavaScriptCore/runtime/JSObject.h b/Source/JavaScriptCore/runtime/JSObject.h index 2c5b8f733..02b137b35 100644 --- a/Source/JavaScriptCore/runtime/JSObject.h +++ b/Source/JavaScriptCore/runtime/JSObject.h @@ -1,7 +1,7 @@ /* * Copyright (C) 1999-2001 Harri Porten (porten@kde.org) * Copyright (C) 2001 Peter Kelly (pmk@post.com) - * Copyright (C) 2003-2009, 2012-2015 Apple Inc. All rights reserved. + * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012, 2013 Apple Inc. All rights reserved. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public @@ -31,10 +31,8 @@ #include "ClassInfo.h" #include "CommonIdentifiers.h" #include "CopyWriteBarrier.h" -#include "CustomGetterSetter.h" #include "DeferGC.h" #include "Heap.h" -#include "HeapInlines.h" #include "IndexingHeaderInlines.h" #include "JSCell.h" #include "PropertySlot.h" @@ -52,21 +50,29 @@ namespace JSC { inline JSCell* getJSFunction(JSValue value) { - if (value.isCell() && (value.asCell()->type() == JSFunctionType)) + if (value.isCell() && (value.asCell()->structure()->typeInfo().type() == JSFunctionType)) return value.asCell(); return 0; } +JS_EXPORT_PRIVATE JSCell* getCallableObjectSlow(JSCell*); + +inline JSCell* getCallableObject(JSValue value) +{ + if (!value.isCell()) + return 0; + return getCallableObjectSlow(value.asCell()); +} + class GetterSetter; +class HashEntry; class InternalFunction; -class JSFunction; class LLIntOffsetsExtractor; class MarkedBlock; class PropertyDescriptor; class PropertyNameArray; class Structure; struct HashTable; -struct HashTableValue; JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const String&); extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError; @@ -86,7 +92,7 @@ class JSObject : public JSCell { friend class JSCell; friend class JSFinalObject; friend class MarkedBlock; - JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject*, PropertyName, PropertySlot&); + JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject*, PropertyName, PropertySlot&); enum PutMode { PutModePut, @@ -100,11 +106,10 @@ public: JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&, CopyToken); JS_EXPORT_PRIVATE static String className(const JSObject*); - JS_EXPORT_PRIVATE static String calculatedClassName(JSObject*); JSValue prototype() const; - JS_EXPORT_PRIVATE void setPrototype(VM&, JSValue prototype); - JS_EXPORT_PRIVATE bool setPrototypeWithCycleCheck(ExecState*, JSValue prototype); + void setPrototype(VM&, JSValue prototype); + bool setPrototypeWithCycleCheck(ExecState*, JSValue prototype); bool mayInterceptIndexedAccesses() { @@ -114,7 +119,7 @@ public: JSValue get(ExecState*, PropertyName) const; JSValue get(ExecState*, unsigned propertyName) const; - bool fastGetOwnPropertySlot(ExecState*, VM&, Structure&, PropertyName, PropertySlot&); + bool fastGetOwnPropertySlot(ExecState*, PropertyName, PropertySlot&); bool getPropertySlot(ExecState*, PropertyName, PropertySlot&); bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&); @@ -124,20 +129,20 @@ public: // The key difference between this and getOwnPropertySlot is that getOwnPropertySlot // currently returns incorrect results for the DOM window (with non-own properties) // being returned. Once this is fixed we should migrate code & remove this method. - JS_EXPORT_PRIVATE bool getOwnPropertyDescriptor(ExecState*, PropertyName, PropertyDescriptor&); + bool getOwnPropertyDescriptor(ExecState*, PropertyName, PropertyDescriptor&); - JS_EXPORT_PRIVATE bool allowsAccessFrom(ExecState*); + bool allowsAccessFrom(ExecState*); unsigned getArrayLength() const { - if (!hasIndexedProperties(indexingType())) + if (!hasIndexedProperties(structure()->indexingType())) return 0; return m_butterfly->publicLength(); } unsigned getVectorLength() { - if (!hasIndexedProperties(indexingType())) + if (!hasIndexedProperties(structure()->indexingType())) return 0; return m_butterfly->vectorLength(); } @@ -145,13 +150,13 @@ public: JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&); JS_EXPORT_PRIVATE static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow); - ALWAYS_INLINE void putByIndexInline(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow) + void putByIndexInline(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow) { if (canSetIndexQuickly(propertyName)) { setIndexQuickly(exec->vm(), propertyName, value); return; } - methodTable(exec->vm())->putByIndex(this, exec, propertyName, value, shouldThrow); + methodTable()->putByIndex(this, exec, propertyName, value, shouldThrow); } // This is similar to the putDirect* methods: @@ -182,7 +187,7 @@ public: bool canGetIndexQuickly(unsigned i) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: return false; @@ -207,7 +212,7 @@ public: JSValue getIndexQuickly(unsigned i) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_INT32_INDEXING_TYPES: return jsNumber(m_butterfly->contiguous()[i].get().asInt32()); case ALL_CONTIGUOUS_INDEXING_TYPES: @@ -224,7 +229,7 @@ public: JSValue tryGetIndexQuickly(unsigned i) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: break; @@ -263,7 +268,7 @@ public: if (JSValue result = tryGetIndexQuickly(i)) return result; PropertySlot slot(this); - if (methodTable(exec->vm())->getOwnPropertySlotByIndex(this, exec, i, slot)) + if (methodTable()->getOwnPropertySlotByIndex(this, exec, i, slot)) return slot.getValue(exec, i); return JSValue(); } @@ -277,7 +282,7 @@ public: bool canSetIndexQuickly(unsigned i) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: return false; @@ -299,7 +304,7 @@ public: bool canSetIndexQuicklyForPutDirect(unsigned i) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: return false; @@ -316,7 +321,7 @@ public: void setIndexQuickly(VM& vm, unsigned i, JSValue v) { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_INT32_INDEXING_TYPES: { ASSERT(i < m_butterfly->vectorLength()); if (!v.isInt32()) { @@ -364,15 +369,10 @@ public: RELEASE_ASSERT_NOT_REACHED(); } } - + void initializeIndex(VM& vm, unsigned i, JSValue v) { - initializeIndex(vm, i, v, indexingType()); - } - - void initializeIndex(VM& vm, unsigned i, JSValue v, IndexingType indexingType) - { - switch (indexingType) { + switch (structure()->indexingType()) { case ALL_UNDECIDED_INDEXING_TYPES: { setIndexQuicklyToUndecided(vm, i, v); break; @@ -421,7 +421,7 @@ public: bool hasSparseMap() { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: case ALL_INT32_INDEXING_TYPES: @@ -429,7 +429,7 @@ public: case ALL_CONTIGUOUS_INDEXING_TYPES: return false; case ALL_ARRAY_STORAGE_INDEXING_TYPES: - return !!m_butterfly->arrayStorage()->m_sparseMap; + return m_butterfly->arrayStorage()->m_sparseMap; default: RELEASE_ASSERT_NOT_REACHED(); return false; @@ -438,7 +438,7 @@ public: bool inSparseIndexingMode() { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_BLANK_INDEXING_TYPES: case ALL_UNDECIDED_INDEXING_TYPES: case ALL_INT32_INDEXING_TYPES: @@ -465,15 +465,10 @@ public: void putDirectWithoutTransition(VM&, PropertyName, JSValue, unsigned attributes = 0); void putDirectNonIndexAccessor(VM&, PropertyName, JSValue, unsigned attributes); void putDirectAccessor(ExecState*, PropertyName, JSValue, unsigned attributes); - JS_EXPORT_PRIVATE void putDirectCustomAccessor(VM&, PropertyName, JSValue, unsigned attributes); - - void putGetter(ExecState*, PropertyName, JSValue); - void putSetter(ExecState*, PropertyName, JSValue); JS_EXPORT_PRIVATE bool hasProperty(ExecState*, PropertyName) const; JS_EXPORT_PRIVATE bool hasProperty(ExecState*, unsigned propertyName) const; bool hasOwnProperty(ExecState*, PropertyName) const; - bool hasOwnProperty(ExecState*, unsigned) const; JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, PropertyName); JS_EXPORT_PRIVATE static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName); @@ -487,10 +482,6 @@ public: JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode); JS_EXPORT_PRIVATE static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode); - JS_EXPORT_PRIVATE static uint32_t getEnumerableLength(ExecState*, JSObject*); - JS_EXPORT_PRIVATE static void getStructurePropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode); - JS_EXPORT_PRIVATE static void getGenericPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode); - JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const; bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const; JS_EXPORT_PRIVATE double toNumber(ExecState*) const; @@ -498,36 +489,36 @@ public: JS_EXPORT_PRIVATE static JSValue toThis(JSCell*, ExecState*, ECMAMode); + bool getPropertySpecificValue(ExecState*, PropertyName, JSCell*& specificFunction) const; + // This get function only looks at the property map. JSValue getDirect(VM& vm, PropertyName propertyName) const { - Structure* structure = this->structure(vm); - PropertyOffset offset = structure->get(vm, propertyName); - checkOffset(offset, structure->inlineCapacity()); + PropertyOffset offset = structure()->get(vm, propertyName); + checkOffset(offset, structure()->inlineCapacity()); return offset != invalidOffset ? getDirect(offset) : JSValue(); } - + JSValue getDirect(VM& vm, PropertyName propertyName, unsigned& attributes) const { - Structure* structure = this->structure(vm); - PropertyOffset offset = structure->get(vm, propertyName, attributes); - checkOffset(offset, structure->inlineCapacity()); + JSCell* specific; + PropertyOffset offset = structure()->get(vm, propertyName, attributes, specific); + checkOffset(offset, structure()->inlineCapacity()); return offset != invalidOffset ? getDirect(offset) : JSValue(); } PropertyOffset getDirectOffset(VM& vm, PropertyName propertyName) { - Structure* structure = this->structure(vm); - PropertyOffset offset = structure->get(vm, propertyName); - checkOffset(offset, structure->inlineCapacity()); + PropertyOffset offset = structure()->get(vm, propertyName); + checkOffset(offset, structure()->inlineCapacity()); return offset; } PropertyOffset getDirectOffset(VM& vm, PropertyName propertyName, unsigned& attributes) { - Structure* structure = this->structure(vm); - PropertyOffset offset = structure->get(vm, propertyName, attributes); - checkOffset(offset, structure->inlineCapacity()); + JSCell* specific; + PropertyOffset offset = structure()->get(vm, propertyName, attributes, specific); + checkOffset(offset, structure()->inlineCapacity()); return offset; } @@ -573,16 +564,15 @@ public: void transitionTo(VM&, Structure*); - JS_EXPORT_PRIVATE bool removeDirect(VM&, PropertyName); // Return true if anything is removed. + bool removeDirect(VM&, PropertyName); // Return true if anything is removed. bool hasCustomProperties() { return structure()->didTransition(); } bool hasGetterSetterProperties() { return structure()->hasGetterSetterProperties(); } - bool hasCustomGetterSetterProperties() { return structure()->hasCustomGetterSetterProperties(); } // putOwnDataProperty has 'put' like semantics, however this method: // - assumes the object contains no own getter/setter properties. // - provides no special handling for __proto__ // - does not walk the prototype chain (to check for accessors or non-writable properties). - // This is used by JSLexicalEnvironment. + // This is used by JSActivation. bool putOwnDataProperty(VM&, PropertyName, JSValue, PutPropertySlot&); // Fast access to known property offsets. @@ -590,10 +580,8 @@ public: void putDirect(VM& vm, PropertyOffset offset, JSValue value) { locationForOffset(offset)->set(vm, this, value); } void putDirectUndefined(PropertyOffset offset) { locationForOffset(offset)->setUndefined(); } - JS_EXPORT_PRIVATE void putDirectNativeFunction(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes); - JS_EXPORT_PRIVATE JSFunction* putDirectBuiltinFunction(VM&, JSGlobalObject*, const PropertyName&, FunctionExecutable*, unsigned attributes); - JSFunction* putDirectBuiltinFunctionWithoutTransition(VM&, JSGlobalObject*, const PropertyName&, FunctionExecutable*, unsigned attributes); - JS_EXPORT_PRIVATE void putDirectNativeFunctionWithoutTransition(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes); + void putDirectNativeFunction(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes); + void putDirectNativeFunctionWithoutTransition(VM&, JSGlobalObject*, const PropertyName&, unsigned functionLength, NativeFunction, Intrinsic, unsigned attributes); JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, const PropertyDescriptor&, bool shouldThrow); @@ -603,13 +591,12 @@ public: bool isNameScopeObject() const; bool isActivationObject() const; bool isErrorInstance() const; - bool isWithScope() const; - JS_EXPORT_PRIVATE void seal(VM&); - JS_EXPORT_PRIVATE void freeze(VM&); + void seal(VM&); + void freeze(VM&); JS_EXPORT_PRIVATE void preventExtensions(VM&); - bool isSealed(VM& vm) { return structure(vm)->isSealed(vm); } - bool isFrozen(VM& vm) { return structure(vm)->isFrozen(vm); } + bool isSealed(VM& vm) { return structure()->isSealed(vm); } + bool isFrozen(VM& vm) { return structure()->isFrozen(vm); } bool isExtensible() { return structure()->isExtensible(); } bool indexingShouldBeSparse() { @@ -628,13 +615,10 @@ public: void setStructureAndReallocateStorageIfNecessary(VM&, unsigned oldCapacity, Structure*); void setStructureAndReallocateStorageIfNecessary(VM&, Structure*); - JS_EXPORT_PRIVATE void convertToDictionary(VM&); - void flattenDictionaryObject(VM& vm) { - structure(vm)->flattenDictionaryStructure(vm, this); + structure()->flattenDictionaryStructure(vm, this); } - void shiftButterflyAfterFlattening(VM&, size_t outOfLineCapacityBefore, size_t outOfLineCapacityAfter); JSGlobalObject* globalObject() const { @@ -660,7 +644,7 @@ public: // contiguous, array storage). ContiguousJSValues ensureInt32(VM& vm) { - if (LIKELY(hasInt32(indexingType()))) + if (LIKELY(hasInt32(structure()->indexingType()))) return m_butterfly->contiguousInt32(); return ensureInt32Slow(vm); @@ -672,7 +656,7 @@ public: // or array storage). ContiguousDoubles ensureDouble(VM& vm) { - if (LIKELY(hasDouble(indexingType()))) + if (LIKELY(hasDouble(structure()->indexingType()))) return m_butterfly->contiguousDouble(); return ensureDoubleSlow(vm); @@ -682,21 +666,32 @@ public: // indexing should be sparse or because we're having a bad time. ContiguousJSValues ensureContiguous(VM& vm) { - if (LIKELY(hasContiguous(indexingType()))) + if (LIKELY(hasContiguous(structure()->indexingType()))) return m_butterfly->contiguous(); return ensureContiguousSlow(vm); } - + + // Same as ensureContiguous(), except that if the indexed storage is in + // double mode, then it does a rage conversion to contiguous: it + // attempts to convert each double to an int32. + ContiguousJSValues rageEnsureContiguous(VM& vm) + { + if (LIKELY(hasContiguous(structure()->indexingType()))) + return m_butterfly->contiguous(); + + return rageEnsureContiguousSlow(vm); + } + // Ensure that the object is in a mode where it has array storage. Use // this if you're about to perform actions that would have required the // object to be converted to have array storage, if it didn't have it // already. ArrayStorage* ensureArrayStorage(VM& vm) { - if (LIKELY(hasAnyArrayStorage(indexingType()))) + if (LIKELY(hasArrayStorage(structure()->indexingType()))) return m_butterfly->arrayStorage(); - + return ensureArrayStorageSlow(vm); } @@ -719,6 +714,8 @@ protected: { Base::finishCreation(vm); ASSERT(inherits(info())); + ASSERT(!structure()->outOfLineCapacity()); + ASSERT(structure()->isEmpty()); ASSERT(prototype().isNull() || Heap::heap(this) == Heap::heap(prototype())); ASSERT(structure()->isObject()); ASSERT(classInfo()); @@ -740,7 +737,7 @@ protected: // storage. This will assert otherwise. ArrayStorage* arrayStorage() { - ASSERT(hasAnyArrayStorage(indexingType())); + ASSERT(hasArrayStorage(structure()->indexingType())); return m_butterfly->arrayStorage(); } @@ -748,7 +745,7 @@ protected: // object is in a mode where it has array storage. ArrayStorage* arrayStorageOrNull() { - switch (indexingType()) { + switch (structure()->indexingType()) { case ALL_ARRAY_STORAGE_INDEXING_TYPES: return m_butterfly->arrayStorage(); @@ -757,9 +754,6 @@ protected: } } - size_t butterflyTotalSize(); - size_t butterflyPreCapacity(); - Butterfly* createInitialUndecided(VM&, unsigned length); ContiguousJSValues createInitialInt32(VM&, unsigned length); ContiguousDoubles createInitialDouble(VM&, unsigned length); @@ -775,18 +769,23 @@ protected: ContiguousJSValues convertUndecidedToInt32(VM&); ContiguousDoubles convertUndecidedToDouble(VM&); ContiguousJSValues convertUndecidedToContiguous(VM&); + ArrayStorage* convertUndecidedToArrayStorage(VM&, NonPropertyTransition, unsigned neededLength); ArrayStorage* convertUndecidedToArrayStorage(VM&, NonPropertyTransition); ArrayStorage* convertUndecidedToArrayStorage(VM&); ContiguousDoubles convertInt32ToDouble(VM&); ContiguousJSValues convertInt32ToContiguous(VM&); + ArrayStorage* convertInt32ToArrayStorage(VM&, NonPropertyTransition, unsigned neededLength); ArrayStorage* convertInt32ToArrayStorage(VM&, NonPropertyTransition); ArrayStorage* convertInt32ToArrayStorage(VM&); ContiguousJSValues convertDoubleToContiguous(VM&); + ContiguousJSValues rageConvertDoubleToContiguous(VM&); + ArrayStorage* convertDoubleToArrayStorage(VM&, NonPropertyTransition, unsigned neededLength); ArrayStorage* convertDoubleToArrayStorage(VM&, NonPropertyTransition); ArrayStorage* convertDoubleToArrayStorage(VM&); + ArrayStorage* convertContiguousToArrayStorage(VM&, NonPropertyTransition, unsigned neededLength); ArrayStorage* convertContiguousToArrayStorage(VM&, NonPropertyTransition); ArrayStorage* convertContiguousToArrayStorage(VM&); @@ -813,7 +812,7 @@ protected: void ensureLength(VM& vm, unsigned length) { ASSERT(length < MAX_ARRAY_INDEX); - ASSERT(hasContiguous(indexingType()) || hasInt32(indexingType()) || hasDouble(indexingType()) || hasUndecided(indexingType())); + ASSERT(hasContiguous(structure()->indexingType()) || hasInt32(structure()->indexingType()) || hasDouble(structure()->indexingType()) || hasUndecided(structure()->indexingType())); if (m_butterfly->vectorLength() < length) ensureLengthSlow(vm, length); @@ -822,16 +821,109 @@ protected: m_butterfly->setPublicLength(length); } - // Call this if you want to shrink the butterfly backing store, and you're - // sure that the array is contiguous. - void reallocateAndShrinkButterfly(VM&, unsigned length); - template<IndexingType indexingShape> unsigned countElements(Butterfly*); // This is relevant to undecided, int32, double, and contiguous. unsigned countElements(); + // This strange method returns a pointer to the start of the indexed data + // as if it contained JSValues. But it won't always contain JSValues. + // Make sure you cast this to the appropriate type before using. + template<IndexingType indexingType> + ContiguousJSValues indexingData() + { + switch (indexingType) { + case ALL_INT32_INDEXING_TYPES: + case ALL_DOUBLE_INDEXING_TYPES: + case ALL_CONTIGUOUS_INDEXING_TYPES: + return m_butterfly->contiguous(); + + case ALL_ARRAY_STORAGE_INDEXING_TYPES: + return m_butterfly->arrayStorage()->vector(); + + default: + CRASH(); + return ContiguousJSValues(); + } + } + + ContiguousJSValues currentIndexingData() + { + switch (structure()->indexingType()) { + case ALL_INT32_INDEXING_TYPES: + case ALL_CONTIGUOUS_INDEXING_TYPES: + return m_butterfly->contiguous(); + + case ALL_ARRAY_STORAGE_INDEXING_TYPES: + return m_butterfly->arrayStorage()->vector(); + + default: + CRASH(); + return ContiguousJSValues(); + } + } + + JSValue getHolyIndexQuickly(unsigned i) + { + ASSERT(i < m_butterfly->vectorLength()); + switch (structure()->indexingType()) { + case ALL_INT32_INDEXING_TYPES: + case ALL_CONTIGUOUS_INDEXING_TYPES: + return m_butterfly->contiguous()[i].get(); + case ALL_DOUBLE_INDEXING_TYPES: { + double value = m_butterfly->contiguousDouble()[i]; + if (value == value) + return JSValue(JSValue::EncodeAsDouble, value); + return JSValue(); + } + case ALL_ARRAY_STORAGE_INDEXING_TYPES: + return m_butterfly->arrayStorage()->m_vector[i].get(); + default: + CRASH(); + return JSValue(); + } + } + + template<IndexingType indexingType> + unsigned relevantLength() + { + switch (indexingType) { + case ALL_INT32_INDEXING_TYPES: + case ALL_DOUBLE_INDEXING_TYPES: + case ALL_CONTIGUOUS_INDEXING_TYPES: + return m_butterfly->publicLength(); + + case ALL_ARRAY_STORAGE_INDEXING_TYPES: + return std::min( + m_butterfly->arrayStorage()->length(), + m_butterfly->arrayStorage()->vectorLength()); + + default: + CRASH(); + return 0; + } + } + + unsigned currentRelevantLength() + { + switch (structure()->indexingType()) { + case ALL_INT32_INDEXING_TYPES: + case ALL_DOUBLE_INDEXING_TYPES: + case ALL_CONTIGUOUS_INDEXING_TYPES: + return m_butterfly->publicLength(); + + case ALL_ARRAY_STORAGE_INDEXING_TYPES: + return std::min( + m_butterfly->arrayStorage()->length(), + m_butterfly->arrayStorage()->vectorLength()); + + default: + CRASH(); + return 0; + } + } + private: friend class LLIntOffsetsExtractor; @@ -848,13 +940,12 @@ private: ArrayStorage* enterDictionaryIndexingModeWhenArrayStorageAlreadyExists(VM&, ArrayStorage*); template<PutMode> - bool putDirectInternal(VM&, PropertyName, JSValue, unsigned attr, PutPropertySlot&); + bool putDirectInternal(VM&, PropertyName, JSValue, unsigned attr, PutPropertySlot&, JSCell*); - bool inlineGetOwnPropertySlot(VM&, Structure&, PropertyName, PropertySlot&); + bool inlineGetOwnPropertySlot(ExecState*, PropertyName, PropertySlot&); JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, JSValue, unsigned, PropertyOffset); - void fillCustomGetterPropertySlot(PropertySlot&, JSValue, unsigned, Structure&); - const HashTableValue* findPropertyHashEntry(PropertyName) const; + const HashEntry* findPropertyHashEntry(ExecState*, PropertyName) const; void putIndexedDescriptor(ExecState*, SparseArrayEntry*, const PropertyDescriptor&, PropertyDescriptor& old); @@ -865,6 +956,8 @@ private: unsigned getNewVectorLength(unsigned currentVectorLength, unsigned currentLength, unsigned desiredLength); unsigned getNewVectorLength(unsigned desiredLength); + JS_EXPORT_PRIVATE bool getOwnPropertySlotSlow(ExecState*, PropertyName, PropertySlot&); + ArrayStorage* constructConvertedArrayStorageWithoutCopyingElements(VM&, unsigned neededLength); JS_EXPORT_PRIVATE void setIndexQuicklyToUndecided(VM&, unsigned index, JSValue); @@ -876,14 +969,16 @@ private: ContiguousJSValues ensureInt32Slow(VM&); ContiguousDoubles ensureDoubleSlow(VM&); ContiguousJSValues ensureContiguousSlow(VM&); - JS_EXPORT_PRIVATE ArrayStorage* ensureArrayStorageSlow(VM&); - + ContiguousJSValues rageEnsureContiguousSlow(VM&); + ArrayStorage* ensureArrayStorageSlow(VM&); + + enum DoubleToContiguousMode { EncodeValueAsDouble, RageConvertDoubleToValue }; + template<DoubleToContiguousMode mode> + ContiguousJSValues genericConvertDoubleToContiguous(VM&); + ContiguousJSValues ensureContiguousSlow(VM&, DoubleToContiguousMode); + protected: CopyWriteBarrier<Butterfly> m_butterfly; -#if USE(JSVALUE32_64) -private: - uint32_t m_padding; -#endif }; // JSNonFinalObject is a type of JSObject that has some internal storage, @@ -909,7 +1004,7 @@ protected: void finishCreation(VM& vm) { Base::finishCreation(vm); - ASSERT(!this->structure()->hasInlineStorage()); + ASSERT(!this->structure()->totalStorageCapacity()); ASSERT(classInfo()); } }; @@ -923,7 +1018,6 @@ class JSFinalObject : public JSObject { public: typedef JSObject Base; - static const unsigned StructureFlags = Base::StructureFlags; static size_t allocationSize(size_t inlineCapacity) { @@ -942,7 +1036,7 @@ public: return (maxSize - allocationSize(0)) / sizeof(WriteBarrier<Unknown>); } - static JSFinalObject* create(ExecState*, Structure*, Butterfly* = nullptr); + static JSFinalObject* create(ExecState*, Structure*); static JSFinalObject* create(VM&, Structure*); static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype, unsigned inlineCapacity) { @@ -966,14 +1060,15 @@ protected: private: friend class LLIntOffsetsExtractor; - explicit JSFinalObject(VM& vm, Structure* structure, Butterfly* butterfly = nullptr) - : JSObject(vm, structure, butterfly) + explicit JSFinalObject(VM& vm, Structure* structure) + : JSObject(vm, structure) { } + + static const unsigned StructureFlags = JSObject::StructureFlags; }; -inline JSFinalObject* JSFinalObject::create( - ExecState* exec, Structure* structure, Butterfly* butterfly) +inline JSFinalObject* JSFinalObject::create(ExecState* exec, Structure* structure) { JSFinalObject* finalObject = new ( NotNull, @@ -981,7 +1076,7 @@ inline JSFinalObject* JSFinalObject::create( *exec->heap(), allocationSize(structure->inlineCapacity()) ) - ) JSFinalObject(exec->vm(), structure, butterfly); + ) JSFinalObject(exec->vm(), structure); finalObject->finishCreation(exec->vm()); return finalObject; } @@ -1010,38 +1105,35 @@ inline size_t JSObject::offsetOfInlineStorage() inline bool JSObject::isGlobalObject() const { - return type() == GlobalObjectType; + return structure()->typeInfo().type() == GlobalObjectType; } inline bool JSObject::isVariableObject() const { - return type() == GlobalObjectType || type() == ActivationObjectType; + return structure()->typeInfo().type() >= VariableObjectType; } + inline bool JSObject::isStaticScopeObject() const { - JSType type = this->type(); + JSType type = structure()->typeInfo().type(); return type == NameScopeObjectType || type == ActivationObjectType; } + inline bool JSObject::isNameScopeObject() const { - return type() == NameScopeObjectType; + return structure()->typeInfo().type() == NameScopeObjectType; } inline bool JSObject::isActivationObject() const { - return type() == ActivationObjectType; + return structure()->typeInfo().type() == ActivationObjectType; } inline bool JSObject::isErrorInstance() const { - return type() == ErrorInstanceType; -} - -inline bool JSObject::isWithScope() const -{ - return type() == WithScopeType; + return structure()->typeInfo().type() == ErrorInstanceType; } inline void JSObject::setStructureAndButterfly(VM& vm, Structure* structure, Butterfly* butterfly) @@ -1101,31 +1193,21 @@ inline JSValue JSObject::prototype() const return structure()->storedPrototype(); } -ALWAYS_INLINE bool JSObject::inlineGetOwnPropertySlot(VM& vm, Structure& structure, PropertyName propertyName, PropertySlot& slot) +ALWAYS_INLINE bool JSObject::inlineGetOwnPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot) { unsigned attributes; - PropertyOffset offset = structure.get(vm, propertyName, attributes); - if (!isValidOffset(offset)) - return false; - - JSValue value = getDirect(offset); - if (structure.hasGetterSetterProperties() && value.isGetterSetter()) - fillGetterPropertySlot(slot, value, attributes, offset); - else if (structure.hasCustomGetterSetterProperties() && value.isCustomGetterSetter()) - fillCustomGetterPropertySlot(slot, value, attributes, structure); - else - slot.setValue(this, attributes, value, offset); - - return true; -} - -ALWAYS_INLINE void JSObject::fillCustomGetterPropertySlot(PropertySlot& slot, JSValue customGetterSetter, unsigned attributes, Structure& structure) -{ - if (structure.isDictionary()) { - slot.setCustom(this, attributes, jsCast<CustomGetterSetter*>(customGetterSetter)->getter()); - return; + JSCell* specific; + PropertyOffset offset = structure()->get(exec->vm(), propertyName, attributes, specific); + if (LIKELY(isValidOffset(offset))) { + JSValue value = getDirect(offset); + if (structure()->hasGetterSetterProperties() && value.isGetterSetter()) + fillGetterPropertySlot(slot, value, attributes, offset); + else + slot.setValue(this, attributes, value, offset); + return true; } - slot.setCacheableCustom(this, attributes, jsCast<CustomGetterSetter*>(customGetterSetter)->getter()); + + return getOwnPropertySlotSlow(exec, propertyName, slot); } // It may seem crazy to inline a function this large, especially a virtual function, @@ -1133,54 +1215,38 @@ ALWAYS_INLINE void JSObject::fillCustomGetterPropertySlot(PropertySlot& slot, JS // base class call to this. ALWAYS_INLINE bool JSObject::getOwnPropertySlot(JSObject* object, ExecState* exec, PropertyName propertyName, PropertySlot& slot) { - VM& vm = exec->vm(); - Structure& structure = *object->structure(vm); - if (object->inlineGetOwnPropertySlot(vm, structure, propertyName, slot)) - return true; - if (Optional<uint32_t> index = parseIndex(propertyName)) - return getOwnPropertySlotByIndex(object, exec, index.value(), slot); - return false; + return object->inlineGetOwnPropertySlot(exec, propertyName, slot); } -ALWAYS_INLINE bool JSObject::fastGetOwnPropertySlot(ExecState* exec, VM& vm, Structure& structure, PropertyName propertyName, PropertySlot& slot) +ALWAYS_INLINE bool JSObject::fastGetOwnPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot) { - if (LIKELY(!TypeInfo::overridesGetOwnPropertySlot(inlineTypeFlags()))) - return inlineGetOwnPropertySlot(vm, structure, propertyName, slot); - return structure.classInfo()->methodTable.getOwnPropertySlot(this, exec, propertyName, slot); + if (!structure()->typeInfo().overridesGetOwnPropertySlot()) + return asObject(this)->inlineGetOwnPropertySlot(exec, propertyName, slot); + return methodTable()->getOwnPropertySlot(this, exec, propertyName, slot); } // It may seem crazy to inline a function this large but it makes a big difference // since this is function very hot in variable lookup ALWAYS_INLINE bool JSObject::getPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot) { - VM& vm = exec->vm(); - auto& structureIDTable = vm.heap.structureIDTable(); JSObject* object = this; while (true) { - Structure& structure = *structureIDTable.get(object->structureID()); - if (object->fastGetOwnPropertySlot(exec, vm, structure, propertyName, slot)) + if (object->fastGetOwnPropertySlot(exec, propertyName, slot)) return true; - JSValue prototype = structure.storedPrototype(); + JSValue prototype = object->prototype(); if (!prototype.isObject()) - break; + return false; object = asObject(prototype); } - - if (Optional<uint32_t> index = parseIndex(propertyName)) - return getPropertySlot(exec, index.value(), slot); - return false; } ALWAYS_INLINE bool JSObject::getPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot) { - VM& vm = exec->vm(); - auto& structureIDTable = vm.heap.structureIDTable(); JSObject* object = this; while (true) { - Structure& structure = *structureIDTable.get(object->structureID()); - if (structure.classInfo()->methodTable.getOwnPropertySlotByIndex(object, exec, propertyName, slot)) + if (object->methodTable()->getOwnPropertySlotByIndex(object, exec, propertyName, slot)) return true; - JSValue prototype = structure.storedPrototype(); + JSValue prototype = object->prototype(); if (!prototype.isObject()) return false; object = asObject(prototype); @@ -1206,29 +1272,34 @@ inline JSValue JSObject::get(ExecState* exec, unsigned propertyName) const } template<JSObject::PutMode mode> -inline bool JSObject::putDirectInternal(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes, PutPropertySlot& slot) +inline bool JSObject::putDirectInternal(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes, PutPropertySlot& slot, JSCell* specificFunction) { ASSERT(value); ASSERT(value.isGetterSetter() == !!(attributes & Accessor)); ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); - ASSERT(!parseIndex(propertyName)); + ASSERT(propertyName.asIndex() == PropertyName::NotAnIndex); - Structure* structure = this->structure(vm); - if (structure->isDictionary()) { + if (structure()->isDictionary()) { unsigned currentAttributes; - PropertyOffset offset = structure->get(vm, propertyName, currentAttributes); + JSCell* currentSpecificFunction; + PropertyOffset offset = structure()->get(vm, propertyName, currentAttributes, currentSpecificFunction); if (offset != invalidOffset) { + // If there is currently a specific function, and there now either isn't, + // or the new value is different, then despecify. + if (currentSpecificFunction && (specificFunction != currentSpecificFunction)) + structure()->despecifyDictionaryFunction(vm, propertyName); if ((mode == PutModePut) && currentAttributes & ReadOnly) return false; putDirect(vm, offset, value); - structure->didReplaceProperty(offset); - slot.setExistingProperty(this, offset); - - if ((attributes & Accessor) != (currentAttributes & Accessor)) { - ASSERT(!(attributes & ReadOnly)); - setStructure(vm, Structure::attributeChangeTransition(vm, structure, propertyName, attributes)); - } + // At this point, the objects structure only has a specific value set if previously there + // had been one set, and if the new value being specified is the same (otherwise we would + // have despecified, above). So, if currentSpecificFunction is not set, or if the new + // value is different (or there is no new value), then the slot now has no value - and + // as such it is cachable. + // If there was previously a value, and the new value is the same, then we cannot cache. + if (!currentSpecificFunction || (specificFunction != currentSpecificFunction)) + slot.setExistingProperty(this, offset); return true; } @@ -1237,23 +1308,25 @@ inline bool JSObject::putDirectInternal(VM& vm, PropertyName propertyName, JSVal DeferGC deferGC(vm.heap); Butterfly* newButterfly = butterfly(); - if (this->structure()->putWillGrowOutOfLineStorage()) - newButterfly = growOutOfLineStorage(vm, this->structure()->outOfLineCapacity(), this->structure()->suggestedNewOutOfLineStorageCapacity()); - offset = this->structure()->addPropertyWithoutTransition(vm, propertyName, attributes); - setStructureAndButterfly(vm, this->structure(), newButterfly); + if (structure()->putWillGrowOutOfLineStorage()) + newButterfly = growOutOfLineStorage(vm, structure()->outOfLineCapacity(), structure()->suggestedNewOutOfLineStorageCapacity()); + offset = structure()->addPropertyWithoutTransition(vm, propertyName, attributes, specificFunction); + setStructureAndButterfly(vm, structure(), newButterfly); validateOffset(offset); - ASSERT(this->structure()->isValidOffset(offset)); + ASSERT(structure()->isValidOffset(offset)); putDirect(vm, offset, value); - slot.setNewProperty(this, offset); + // See comment on setNewProperty call below. + if (!specificFunction) + slot.setNewProperty(this, offset); if (attributes & ReadOnly) - this->structure()->setContainsReadOnlyProperties(); + structure()->setContainsReadOnlyProperties(); return true; } PropertyOffset offset; - size_t currentCapacity = this->structure()->outOfLineCapacity(); - if (Structure* structure = Structure::addPropertyTransitionToExistingStructure(this->structure(), propertyName, attributes, offset)) { + size_t currentCapacity = structure()->outOfLineCapacity(); + if (Structure* structure = Structure::addPropertyTransitionToExistingStructure(this->structure(), propertyName, attributes, specificFunction, offset)) { DeferGC deferGC(vm.heap); Butterfly* newButterfly = butterfly(); if (currentCapacity != structure->outOfLineCapacity()) { @@ -1265,43 +1338,59 @@ inline bool JSObject::putDirectInternal(VM& vm, PropertyName propertyName, JSVal ASSERT(structure->isValidOffset(offset)); setStructureAndButterfly(vm, structure, newButterfly); putDirect(vm, offset, value); - slot.setNewProperty(this, offset); + // This is a new property; transitions with specific values are not currently cachable, + // so leave the slot in an uncachable state. + if (!specificFunction) + slot.setNewProperty(this, offset); return true; } unsigned currentAttributes; - offset = structure->get(vm, propertyName, currentAttributes); + JSCell* currentSpecificFunction; + offset = structure()->get(vm, propertyName, currentAttributes, currentSpecificFunction); if (offset != invalidOffset) { if ((mode == PutModePut) && currentAttributes & ReadOnly) return false; - structure->didReplaceProperty(offset); + // There are three possibilities here: + // (1) There is an existing specific value set, and we're overwriting with *the same value*. + // * Do nothing - no need to despecify, but that means we can't cache (a cached + // put could write a different value). Leave the slot in an uncachable state. + // (2) There is a specific value currently set, but we're writing a different value. + // * First, we have to despecify. Having done so, this is now a regular slot + // with no specific value, so go ahead & cache like normal. + // (3) Normal case, there is no specific value set. + // * Go ahead & cache like normal. + if (currentSpecificFunction) { + // case (1) Do the put, then return leaving the slot uncachable. + if (specificFunction == currentSpecificFunction) { + putDirect(vm, offset, value); + return true; + } + // case (2) Despecify, fall through to (3). + setStructure(vm, Structure::despecifyFunctionTransition(vm, structure(), propertyName)); + } + + // case (3) set the slot, do the put, return. slot.setExistingProperty(this, offset); putDirect(vm, offset, value); - - if ((attributes & Accessor) != (currentAttributes & Accessor)) { - ASSERT(!(attributes & ReadOnly)); - setStructure(vm, Structure::attributeChangeTransition(vm, structure, propertyName, attributes)); - } return true; } if ((mode == PutModePut) && !isExtensible()) return false; - // We want the structure transition watchpoint to fire after this object has switched - // structure. This allows adaptive watchpoints to observe if the new structure is the one - // we want. - DeferredStructureTransitionWatchpointFire deferredWatchpointFire; - - structure = Structure::addPropertyTransition(vm, structure, propertyName, attributes, offset, slot.context(), &deferredWatchpointFire); + Structure* structure = Structure::addPropertyTransition(vm, this->structure(), propertyName, attributes, specificFunction, offset, slot.context()); validateOffset(offset); ASSERT(structure->isValidOffset(offset)); setStructureAndReallocateStorageIfNecessary(vm, structure); putDirect(vm, offset, value); - slot.setNewProperty(this, offset); + // This is a new property; transitions with specific values are not currently cachable, + // so leave the slot in an uncachable state. + if (!specificFunction) + slot.setNewProperty(this, offset); if (attributes & ReadOnly) structure->setContainsReadOnlyProperties(); return true; @@ -1325,7 +1414,7 @@ inline void JSObject::setStructureAndReallocateStorageIfNecessary(VM& vm, unsign inline void JSObject::setStructureAndReallocateStorageIfNecessary(VM& vm, Structure* newStructure) { setStructureAndReallocateStorageIfNecessary( - vm, structure(vm)->outOfLineCapacity(), newStructure); + vm, structure()->outOfLineCapacity(), newStructure); } inline bool JSObject::putOwnDataProperty(VM& vm, PropertyName propertyName, JSValue value, PutPropertySlot& slot) @@ -1333,35 +1422,31 @@ inline bool JSObject::putOwnDataProperty(VM& vm, PropertyName propertyName, JSVa ASSERT(value); ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this)); ASSERT(!structure()->hasGetterSetterProperties()); - ASSERT(!structure()->hasCustomGetterSetterProperties()); - return putDirectInternal<PutModePut>(vm, propertyName, value, 0, slot); + return putDirectInternal<PutModePut>(vm, propertyName, value, 0, slot, getCallableObject(value)); } inline void JSObject::putDirect(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes) { ASSERT(!value.isGetterSetter() && !(attributes & Accessor)); - ASSERT(!value.isCustomGetterSetter()); PutPropertySlot slot(this); - putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, attributes, slot); + putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, attributes, slot, getCallableObject(value)); } inline void JSObject::putDirect(VM& vm, PropertyName propertyName, JSValue value, PutPropertySlot& slot) { ASSERT(!value.isGetterSetter()); - ASSERT(!value.isCustomGetterSetter()); - putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, 0, slot); + putDirectInternal<PutModeDefineOwnProperty>(vm, propertyName, value, 0, slot, getCallableObject(value)); } inline void JSObject::putDirectWithoutTransition(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes) { DeferGC deferGC(vm.heap); ASSERT(!value.isGetterSetter() && !(attributes & Accessor)); - ASSERT(!value.isCustomGetterSetter()); Butterfly* newButterfly = m_butterfly.get(); if (structure()->putWillGrowOutOfLineStorage()) newButterfly = growOutOfLineStorage(vm, structure()->outOfLineCapacity(), structure()->suggestedNewOutOfLineStorageCapacity()); - PropertyOffset offset = structure()->addPropertyWithoutTransition(vm, propertyName, attributes); + PropertyOffset offset = structure()->addPropertyWithoutTransition(vm, propertyName, attributes, getCallableObject(value)); setStructureAndButterfly(vm, structure(), newButterfly); putDirect(vm, offset, value); } @@ -1371,15 +1456,18 @@ inline JSValue JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType pre return methodTable()->defaultValue(this, exec, preferredType); } -ALWAYS_INLINE JSObject* Register::object() const +ALWAYS_INLINE JSObject* Register::function() const { + if (!jsValue()) + return 0; return asObject(jsValue()); } -ALWAYS_INLINE Register& Register::operator=(JSObject* object) +ALWAYS_INLINE Register Register::withCallee(JSObject* callee) { - u.value = JSValue::encode(JSValue(object)); - return *this; + Register r; + r = JSValue(callee); + return r; } inline size_t offsetInButterfly(PropertyOffset offset) @@ -1387,32 +1475,6 @@ inline size_t offsetInButterfly(PropertyOffset offset) return offsetInOutOfLineStorage(offset) + Butterfly::indexOfPropertyStorage(); } -inline size_t JSObject::butterflyPreCapacity() -{ - if (UNLIKELY(hasIndexingHeader())) - return butterfly()->indexingHeader()->preCapacity(structure()); - return 0; -} - -inline size_t JSObject::butterflyTotalSize() -{ - Structure* structure = this->structure(); - Butterfly* butterfly = this->butterfly(); - size_t preCapacity; - size_t indexingPayloadSizeInBytes; - bool hasIndexingHeader = this->hasIndexingHeader(); - - if (UNLIKELY(hasIndexingHeader)) { - preCapacity = butterfly->indexingHeader()->preCapacity(structure); - indexingPayloadSizeInBytes = butterfly->indexingHeader()->indexingPayloadSizeInBytes(structure); - } else { - preCapacity = 0; - indexingPayloadSizeInBytes = 0; - } - - return Butterfly::totalSize(preCapacity, structure->outOfLineCapacity(), hasIndexingHeader, indexingPayloadSizeInBytes); -} - // Helpers for patching code where you want to emit a load or store and // the base is: // For inline offsets: a pointer to the out-of-line storage pointer. @@ -1454,7 +1516,7 @@ COMPILE_ASSERT(!(sizeof(JSObject) % sizeof(WriteBarrierBase<Unknown>)), JSObject ALWAYS_INLINE Identifier makeIdentifier(VM& vm, const char* name) { - return Identifier::fromString(&vm, name); + return Identifier(&vm, name); } ALWAYS_INLINE Identifier makeIdentifier(VM&, const Identifier& name) @@ -1476,11 +1538,27 @@ ALWAYS_INLINE Identifier makeIdentifier(VM&, const Identifier& name) #define JSC_NATIVE_FUNCTION(jsName, cppName, attributes, length) \ JSC_NATIVE_INTRINSIC_FUNCTION(jsName, cppName, (attributes), (length), NoIntrinsic) -// Identical helpers but for builtins. Note that currently, we don't support builtins that are -// also intrinsics, but we probably will do that eventually. -#define JSC_BUILTIN_FUNCTION(jsName, generatorName, attributes) \ - putDirectBuiltinFunction(\ - vm, globalObject, makeIdentifier(vm, (jsName)), (generatorName)(vm), (attributes)) +ALWAYS_INLINE JSValue PropertySlot::getValue(ExecState* exec, PropertyName propertyName) const +{ + if (m_propertyType == TypeValue) + return JSValue::decode(m_data.value); + if (m_propertyType == TypeCustomIndex) + return JSValue::decode(m_data.customIndex.getIndexValue(exec, JSValue::encode(slotBase()), JSValue::encode(m_thisValue), m_data.customIndex.index)); + if (m_propertyType == TypeGetter) + return functionGetter(exec); + return JSValue::decode(m_data.custom.getValue(exec, JSValue::encode(slotBase()), JSValue::encode(m_thisValue), propertyName)); +} + +ALWAYS_INLINE JSValue PropertySlot::getValue(ExecState* exec, unsigned propertyName) const +{ + if (m_propertyType == TypeValue) + return JSValue::decode(m_data.value); + if (m_propertyType == TypeCustomIndex) + return JSValue::decode(m_data.customIndex.getIndexValue(exec, JSValue::encode(slotBase()), JSValue::encode(m_thisValue), m_data.customIndex.index)); + if (m_propertyType == TypeGetter) + return functionGetter(exec); + return JSValue::decode(m_data.custom.getValue(exec, JSValue::encode(slotBase()), JSValue::encode(m_thisValue), Identifier::from(exec, propertyName))); +} } // namespace JSC |