StructureInlines.h [plain text]
#ifndef StructureInlines_h
#define StructureInlines_h
#include "JSArrayBufferView.h"
#include "PropertyMapHashTable.h"
#include "Structure.h"
namespace JSC {
inline Structure* Structure::create(VM& vm, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo, IndexingType indexingType, unsigned inlineCapacity)
{
ASSERT(vm.structureStructure);
ASSERT(classInfo);
Structure* structure = new (NotNull, allocateCell<Structure>(vm.heap)) Structure(vm, globalObject, prototype, typeInfo, classInfo, indexingType, inlineCapacity);
structure->finishCreation(vm);
return structure;
}
inline Structure* Structure::createStructure(VM& vm)
{
ASSERT(!vm.structureStructure);
Structure* structure = new (NotNull, allocateCell<Structure>(vm.heap)) Structure(vm);
structure->finishCreation(vm, CreatingEarlyCell);
return structure;
}
inline Structure* Structure::create(VM& vm, Structure* structure)
{
ASSERT(vm.structureStructure);
Structure* newStructure = new (NotNull, allocateCell<Structure>(vm.heap)) Structure(vm, structure);
newStructure->finishCreation(vm);
return newStructure;
}
inline JSObject* Structure::storedPrototypeObject() const
{
JSValue value = m_prototype.get();
if (value.isNull())
return 0;
return asObject(value);
}
inline Structure* Structure::storedPrototypeStructure() const
{
JSObject* object = storedPrototypeObject();
if (!object)
return 0;
return object->structure();
}
ALWAYS_INLINE PropertyOffset Structure::get(VM& vm, PropertyName propertyName)
{
ASSERT(!isCompilationThread());
ASSERT(structure()->classInfo() == info());
PropertyTable* propertyTable;
materializePropertyMapIfNecessary(vm, propertyTable);
if (!propertyTable)
return invalidOffset;
PropertyMapEntry* entry = propertyTable->get(propertyName.uid());
return entry ? entry->offset : invalidOffset;
}
ALWAYS_INLINE PropertyOffset Structure::get(VM& vm, const WTF::String& name)
{
ASSERT(!isCompilationThread());
ASSERT(structure()->classInfo() == info());
PropertyTable* propertyTable;
materializePropertyMapIfNecessary(vm, propertyTable);
if (!propertyTable)
return invalidOffset;
PropertyMapEntry* entry = propertyTable->findWithString(name.impl()).first;
return entry ? entry->offset : invalidOffset;
}
ALWAYS_INLINE PropertyOffset Structure::get(VM& vm, PropertyName propertyName, unsigned& attributes, JSCell*& specificValue)
{
ASSERT(!isCompilationThread());
ASSERT(structure()->classInfo() == info());
PropertyTable* propertyTable;
materializePropertyMapIfNecessary(vm, propertyTable);
if (!propertyTable)
return invalidOffset;
PropertyMapEntry* entry = propertyTable->get(propertyName.uid());
if (!entry)
return invalidOffset;
attributes = entry->attributes;
specificValue = entry->specificValue.get();
return entry->offset;
}
inline PropertyOffset Structure::getConcurrently(VM& vm, StringImpl* uid)
{
unsigned attributesIgnored;
JSCell* specificValueIgnored;
return getConcurrently(
vm, uid, attributesIgnored, specificValueIgnored);
}
inline bool Structure::hasIndexingHeader(const JSCell* cell) const
{
if (hasIndexedProperties(indexingType()))
return true;
if (!isTypedView(m_classInfo->typedArrayStorageType))
return false;
return jsCast<const JSArrayBufferView*>(cell)->mode() == WastefulTypedArray;
}
inline bool Structure::masqueradesAsUndefined(JSGlobalObject* lexicalGlobalObject)
{
return typeInfo().masqueradesAsUndefined() && globalObject() == lexicalGlobalObject;
}
inline bool Structure::transitivelyTransitionedFrom(Structure* structureToFind)
{
for (Structure* current = this; current; current = current->previousID()) {
if (current == structureToFind)
return true;
}
return false;
}
inline void Structure::setEnumerationCache(VM& vm, JSPropertyNameIterator* enumerationCache)
{
ASSERT(!isDictionary());
if (!m_hasRareData)
allocateRareData(vm);
rareData()->setEnumerationCache(vm, enumerationCache);
}
inline JSPropertyNameIterator* Structure::enumerationCache()
{
if (!m_hasRareData)
return 0;
return rareData()->enumerationCache();
}
inline JSValue Structure::prototypeForLookup(JSGlobalObject* globalObject) const
{
if (isObject())
return m_prototype.get();
ASSERT(typeInfo().type() == StringType);
return globalObject->stringPrototype();
}
inline JSValue Structure::prototypeForLookup(ExecState* exec) const
{
return prototypeForLookup(exec->lexicalGlobalObject());
}
inline StructureChain* Structure::prototypeChain(VM& vm, JSGlobalObject* globalObject) const
{
if (!isValid(globalObject, m_cachedPrototypeChain.get())) {
JSValue prototype = prototypeForLookup(globalObject);
m_cachedPrototypeChain.set(vm, this, StructureChain::create(vm, prototype.isNull() ? 0 : asObject(prototype)->structure()));
}
return m_cachedPrototypeChain.get();
}
inline StructureChain* Structure::prototypeChain(ExecState* exec) const
{
return prototypeChain(exec->vm(), exec->lexicalGlobalObject());
}
inline bool Structure::isValid(JSGlobalObject* globalObject, StructureChain* cachedPrototypeChain) const
{
if (!cachedPrototypeChain)
return false;
JSValue prototype = prototypeForLookup(globalObject);
WriteBarrier<Structure>* cachedStructure = cachedPrototypeChain->head();
while (*cachedStructure && !prototype.isNull()) {
if (asObject(prototype)->structure() != cachedStructure->get())
return false;
++cachedStructure;
prototype = asObject(prototype)->prototype();
}
return prototype.isNull() && !*cachedStructure;
}
inline bool Structure::isValid(ExecState* exec, StructureChain* cachedPrototypeChain) const
{
return isValid(exec->lexicalGlobalObject(), cachedPrototypeChain);
}
inline bool Structure::putWillGrowOutOfLineStorage()
{
checkOffsetConsistency();
ASSERT(outOfLineCapacity() >= outOfLineSize());
if (!propertyTable()) {
unsigned currentSize = numberOfOutOfLineSlotsForLastOffset(m_offset);
ASSERT(outOfLineCapacity() >= currentSize);
return currentSize == outOfLineCapacity();
}
ASSERT(totalStorageCapacity() >= propertyTable()->propertyStorageSize());
if (propertyTable()->hasDeletedOffset())
return false;
ASSERT(totalStorageCapacity() >= propertyTable()->size());
return propertyTable()->size() == totalStorageCapacity();
}
ALWAYS_INLINE WriteBarrier<PropertyTable>& Structure::propertyTable()
{
ASSERT(!globalObject() || !globalObject()->vm().heap.isCollecting());
return m_propertyTableUnsafe;
}
ALWAYS_INLINE bool Structure::checkOffsetConsistency() const
{
PropertyTable* propertyTable = m_propertyTableUnsafe.get();
if (!propertyTable) {
ASSERT(!m_isPinnedPropertyTable);
return true;
}
if (isCompilationThread())
return true;
RELEASE_ASSERT(numberOfSlotsForLastOffset(m_offset, m_inlineCapacity) == propertyTable->propertyStorageSize());
unsigned totalSize = propertyTable->propertyStorageSize();
RELEASE_ASSERT((totalSize < inlineCapacity() ? 0 : totalSize - inlineCapacity()) == numberOfOutOfLineSlotsForLastOffset(m_offset));
return true;
}
inline size_t nextOutOfLineStorageCapacity(size_t currentCapacity)
{
if (!currentCapacity)
return initialOutOfLineCapacity;
return currentCapacity * outOfLineGrowthFactor;
}
inline size_t Structure::suggestedNewOutOfLineStorageCapacity()
{
return nextOutOfLineStorageCapacity(outOfLineCapacity());
}
}
#endif // StructureInlines_h