blob: a5687192ef510e9562fc786f4ccd1b7c6b17b112 [file] [log] [blame]
/*
* Copyright (C) 1999-2001 Harri Porten (porten@kde.org)
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 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
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef JSObject_h
#define JSObject_h
#include "ArgList.h"
#include "ArrayConventions.h"
#include "ArrayStorage.h"
#include "Butterfly.h"
#include "ClassInfo.h"
#include "CommonIdentifiers.h"
#include "CallFrame.h"
#include "JSCell.h"
#include "PropertySlot.h"
#include "PropertyStorage.h"
#include "PutDirectIndexMode.h"
#include "PutPropertySlot.h"
#include "Structure.h"
#include "JSGlobalData.h"
#include "JSString.h"
#include "SlotVisitorInlines.h"
#include "SparseArrayValueMap.h"
#include <wtf/StdLibExtras.h>
namespace JSC {
inline JSCell* getJSFunction(JSValue value)
{
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 LLIntOffsetsExtractor;
class MarkedBlock;
class PropertyDescriptor;
class PropertyNameArray;
class Structure;
struct HashTable;
JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const String&);
JS_EXPORT_PRIVATE const char* GetStrictModeReadonlyPropertyWriteError();
// ECMA 262-3 8.6.1
// Property attributes
enum Attribute {
None = 0,
ReadOnly = 1 << 1, // property can be only read, not written
DontEnum = 1 << 2, // property doesn't appear in (for .. in ..)
DontDelete = 1 << 3, // property can't be deleted
Function = 1 << 4, // property is a function - only used by static hashtables
Accessor = 1 << 5, // property is a getter/setter
};
COMPILE_ASSERT(None < FirstInternalAttribute, None_is_below_FirstInternalAttribute);
COMPILE_ASSERT(ReadOnly < FirstInternalAttribute, ReadOnly_is_below_FirstInternalAttribute);
COMPILE_ASSERT(DontEnum < FirstInternalAttribute, DontEnum_is_below_FirstInternalAttribute);
COMPILE_ASSERT(DontDelete < FirstInternalAttribute, DontDelete_is_below_FirstInternalAttribute);
COMPILE_ASSERT(Function < FirstInternalAttribute, Function_is_below_FirstInternalAttribute);
COMPILE_ASSERT(Accessor < FirstInternalAttribute, Accessor_is_below_FirstInternalAttribute);
class JSFinalObject;
class JSObject : public JSCell {
friend class BatchedTransitionOptimizer;
friend class JIT;
friend class JSCell;
friend class JSFinalObject;
friend class MarkedBlock;
JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject*, PropertyName, PropertySlot&);
enum PutMode {
PutModePut,
PutModeDefineOwnProperty,
};
public:
typedef JSCell Base;
static size_t allocationSize(size_t inlineCapacity)
{
return sizeof(JSObject) + inlineCapacity * sizeof(WriteBarrierBase<Unknown>);
}
JS_EXPORT_PRIVATE static void visitChildrenInternal(JSCell*, SlotVisitor&);
static void visitChildren(JSCell* cell, SlotVisitor& slotVisitor) {
return visitChildrenInternal(cell, slotVisitor);
}
JS_EXPORT_PRIVATE static void copyBackingStoreInternal(JSCell*, CopyVisitor&);
static void copyBackingStore(JSCell* cell, CopyVisitor& copyVisitor) {
return copyBackingStoreInternal(cell, copyVisitor);
}
JS_EXPORT_PRIVATE static String classNameInternal(const JSObject*);
static String className(const JSObject* object) {
return classNameInternal(object);
}
JSValue prototype() const;
JS_EXPORT_PRIVATE void setPrototype(JSGlobalData&, JSValue prototype);
bool setPrototypeWithCycleCheck(JSGlobalData&, JSValue prototype);
Structure* inheritorID(JSGlobalData&);
void notifyUsedAsPrototype(JSGlobalData&);
bool mayBeUsedAsPrototype(JSGlobalData& globalData)
{
return isValidOffset(structure()->get(globalData, globalData.m_inheritorIDKey));
}
bool mayInterceptIndexedAccesses()
{
return structure()->mayInterceptIndexedAccesses();
}
JSValue get(ExecState*, PropertyName) const;
JSValue get(ExecState*, unsigned propertyName) const;
bool getPropertySlot(ExecState*, PropertyName, PropertySlot&);
bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
JS_EXPORT_PRIVATE bool getPropertyDescriptor(ExecState*, PropertyName, PropertyDescriptor&);
static bool getOwnPropertySlot(JSCell*, ExecState*, PropertyName, PropertySlot&);
JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndexInternal(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
static bool getOwnPropertySlotByIndex(JSCell* cell, ExecState* exec, unsigned propertyName, PropertySlot& slot) {
return getOwnPropertySlotByIndexInternal(cell, exec, propertyName, slot);
}
JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptorInternal(JSObject*, ExecState*, PropertyName, PropertyDescriptor&);
static bool getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName name, PropertyDescriptor& descriptor) {
return getOwnPropertyDescriptorInternal(object, exec, name, descriptor);
}
bool allowsAccessFrom(ExecState*);
unsigned getArrayLength() const
{
if (!hasIndexedProperties(structure()->indexingType()))
return 0;
return m_butterfly->publicLength();
}
unsigned getVectorLength()
{
if (!hasIndexedProperties(structure()->indexingType()))
return 0;
return m_butterfly->vectorLength();
}
JS_EXPORT_PRIVATE static void putInternal(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
static void put(JSCell* cell, ExecState* exec, PropertyName name, JSValue value, PutPropertySlot& slot) {
return putInternal(cell, exec, name, value, slot);
}
JS_EXPORT_PRIVATE static void putByIndexInternal(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
static void putByIndex(JSCell* cell, ExecState*exec, unsigned propertyName, JSValue value, bool shouldThrow) {
return putByIndexInternal(cell, exec, propertyName, value, shouldThrow);
}
void putByIndexInline(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)
{
if (canSetIndexQuickly(propertyName)) {
setIndexQuickly(exec->globalData(), propertyName, value);
return;
}
methodTable()->putByIndex(this, exec, propertyName, value, shouldThrow);
}
// This is similar to the putDirect* methods:
// - the prototype chain is not consulted
// - accessors are not called.
// - it will ignore extensibility and read-only properties if PutDirectIndexLikePutDirect is passed as the mode (the default).
// This method creates a property with attributes writable, enumerable and configurable all set to true.
bool putDirectIndex(ExecState* exec, unsigned propertyName, JSValue value, unsigned attributes, PutDirectIndexMode mode)
{
if (!attributes && canSetIndexQuicklyForPutDirect(propertyName)) {
setIndexQuickly(exec->globalData(), propertyName, value);
return true;
}
return putDirectIndexBeyondVectorLength(exec, propertyName, value, attributes, mode);
}
bool putDirectIndex(ExecState* exec, unsigned propertyName, JSValue value)
{
return putDirectIndex(exec, propertyName, value, 0, PutDirectIndexLikePutDirect);
}
// A non-throwing version of putDirect and putDirectIndex.
JS_EXPORT_PRIVATE void putDirectMayBeIndex(ExecState*, PropertyName, JSValue);
bool canGetIndexQuickly(unsigned i)
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
return false;
case ALL_INT32_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
return i < m_butterfly->vectorLength() && m_butterfly->contiguous()[i];
case ALL_DOUBLE_INDEXING_TYPES: {
if (i >= m_butterfly->vectorLength())
return false;
double value = m_butterfly->contiguousDouble()[i];
if (value != value)
return false;
return true;
}
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return i < m_butterfly->arrayStorage()->vectorLength() && m_butterfly->arrayStorage()->m_vector[i];
default:
ASSERT_NOT_REACHED();
return false;
}
}
JSValue getIndexQuickly(unsigned i)
{
switch (structure()->indexingType()) {
case ALL_INT32_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
return m_butterfly->contiguous()[i].get();
case ALL_DOUBLE_INDEXING_TYPES:
return JSValue(JSValue::EncodeAsDouble, m_butterfly->contiguousDouble()[i]);
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return m_butterfly->arrayStorage()->m_vector[i].get();
default:
ASSERT_NOT_REACHED();
return JSValue();
}
}
JSValue tryGetIndexQuickly(unsigned i)
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
break;
case ALL_INT32_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
if (i < m_butterfly->publicLength())
return m_butterfly->contiguous()[i].get();
break;
case ALL_DOUBLE_INDEXING_TYPES: {
if (i >= m_butterfly->publicLength())
break;
double result = m_butterfly->contiguousDouble()[i];
if (result != result)
break;
return JSValue(JSValue::EncodeAsDouble, result);
}
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
if (i < m_butterfly->arrayStorage()->vectorLength())
return m_butterfly->arrayStorage()->m_vector[i].get();
break;
default:
ASSERT_NOT_REACHED();
break;
}
return JSValue();
}
JSValue getDirectIndex(ExecState* exec, unsigned i)
{
if (JSValue result = tryGetIndexQuickly(i))
return result;
PropertySlot slot(this);
if (methodTable()->getOwnPropertySlotByIndex(this, exec, i, slot))
return slot.getValue(exec, i);
return JSValue();
}
JSValue getIndex(ExecState* exec, unsigned i)
{
if (JSValue result = tryGetIndexQuickly(i))
return result;
return get(exec, i);
}
bool canSetIndexQuickly(unsigned i)
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
return false;
case ALL_INT32_INDEXING_TYPES:
case ALL_DOUBLE_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
case NonArrayWithArrayStorage:
case ArrayWithArrayStorage:
return i < m_butterfly->vectorLength();
case NonArrayWithSlowPutArrayStorage:
case ArrayWithSlowPutArrayStorage:
return i < m_butterfly->arrayStorage()->vectorLength()
&& !!m_butterfly->arrayStorage()->m_vector[i];
default:
ASSERT_NOT_REACHED();
return false;
}
}
bool canSetIndexQuicklyForPutDirect(unsigned i)
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
return false;
case ALL_INT32_INDEXING_TYPES:
case ALL_DOUBLE_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return i < m_butterfly->vectorLength();
default:
ASSERT_NOT_REACHED();
return false;
}
}
void setIndexQuickly(JSGlobalData& globalData, unsigned i, JSValue v)
{
switch (structure()->indexingType()) {
case ALL_INT32_INDEXING_TYPES: {
ASSERT(i < m_butterfly->vectorLength());
if (!v.isInt32()) {
convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(globalData, i, v);
return;
}
// Fall through to contiguous case.
}
case ALL_CONTIGUOUS_INDEXING_TYPES: {
ASSERT(i < m_butterfly->vectorLength());
m_butterfly->contiguous()[i].set(globalData, this, v);
if (i >= m_butterfly->publicLength())
m_butterfly->setPublicLength(i + 1);
break;
}
case ALL_DOUBLE_INDEXING_TYPES: {
ASSERT(i < m_butterfly->vectorLength());
if (!v.isNumber()) {
convertDoubleToContiguousWhilePerformingSetIndex(globalData, i, v);
return;
}
double value = v.asNumber();
if (value != value) {
convertDoubleToContiguousWhilePerformingSetIndex(globalData, i, v);
return;
}
m_butterfly->contiguousDouble()[i] = value;
if (i >= m_butterfly->publicLength())
m_butterfly->setPublicLength(i + 1);
break;
}
case ALL_ARRAY_STORAGE_INDEXING_TYPES: {
ArrayStorage* storage = m_butterfly->arrayStorage();
WriteBarrier<Unknown>& x = storage->m_vector[i];
JSValue old = x.get();
x.set(globalData, this, v);
if (!old) {
++storage->m_numValuesInVector;
if (i >= storage->length())
storage->setLength(i + 1);
}
break;
}
default:
ASSERT_NOT_REACHED();
}
}
void initializeIndex(JSGlobalData& globalData, unsigned i, JSValue v)
{
switch (structure()->indexingType()) {
case ALL_UNDECIDED_INDEXING_TYPES: {
setIndexQuicklyToUndecided(globalData, i, v);
break;
}
case ALL_INT32_INDEXING_TYPES: {
ASSERT(i < m_butterfly->publicLength());
ASSERT(i < m_butterfly->vectorLength());
if (!v.isInt32()) {
convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(globalData, i, v);
break;
}
// Fall through.
}
case ALL_CONTIGUOUS_INDEXING_TYPES: {
ASSERT(i < m_butterfly->publicLength());
ASSERT(i < m_butterfly->vectorLength());
m_butterfly->contiguous()[i].set(globalData, this, v);
break;
}
case ALL_DOUBLE_INDEXING_TYPES: {
ASSERT(i < m_butterfly->publicLength());
ASSERT(i < m_butterfly->vectorLength());
if (!v.isNumber()) {
convertDoubleToContiguousWhilePerformingSetIndex(globalData, i, v);
return;
}
double value = v.asNumber();
if (value != value) {
convertDoubleToContiguousWhilePerformingSetIndex(globalData, i, v);
return;
}
m_butterfly->contiguousDouble()[i] = value;
break;
}
case ALL_ARRAY_STORAGE_INDEXING_TYPES: {
ArrayStorage* storage = m_butterfly->arrayStorage();
ASSERT(i < storage->length());
ASSERT(i < storage->m_numValuesInVector);
storage->m_vector[i].set(globalData, this, v);
break;
}
default:
ASSERT_NOT_REACHED();
}
}
bool hasSparseMap()
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
case ALL_INT32_INDEXING_TYPES:
case ALL_DOUBLE_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
return false;
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return m_butterfly->arrayStorage()->m_sparseMap;
default:
ASSERT_NOT_REACHED();
return false;
}
}
bool inSparseIndexingMode()
{
switch (structure()->indexingType()) {
case ALL_BLANK_INDEXING_TYPES:
case ALL_UNDECIDED_INDEXING_TYPES:
case ALL_INT32_INDEXING_TYPES:
case ALL_DOUBLE_INDEXING_TYPES:
case ALL_CONTIGUOUS_INDEXING_TYPES:
return false;
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return m_butterfly->arrayStorage()->inSparseMode();
default:
ASSERT_NOT_REACHED();
return false;
}
}
void enterDictionaryIndexingMode(JSGlobalData&);
// putDirect is effectively an unchecked vesion of 'defineOwnProperty':
// - the prototype chain is not consulted
// - accessors are not called.
// - attributes will be respected (after the call the property will exist with the given attributes)
// - the property name is assumed to not be an index.
JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, PropertyName, JSValue, unsigned attributes);
void putDirect(JSGlobalData&, PropertyName, JSValue, unsigned attributes = 0);
void putDirect(JSGlobalData&, PropertyName, JSValue, PutPropertySlot&);
void putDirectWithoutTransition(JSGlobalData&, PropertyName, JSValue, unsigned attributes = 0);
void putDirectAccessor(ExecState*, PropertyName, JSValue, unsigned attributes);
bool propertyIsEnumerable(ExecState*, const Identifier& propertyName) const;
JS_EXPORT_PRIVATE bool hasProperty(ExecState*, PropertyName) const;
JS_EXPORT_PRIVATE bool hasProperty(ExecState*, unsigned propertyName) const;
JS_EXPORT_PRIVATE bool hasOwnProperty(ExecState*, PropertyName) const;
JS_EXPORT_PRIVATE static bool deletePropertyInternal(JSCell*, ExecState*, PropertyName);
static bool deleteProperty(JSCell* cell, ExecState* exec, PropertyName name) {
return deletePropertyInternal(cell, exec, name);
}
JS_EXPORT_PRIVATE static bool deletePropertyByIndexInternal(JSCell*, ExecState*, unsigned propertyName);
static bool deletePropertyByIndex(JSCell* cell, ExecState* exec, unsigned propertyName) {
return deletePropertyByIndexInternal(cell, exec, propertyName);
}
JS_EXPORT_PRIVATE static JSValue defaultValueInternal(const JSObject*, ExecState*, PreferredPrimitiveType);
static JSValue defaultValue(const JSObject* object, ExecState* exec, PreferredPrimitiveType type) {
return defaultValueInternal(object, exec, type);
}
bool hasInstance(ExecState*, JSValue);
static bool defaultHasInstance(ExecState*, JSValue, JSValue prototypeProperty);
JS_EXPORT_PRIVATE static void getOwnPropertyNamesInternal(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
static void getOwnPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& nameArray, EnumerationMode mode) {
return getOwnPropertyNamesInternal(object, exec, nameArray, mode);
}
JS_EXPORT_PRIVATE static void getOwnNonIndexPropertyNamesInternal(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
static void getOwnNonIndexPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& nameArray, EnumerationMode mode) {
return getOwnNonIndexPropertyNamesInternal(object, exec, nameArray, mode);
}
JS_EXPORT_PRIVATE static void getPropertyNamesInternal(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
static void getPropertyNames(JSObject* object, ExecState* exec, PropertyNameArray& nameArray, EnumerationMode mode) {
return getPropertyNamesInternal(object, exec, nameArray, mode);
}
JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
JS_EXPORT_PRIVATE JSString* toString(ExecState*) const;
// NOTE: JSObject and its subclasses must be able to gracefully handle ExecState* = 0,
// because this call may come from inside the compiler.
JS_EXPORT_PRIVATE static JSObject* toThisObjectInternal(JSCell* cell, ExecState* exec);
static JSObject* toThisObject(JSCell* cell, ExecState* exec) {
return toThisObjectInternal(cell, exec);
}
bool getPropertySpecificValue(ExecState*, PropertyName, JSCell*& specificFunction) const;
// This get function only looks at the property map.
JSValue getDirect(JSGlobalData& globalData, PropertyName propertyName) const
{
PropertyOffset offset = structure()->get(globalData, propertyName);
checkOffset(offset, structure()->inlineCapacity());
return offset != invalidOffset ? getDirect(offset) : JSValue();
}
PropertyOffset getDirectOffset(JSGlobalData& globalData, PropertyName propertyName)
{
PropertyOffset offset = structure()->get(globalData, propertyName);
checkOffset(offset, structure()->inlineCapacity());
return offset;
}
WriteBarrierBase<Unknown>* getDirectLocation(JSGlobalData& globalData, PropertyName propertyName, unsigned& attributes)
{
JSCell* specificFunction;
PropertyOffset offset = structure()->get(globalData, propertyName, attributes, specificFunction);
return isValidOffset(offset) ? locationForOffset(offset) : 0;
}
bool hasInlineStorage() const { return structure()->hasInlineStorage(); }
ConstPropertyStorage inlineStorageUnsafe() const
{
return bitwise_cast<ConstPropertyStorage>(this + 1);
}
PropertyStorage inlineStorageUnsafe()
{
return bitwise_cast<PropertyStorage>(this + 1);
}
ConstPropertyStorage inlineStorage() const
{
ASSERT(hasInlineStorage());
return inlineStorageUnsafe();
}
PropertyStorage inlineStorage()
{
ASSERT(hasInlineStorage());
return inlineStorageUnsafe();
}
const Butterfly* butterfly() const { return m_butterfly; }
Butterfly* butterfly() { return m_butterfly; }
ConstPropertyStorage outOfLineStorage() const { return m_butterfly->propertyStorage(); }
PropertyStorage outOfLineStorage() { return m_butterfly->propertyStorage(); }
const WriteBarrierBase<Unknown>* locationForOffset(PropertyOffset offset) const
{
if (isInlineOffset(offset))
return &inlineStorage()[offsetInInlineStorage(offset)];
return &outOfLineStorage()[offsetInOutOfLineStorage(offset)];
}
WriteBarrierBase<Unknown>* locationForOffset(PropertyOffset offset)
{
if (isInlineOffset(offset))
return &inlineStorage()[offsetInInlineStorage(offset)];
return &outOfLineStorage()[offsetInOutOfLineStorage(offset)];
}
void transitionTo(JSGlobalData&, Structure*);
bool removeDirect(JSGlobalData&, PropertyName); // Return true if anything is removed.
bool hasCustomProperties() { return structure()->didTransition(); }
bool hasGetterSetterProperties() { return structure()->hasGetterSetterProperties(); }
// 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 JSActivation.
bool putOwnDataProperty(JSGlobalData&, PropertyName, JSValue, PutPropertySlot&);
// Fast access to known property offsets.
JSValue getDirect(PropertyOffset offset) const { return locationForOffset(offset)->get(); }
void putDirect(JSGlobalData& globalData, PropertyOffset offset, JSValue value) { locationForOffset(offset)->set(globalData, this, value); }
void putDirectUndefined(PropertyOffset offset) { locationForOffset(offset)->setUndefined(); }
JS_EXPORT_PRIVATE static bool defineOwnPropertyInternal(JSObject*, ExecState*, PropertyName, PropertyDescriptor&, bool shouldThrow);
static bool defineOwnProperty(JSObject* object, ExecState* exec, PropertyName name, PropertyDescriptor& descriptor, bool shouldThrow) {
return defineOwnPropertyInternal(object, exec, name, descriptor, shouldThrow);
}
bool isGlobalObject() const;
bool isVariableObject() const;
bool isNameScopeObject() const;
bool isActivationObject() const;
bool isErrorInstance() const;
void seal(JSGlobalData&);
void freeze(JSGlobalData&);
JS_EXPORT_PRIVATE void preventExtensions(JSGlobalData&);
bool isSealed(JSGlobalData& globalData) { return structure()->isSealed(globalData); }
bool isFrozen(JSGlobalData& globalData) { return structure()->isFrozen(globalData); }
bool isExtensible() { return structure()->isExtensible(); }
bool indexingShouldBeSparse()
{
return !isExtensible()
|| structure()->typeInfo().interceptsGetOwnPropertySlotByIndexEvenWhenLengthIsNotZero();
}
bool staticFunctionsReified() { return structure()->staticFunctionsReified(); }
void reifyStaticFunctionsForDelete(ExecState* exec);
JS_EXPORT_PRIVATE Butterfly* growOutOfLineStorage(JSGlobalData&, size_t oldSize, size_t newSize);
void setButterfly(JSGlobalData&, Butterfly*, Structure*);
void setButterflyWithoutChangingStructure(Butterfly*); // You probably don't want to call this.
void setStructureAndReallocateStorageIfNecessary(JSGlobalData&, unsigned oldCapacity, Structure*);
void setStructureAndReallocateStorageIfNecessary(JSGlobalData&, Structure*);
void flattenDictionaryObject(JSGlobalData& globalData)
{
structure()->flattenDictionaryStructure(globalData, this);
}
JSGlobalObject* globalObject() const
{
ASSERT(structure()->globalObject());
ASSERT(!isGlobalObject() || ((JSObject*)structure()->globalObject()) == this);
return structure()->globalObject();
}
void switchToSlowPutArrayStorage(JSGlobalData&);
// The receiver is the prototype in this case. The following:
//
// asObject(foo->structure()->storedPrototype())->attemptToInterceptPutByIndexOnHoleForPrototype(...)
//
// is equivalent to:
//
// foo->attemptToInterceptPutByIndexOnHole(...);
bool attemptToInterceptPutByIndexOnHoleForPrototype(ExecState*, JSValue thisValue, unsigned propertyName, JSValue, bool shouldThrow);
// Returns 0 if int32 storage cannot be created - either because
// indexing should be sparse, we're having a bad time, or because
// we already have a more general form of storage (double,
// contiguous, array storage).
WriteBarrier<Unknown>* ensureInt32(JSGlobalData& globalData)
{
if (LIKELY(hasInt32(structure()->indexingType())))
return m_butterfly->contiguousInt32();
return ensureInt32Slow(globalData);
}
// Returns 0 if double storage cannot be created - either because
// indexing should be sparse, we're having a bad time, or because
// we already have a more general form of storage (contiguous,
// or array storage).
double* ensureDouble(JSGlobalData& globalData)
{
if (LIKELY(hasDouble(structure()->indexingType())))
return m_butterfly->contiguousDouble();
return ensureDoubleSlow(globalData);
}
// Returns 0 if contiguous storage cannot be created - either because
// indexing should be sparse or because we're having a bad time.
WriteBarrier<Unknown>* ensureContiguous(JSGlobalData& globalData)
{
if (LIKELY(hasContiguous(structure()->indexingType())))
return m_butterfly->contiguous();
return ensureContiguousSlow(globalData);
}
// 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.
WriteBarrier<Unknown>* rageEnsureContiguous(JSGlobalData& globalData)
{
if (LIKELY(hasContiguous(structure()->indexingType())))
return m_butterfly->contiguous();
return rageEnsureContiguousSlow(globalData);
}
// 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(JSGlobalData& globalData)
{
if (LIKELY(hasArrayStorage(structure()->indexingType())))
return m_butterfly->arrayStorage();
return ensureArrayStorageSlow(globalData);
}
static size_t offsetOfInlineStorage();
static ptrdiff_t butterflyOffset()
{
return OBJECT_OFFSETOF(JSObject, m_butterfly);
}
void* butterflyAddress()
{
return &m_butterfly;
}
DECLARE_EXPORTED_CLASSINFO();
protected:
void finishCreation(JSGlobalData& globalData)
{
Base::finishCreation(globalData);
ASSERT(inherits(s_classinfo()));
ASSERT(!structure()->outOfLineCapacity());
ASSERT(structure()->isEmpty());
ASSERT(prototype().isNull() || Heap::heap(this) == Heap::heap(prototype()));
ASSERT(structure()->isObject());
ASSERT(classInfo());
}
static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(globalData, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), s_classinfo());
}
// To instantiate objects you likely want JSFinalObject, below.
// To create derived types you likely want JSNonFinalObject, below.
JSObject(JSGlobalData&, Structure*, Butterfly* = 0);
void resetInheritorID(JSGlobalData&);
void visitButterfly(SlotVisitor&, Butterfly*, size_t storageSize);
void copyButterfly(CopyVisitor&, Butterfly*, size_t storageSize);
// Call this if you know that the object is in a mode where it has array
// storage. This will assert otherwise.
ArrayStorage* arrayStorage()
{
ASSERT(hasArrayStorage(structure()->indexingType()));
return m_butterfly->arrayStorage();
}
// Call this if you want to predicate some actions on whether or not the
// object is in a mode where it has array storage.
ArrayStorage* arrayStorageOrNull()
{
switch (structure()->indexingType()) {
case ALL_ARRAY_STORAGE_INDEXING_TYPES:
return m_butterfly->arrayStorage();
default:
return 0;
}
}
Butterfly* createInitialUndecided(JSGlobalData&, unsigned length);
WriteBarrier<Unknown>* createInitialInt32(JSGlobalData&, unsigned length);
double* createInitialDouble(JSGlobalData&, unsigned length);
WriteBarrier<Unknown>* createInitialContiguous(JSGlobalData&, unsigned length);
void convertUndecidedForValue(JSGlobalData&, JSValue);
void convertInt32ForValue(JSGlobalData&, JSValue);
ArrayStorage* createArrayStorage(JSGlobalData&, unsigned length, unsigned vectorLength);
ArrayStorage* createInitialArrayStorage(JSGlobalData&);
WriteBarrier<Unknown>* convertUndecidedToInt32(JSGlobalData&);
double* convertUndecidedToDouble(JSGlobalData&);
WriteBarrier<Unknown>* convertUndecidedToContiguous(JSGlobalData&);
ArrayStorage* convertUndecidedToArrayStorage(JSGlobalData&, NonPropertyTransition, unsigned neededLength);
ArrayStorage* convertUndecidedToArrayStorage(JSGlobalData&, NonPropertyTransition);
ArrayStorage* convertUndecidedToArrayStorage(JSGlobalData&);
double* convertInt32ToDouble(JSGlobalData&);
WriteBarrier<Unknown>* convertInt32ToContiguous(JSGlobalData&);
ArrayStorage* convertInt32ToArrayStorage(JSGlobalData&, NonPropertyTransition, unsigned neededLength);
ArrayStorage* convertInt32ToArrayStorage(JSGlobalData&, NonPropertyTransition);
ArrayStorage* convertInt32ToArrayStorage(JSGlobalData&);
WriteBarrier<Unknown>* convertDoubleToContiguous(JSGlobalData&);
WriteBarrier<Unknown>* rageConvertDoubleToContiguous(JSGlobalData&);
ArrayStorage* convertDoubleToArrayStorage(JSGlobalData&, NonPropertyTransition, unsigned neededLength);
ArrayStorage* convertDoubleToArrayStorage(JSGlobalData&, NonPropertyTransition);
ArrayStorage* convertDoubleToArrayStorage(JSGlobalData&);
ArrayStorage* convertContiguousToArrayStorage(JSGlobalData&, NonPropertyTransition, unsigned neededLength);
ArrayStorage* convertContiguousToArrayStorage(JSGlobalData&, NonPropertyTransition);
ArrayStorage* convertContiguousToArrayStorage(JSGlobalData&);
ArrayStorage* ensureArrayStorageExistsAndEnterDictionaryIndexingMode(JSGlobalData&);
bool defineOwnNonIndexProperty(ExecState*, PropertyName, PropertyDescriptor&, bool throwException);
template<IndexingType indexingShape>
void putByIndexBeyondVectorLengthWithoutAttributes(ExecState*, unsigned propertyName, JSValue);
void putByIndexBeyondVectorLengthWithArrayStorage(ExecState*, unsigned propertyName, JSValue, bool shouldThrow, ArrayStorage*);
bool increaseVectorLength(JSGlobalData&, unsigned newLength);
void deallocateSparseIndexMap();
bool defineOwnIndexedProperty(ExecState*, unsigned, PropertyDescriptor&, bool throwException);
SparseArrayValueMap* allocateSparseIndexMap(JSGlobalData&);
void notifyPresenceOfIndexedAccessors(JSGlobalData&);
bool attemptToInterceptPutByIndexOnHole(ExecState*, unsigned index, JSValue, bool shouldThrow);
// Call this if you want setIndexQuickly to succeed and you're sure that
// the array is contiguous.
void ensureLength(JSGlobalData& globalData, unsigned length)
{
ASSERT(length < MAX_ARRAY_INDEX);
ASSERT(hasContiguous(structure()->indexingType()) || hasInt32(structure()->indexingType()) || hasDouble(structure()->indexingType()) || hasUndecided(structure()->indexingType()));
if (m_butterfly->vectorLength() < length)
ensureLengthSlow(globalData, length);
if (m_butterfly->publicLength() < length)
m_butterfly->setPublicLength(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>
WriteBarrier<Unknown>* 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()->m_vector;
default:
CRASH();
return 0;
}
}
WriteBarrier<Unknown>* 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()->m_vector;
default:
CRASH();
return 0;
}
}
JSValue getHolyIndexQuickly(unsigned i)
{
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;
// Nobody should ever ask any of these questions on something already known to be a JSObject.
using JSCell::isAPIValueWrapper;
using JSCell::isGetterSetter;
void getObject();
void getString(ExecState* exec);
void isObject();
void isString();
Butterfly* createInitialIndexedStorage(JSGlobalData&, unsigned length, size_t elementSize);
ArrayStorage* enterDictionaryIndexingModeWhenArrayStorageAlreadyExists(JSGlobalData&, ArrayStorage*);
template<PutMode>
bool putDirectInternal(JSGlobalData&, PropertyName, JSValue, unsigned attr, PutPropertySlot&, JSCell*);
bool inlineGetOwnPropertySlot(ExecState*, PropertyName, PropertySlot&);
JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, PropertyOffset);
const HashEntry* findPropertyHashEntry(ExecState*, PropertyName) const;
Structure* createInheritorID(JSGlobalData&);
void putIndexedDescriptor(ExecState*, SparseArrayEntry*, PropertyDescriptor&, PropertyDescriptor& old);
void putByIndexBeyondVectorLength(ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
bool putDirectIndexBeyondVectorLengthWithArrayStorage(ExecState*, unsigned propertyName, JSValue, unsigned attributes, PutDirectIndexMode, ArrayStorage*);
JS_EXPORT_PRIVATE bool putDirectIndexBeyondVectorLength(ExecState*, unsigned propertyName, JSValue, unsigned attributes, PutDirectIndexMode);
unsigned getNewVectorLength(unsigned currentVectorLength, unsigned currentLength, unsigned desiredLength);
unsigned getNewVectorLength(unsigned desiredLength);
JS_EXPORT_PRIVATE bool getOwnPropertySlotSlow(ExecState*, PropertyName, PropertySlot&);
ArrayStorage* constructConvertedArrayStorageWithoutCopyingElements(JSGlobalData&, unsigned neededLength);
JS_EXPORT_PRIVATE void setIndexQuicklyToUndecided(JSGlobalData&, unsigned index, JSValue);
JS_EXPORT_PRIVATE void convertInt32ToDoubleOrContiguousWhilePerformingSetIndex(JSGlobalData&, unsigned index, JSValue);
JS_EXPORT_PRIVATE void convertDoubleToContiguousWhilePerformingSetIndex(JSGlobalData&, unsigned index, JSValue);
void ensureLengthSlow(JSGlobalData&, unsigned length);
WriteBarrier<Unknown>* ensureInt32Slow(JSGlobalData&);
double* ensureDoubleSlow(JSGlobalData&);
WriteBarrier<Unknown>* ensureContiguousSlow(JSGlobalData&);
WriteBarrier<Unknown>* rageEnsureContiguousSlow(JSGlobalData&);
ArrayStorage* ensureArrayStorageSlow(JSGlobalData&);
enum DoubleToContiguousMode { EncodeValueAsDouble, RageConvertDoubleToValue };
template<DoubleToContiguousMode mode>
WriteBarrier<Unknown>* genericConvertDoubleToContiguous(JSGlobalData&);
WriteBarrier<Unknown>* ensureContiguousSlow(JSGlobalData&, DoubleToContiguousMode);
protected:
Butterfly* m_butterfly;
};
// JSNonFinalObject is a type of JSObject that has some internal storage,
// but also preserves some space in the collector cell for additional
// data members in derived types.
class JSNonFinalObject : public JSObject {
friend class JSObject;
public:
typedef JSObject Base;
static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(globalData, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), Base::s_classinfo());
}
protected:
explicit JSNonFinalObject(JSGlobalData& globalData, Structure* structure, Butterfly* butterfly = 0)
: JSObject(globalData, structure, butterfly)
{
}
void finishCreation(JSGlobalData& globalData)
{
Base::finishCreation(globalData);
ASSERT(!this->structure()->totalStorageCapacity());
ASSERT(classInfo());
}
};
class JSFinalObject;
// JSFinalObject is a type of JSObject that contains sufficent internal
// storage to fully make use of the colloctor cell containing it.
class JSFinalObject : public JSObject {
friend class JSObject;
public:
typedef JSObject Base;
JS_EXPORT_PRIVATE static JSFinalObject* create(ExecState*, Structure*);
static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(globalData, globalObject, prototype, TypeInfo(FinalObjectType, StructureFlags), s_classinfo(), NonArray, INLINE_STORAGE_CAPACITY);
}
JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
DECLARE_EXPORTED_CLASSINFO();
protected:
void visitChildrenCommon(SlotVisitor&);
void finishCreation(JSGlobalData& globalData)
{
Base::finishCreation(globalData);
ASSERT(structure()->totalStorageCapacity() == structure()->inlineCapacity());
ASSERT(classInfo());
}
private:
friend class LLIntOffsetsExtractor;
explicit JSFinalObject(JSGlobalData& globalData, Structure* structure)
: JSObject(globalData, structure)
{
}
static const unsigned StructureFlags = JSObject::StructureFlags;
};
inline bool isJSFinalObject(JSCell* cell)
{
return cell->classInfo() == JSFinalObject::s_classinfo();
}
inline bool isJSFinalObject(JSValue value)
{
return value.isCell() && isJSFinalObject(value.asCell());
}
inline size_t JSObject::offsetOfInlineStorage()
{
return sizeof(JSObject);
}
inline bool JSObject::isGlobalObject() const
{
return structure()->typeInfo().type() == GlobalObjectType;
}
inline bool JSObject::isVariableObject() const
{
return structure()->typeInfo().type() >= VariableObjectType;
}
inline bool JSObject::isNameScopeObject() const
{
return structure()->typeInfo().type() == NameScopeObjectType;
}
inline bool JSObject::isActivationObject() const
{
return structure()->typeInfo().type() == ActivationObjectType;
}
inline bool JSObject::isErrorInstance() const
{
return structure()->typeInfo().type() == ErrorInstanceType;
}
inline void JSObject::setButterfly(JSGlobalData& globalData, Butterfly* butterfly, Structure* structure)
{
ASSERT(structure);
ASSERT(!butterfly == (!structure->outOfLineCapacity() && !hasIndexingHeader(structure->indexingType())));
setStructure(globalData, structure);
m_butterfly = butterfly;
}
inline void JSObject::setButterflyWithoutChangingStructure(Butterfly* butterfly)
{
m_butterfly = butterfly;
}
inline JSObject* constructEmptyObject(ExecState* exec, Structure* structure)
{
return JSFinalObject::create(exec, structure);
}
inline CallType getCallData(JSValue value, CallData& callData)
{
CallType result = value.isCell() ? value.asCell()->methodTable()->getCallData(value.asCell(), callData) : CallTypeNone;
ASSERT(result == CallTypeNone || value.isValidCallee());
return result;
}
inline ConstructType getConstructData(JSValue value, ConstructData& constructData)
{
ConstructType result = value.isCell() ? value.asCell()->methodTable()->getConstructData(value.asCell(), constructData) : ConstructTypeNone;
ASSERT(result == ConstructTypeNone || value.isValidCallee());
return result;
}
inline Structure* createEmptyObjectStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
{
return JSFinalObject::createStructure(globalData, globalObject, prototype);
}
inline JSObject* asObject(JSCell* cell)
{
ASSERT(cell->isObject());
return jsCast<JSObject*>(cell);
}
inline JSObject* asObject(JSValue value)
{
return asObject(value.asCell());
}
inline JSObject::JSObject(JSGlobalData& globalData, Structure* structure, Butterfly* butterfly)
: JSCell(globalData, structure)
, m_butterfly(butterfly)
{
}
inline JSValue JSObject::prototype() const
{
return structure()->storedPrototype();
}
inline const MethodTable* JSCell::methodTable() const
{
return &classInfo()->methodTable;
}
inline bool JSCell::inherits(const ClassInfo* info) const
{
return classInfo()->isSubClassOf(info);
}
// this method is here to be after the inline declaration of JSCell::inherits
inline bool JSValue::inherits(const ClassInfo* classInfo) const
{
return isCell() && asCell()->inherits(classInfo);
}
inline JSObject* JSValue::toThisObject(ExecState* exec) const
{
if (isCell()) {
JSCell* cell = asCell();
const MethodTable* methodTable = cell->methodTable();
return methodTable->toThisObject(cell, exec);
} else {
return toThisObjectSlowCase(exec);
}
}
ALWAYS_INLINE bool JSObject::inlineGetOwnPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
PropertyOffset offset = structure()->get(exec->globalData(), propertyName);
if (LIKELY(isValidOffset(offset))) {
JSValue value = getDirect(offset);
if (structure()->hasGetterSetterProperties() && value.isGetterSetter())
fillGetterPropertySlot(slot, offset);
else
slot.setValue(this, value, offset);
return true;
}
return getOwnPropertySlotSlow(exec, propertyName, slot);
}
// It may seem crazy to inline a function this large, especially a virtual function,
// but it makes a big difference to property lookup that derived classes can inline their
// base class call to this.
ALWAYS_INLINE bool JSObject::getOwnPropertySlot(JSCell* cell, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
return jsCast<JSObject*>(cell)->inlineGetOwnPropertySlot(exec, propertyName, slot);
}
ALWAYS_INLINE bool JSCell::fastGetOwnPropertySlot(ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
if (!structure()->typeInfo().overridesGetOwnPropertySlot())
return asObject(this)->inlineGetOwnPropertySlot(exec, propertyName, slot);
return methodTable()->getOwnPropertySlot(this, exec, propertyName, slot);
}
// Fast call to get a property where we may not yet have converted the string to an
// identifier. The first time we perform a property access with a given string, try
// performing the property map lookup without forming an identifier. We detect this
// case by checking whether the hash has yet been set for this string.
ALWAYS_INLINE JSValue JSCell::fastGetOwnProperty(ExecState* exec, const String& name)
{
if (!structure()->typeInfo().overridesGetOwnPropertySlot() && !structure()->hasGetterSetterProperties()) {
PropertyOffset offset = name.impl()->hasHash()
? structure()->get(exec->globalData(), Identifier(exec, name))
: structure()->get(exec->globalData(), name);
if (offset != invalidOffset)
return asObject(this)->locationForOffset(offset)->get();
}
return JSValue();
}
// 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)
{
JSObject* object = this;
while (true) {
if (object->fastGetOwnPropertySlot(exec, propertyName, slot))
return true;
JSValue prototype = object->prototype();
if (!prototype.isObject())
return false;
object = asObject(prototype);
}
}
ALWAYS_INLINE bool JSObject::getPropertySlot(ExecState* exec, unsigned propertyName, PropertySlot& slot)
{
JSObject* object = this;
while (true) {
if (object->methodTable()->getOwnPropertySlotByIndex(object, exec, propertyName, slot))
return true;
JSValue prototype = object->prototype();
if (!prototype.isObject())
return false;
object = asObject(prototype);
}
}
inline JSValue JSObject::get(ExecState* exec, PropertyName propertyName) const
{
PropertySlot slot(this);
if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
return slot.getValue(exec, propertyName);
return jsUndefined();
}
inline JSValue JSObject::get(ExecState* exec, unsigned propertyName) const
{
PropertySlot slot(this);
if (const_cast<JSObject*>(this)->getPropertySlot(exec, propertyName, slot))
return slot.getValue(exec, propertyName);
return jsUndefined();
}
template<JSObject::PutMode mode>
inline bool JSObject::putDirectInternal(JSGlobalData& globalData, 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(propertyName.asIndex() == PropertyName::NotAnIndex);
if (structure()->isDictionary()) {
unsigned currentAttributes;
JSCell* currentSpecificFunction;
PropertyOffset offset = structure()->get(globalData, 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(globalData, propertyName);
if ((mode == PutModePut) && currentAttributes & ReadOnly)
return false;
putDirect(globalData, offset, value);
// 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;
}
if ((mode == PutModePut) && !isExtensible())
return false;
Butterfly* newButterfly = m_butterfly;
if (structure()->putWillGrowOutOfLineStorage())
newButterfly = growOutOfLineStorage(globalData, structure()->outOfLineCapacity(), structure()->suggestedNewOutOfLineStorageCapacity());
offset = structure()->addPropertyWithoutTransition(globalData, propertyName, attributes, specificFunction);
setButterfly(globalData, newButterfly, structure());
validateOffset(offset);
ASSERT(structure()->isValidOffset(offset));
putDirect(globalData, offset, value);
// See comment on setNewProperty call below.
if (!specificFunction)
slot.setNewProperty(this, offset);
if (attributes & ReadOnly)
structure()->setContainsReadOnlyProperties();
return true;
}
PropertyOffset offset;
size_t currentCapacity = structure()->outOfLineCapacity();
if (Structure* structure = Structure::addPropertyTransitionToExistingStructure(this->structure(), propertyName, attributes, specificFunction, offset)) {
Butterfly* newButterfly = m_butterfly;
if (currentCapacity != structure->outOfLineCapacity())
newButterfly = growOutOfLineStorage(globalData, currentCapacity, structure->outOfLineCapacity());
validateOffset(offset);
ASSERT(structure->isValidOffset(offset));
setButterfly(globalData, newButterfly, structure);
putDirect(globalData, offset, value);
// 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;
JSCell* currentSpecificFunction;
offset = structure()->get(globalData, propertyName, currentAttributes, currentSpecificFunction);
if (offset != invalidOffset) {
if ((mode == PutModePut) && currentAttributes & ReadOnly)
return false;
// 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(globalData, offset, value);
return true;
}
// case (2) Despecify, fall through to (3).
setStructure(globalData, Structure::despecifyFunctionTransition(globalData, structure(), propertyName));
}
// case (3) set the slot, do the put, return.
slot.setExistingProperty(this, offset);
putDirect(globalData, offset, value);
return true;
}
if ((mode == PutModePut) && !isExtensible())
return false;
Structure* structure = Structure::addPropertyTransition(globalData, this->structure(), propertyName, attributes, specificFunction, offset);
validateOffset(offset);
ASSERT(structure->isValidOffset(offset));
setStructureAndReallocateStorageIfNecessary(globalData, structure);
putDirect(globalData, offset, value);
// 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;
}
inline void JSObject::setStructureAndReallocateStorageIfNecessary(JSGlobalData& globalData, unsigned oldCapacity, Structure* newStructure)
{
ASSERT(oldCapacity <= newStructure->outOfLineCapacity());
if (oldCapacity == newStructure->outOfLineCapacity()) {
setStructure(globalData, newStructure);
return;
}
Butterfly* newButterfly = growOutOfLineStorage(
globalData, oldCapacity, newStructure->outOfLineCapacity());
setButterfly(globalData, newButterfly, newStructure);
}
inline void JSObject::setStructureAndReallocateStorageIfNecessary(JSGlobalData& globalData, Structure* newStructure)
{
setStructureAndReallocateStorageIfNecessary(
globalData, structure()->outOfLineCapacity(), newStructure);
}
inline bool JSObject::putOwnDataProperty(JSGlobalData& globalData, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
ASSERT(value);
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
ASSERT(!structure()->hasGetterSetterProperties());
return putDirectInternal<PutModePut>(globalData, propertyName, value, 0, slot, getCallableObject(value));
}
inline void JSObject::putDirect(JSGlobalData& globalData, PropertyName propertyName, JSValue value, unsigned attributes)
{
ASSERT(!value.isGetterSetter() && !(attributes & Accessor));
PutPropertySlot slot;
putDirectInternal<PutModeDefineOwnProperty>(globalData, propertyName, value, attributes, slot, getCallableObject(value));
}
inline void JSObject::putDirect(JSGlobalData& globalData, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
ASSERT(!value.isGetterSetter());
putDirectInternal<PutModeDefineOwnProperty>(globalData, propertyName, value, 0, slot, getCallableObject(value));
}
inline void JSObject::putDirectWithoutTransition(JSGlobalData& globalData, PropertyName propertyName, JSValue value, unsigned attributes)
{
ASSERT(!value.isGetterSetter() && !(attributes & Accessor));
Butterfly* newButterfly = m_butterfly;
if (structure()->putWillGrowOutOfLineStorage())
newButterfly = growOutOfLineStorage(globalData, structure()->outOfLineCapacity(), structure()->suggestedNewOutOfLineStorageCapacity());
PropertyOffset offset = structure()->addPropertyWithoutTransition(globalData, propertyName, attributes, getCallableObject(value));
setButterfly(globalData, newButterfly, structure());
putDirect(globalData, offset, value);
}
inline JSValue JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
{
return methodTable()->defaultValue(this, exec, preferredType);
}
inline JSValue JSValue::get(ExecState* exec, PropertyName propertyName) const
{
PropertySlot slot(asValue());
return get(exec, propertyName, slot);
}
inline JSValue JSValue::get(ExecState* exec, PropertyName propertyName, PropertySlot& slot) const
{
if (UNLIKELY(!isCell())) {
JSObject* prototype = synthesizePrototype(exec);
if (!prototype->getPropertySlot(exec, propertyName, slot))
return jsUndefined();
return slot.getValue(exec, propertyName);
}
JSCell* cell = asCell();
while (true) {
if (cell->fastGetOwnPropertySlot(exec, propertyName, slot))
return slot.getValue(exec, propertyName);
JSValue prototype = asObject(cell)->prototype();
if (!prototype.isObject())
return jsUndefined();
cell = asObject(prototype);
}
}
inline JSValue JSValue::get(ExecState* exec, unsigned propertyName) const
{
PropertySlot slot(asValue());
return get(exec, propertyName, slot);
}
inline JSValue JSValue::get(ExecState* exec, unsigned propertyName, PropertySlot& slot) const
{
if (UNLIKELY(!isCell())) {
JSObject* prototype = synthesizePrototype(exec);
if (!prototype->getPropertySlot(exec, propertyName, slot))
return jsUndefined();
return slot.getValue(exec, propertyName);
}
JSCell* cell = const_cast<JSCell*>(asCell());
while (true) {
if (cell->methodTable()->getOwnPropertySlotByIndex(cell, exec, propertyName, slot))
return slot.getValue(exec, propertyName);
JSValue prototype = asObject(cell)->prototype();
if (!prototype.isObject())
return jsUndefined();
cell = prototype.asCell();
}
}
inline void JSValue::put(ExecState* exec, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
{
if (UNLIKELY(!isCell())) {
putToPrimitive(exec, propertyName, value, slot);
return;
}
asCell()->methodTable()->put(asCell(), exec, propertyName, value, slot);
}
inline void JSValue::putByIndex(ExecState* exec, unsigned propertyName, JSValue value, bool shouldThrow)
{
if (UNLIKELY(!isCell())) {
putToPrimitiveByIndex(exec, propertyName, value, shouldThrow);
return;
}
asCell()->methodTable()->putByIndex(asCell(), exec, propertyName, value, shouldThrow);
}
ALWAYS_INLINE JSObject* Register::function() const
{
if (!jsValue())
return 0;
return asObject(jsValue());
}
ALWAYS_INLINE Register Register::withCallee(JSObject* callee)
{
Register r;
r = JSValue(callee);
return r;
}
inline size_t offsetInButterfly(PropertyOffset offset)
{
return offsetInOutOfLineStorage(offset) + Butterfly::indexOfPropertyStorage();
}
// This is a helper 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.
// For out-of-line offsets: the base of the out-of-line storage.
inline size_t offsetRelativeToPatchedStorage(PropertyOffset offset)
{
if (isOutOfLineOffset(offset))
return sizeof(EncodedJSValue) * offsetInButterfly(offset);
return JSObject::offsetOfInlineStorage() - JSObject::butterflyOffset() + sizeof(EncodedJSValue) * offsetInInlineStorage(offset);
}
inline int indexRelativeToBase(PropertyOffset offset)
{
if (isOutOfLineOffset(offset))
return offsetInOutOfLineStorage(offset) + Butterfly::indexOfPropertyStorage();
ASSERT(!(JSObject::offsetOfInlineStorage() % sizeof(EncodedJSValue)));
return JSObject::offsetOfInlineStorage() / sizeof(EncodedJSValue) + offsetInInlineStorage(offset);
}
inline int offsetRelativeToBase(PropertyOffset offset)
{
if (isOutOfLineOffset(offset))
return offsetInOutOfLineStorage(offset) * sizeof(EncodedJSValue) + Butterfly::offsetOfPropertyStorage();
return JSObject::offsetOfInlineStorage() + offsetInInlineStorage(offset) * sizeof(EncodedJSValue);
}
COMPILE_ASSERT(!(sizeof(JSObject) % sizeof(WriteBarrierBase<Unknown>)), JSObject_inline_storage_has_correct_alignment);
} // namespace JSC
#endif // JSObject_h