#ifndef JSCell_h
#define JSCell_h
-#include "Collector.h"
-#include "JSImmediate.h"
-#include "JSValue.h"
-#include "MarkStack.h"
-#include "Structure.h"
+#include "CallData.h"
+#include "ConstructData.h"
+#include "Heap.h"
+#include "JSLock.h"
+#include "SlotVisitor.h"
+#include "TypedArrayDescriptor.h"
+#include "WriteBarrier.h"
#include <wtf/Noncopyable.h>
+#include <wtf/TypeTraits.h>
namespace JSC {
- class JSCell : public NoncopyableCustomAllocated {
- friend class GetterSetter;
- friend class Heap;
- friend class JIT;
- friend class JSNumberCell;
- friend class JSObject;
- friend class JSPropertyNameIterator;
- friend class JSString;
- friend class JSValue;
- friend class JSAPIValueWrapper;
- friend class JSZombie;
- friend class JSGlobalData;
-
- private:
- explicit JSCell(Structure*);
- virtual ~JSCell();
-
- public:
- static PassRefPtr<Structure> createDummyStructure()
- {
- return Structure::create(jsNull(), TypeInfo(UnspecifiedType), AnonymousSlotCount);
- }
-
- // Querying the type.
-#if USE(JSVALUE32)
- bool isNumber() const;
-#endif
- bool isString() const;
- bool isObject() const;
- virtual bool isGetterSetter() const;
- bool inherits(const ClassInfo*) const;
- virtual bool isAPIValueWrapper() const { return false; }
- virtual bool isPropertyNameIterator() const { return false; }
-
- Structure* structure() const;
-
- // Extracting the value.
- bool getString(ExecState* exec, UString&) const;
- UString getString(ExecState* exec) const; // null string if not a string
- JSObject* getObject(); // NULL if not an object
- const JSObject* getObject() const; // NULL if not an object
+class CopyVisitor;
+class ExecState;
+class JSDestructibleObject;
+class JSGlobalObject;
+class LLIntOffsetsExtractor;
+class PropertyDescriptor;
+class PropertyNameArray;
+class Structure;
+
+enum EnumerationMode {
+ ExcludeDontEnumProperties,
+ IncludeDontEnumProperties
+};
+
+class JSCell {
+ friend class JSValue;
+ friend class MarkedBlock;
+ template<typename T> friend void* allocateCell(Heap&);
+ template<typename T> friend void* allocateCell(Heap&, size_t);
+
+public:
+ static const unsigned StructureFlags = 0;
+
+ static const bool needsDestruction = false;
+ static const bool hasImmortalStructure = false;
+
+ enum CreatingEarlyCellTag { CreatingEarlyCell };
+ JSCell(CreatingEarlyCellTag);
+
+protected:
+ JSCell(VM&, Structure*);
+ JS_EXPORT_PRIVATE static void destroy(JSCell*);
+
+public:
+ // Querying the type.
+ bool isString() const;
+ bool isObject() const;
+ bool isGetterSetter() const;
+ bool isProxy() const;
+ bool inherits(const ClassInfo*) const;
+ bool isAPIValueWrapper() const;
+
+ Structure* structure() const;
+ void setStructure(VM&, Structure*);
+ void clearStructure() { m_structure.clear(); }
+
+ const char* className();
+
+ // Extracting the value.
+ JS_EXPORT_PRIVATE bool getString(ExecState*, String&) const;
+ JS_EXPORT_PRIVATE String getString(ExecState*) const; // null string if not a string
+ JS_EXPORT_PRIVATE JSObject* getObject(); // NULL if not an object
+ const JSObject* getObject() const; // NULL if not an object
- virtual CallType getCallData(CallData&);
- virtual ConstructType getConstructData(ConstructData&);
-
- // Extracting integer values.
- // FIXME: remove these methods, can check isNumberCell in JSValue && then call asNumberCell::*.
- virtual bool getUInt32(uint32_t&) const;
-
- // Basic conversions.
- virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
- virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
- virtual bool toBoolean(ExecState*) const;
- virtual double toNumber(ExecState*) const;
- virtual UString toString(ExecState*) const;
- virtual JSObject* toObject(ExecState*) const;
-
- // Garbage collection.
- void* operator new(size_t, ExecState*);
- void* operator new(size_t, JSGlobalData*);
- void* operator new(size_t, void* placementNewDestination) { return placementNewDestination; }
-
- virtual void markChildren(MarkStack&);
-#if ENABLE(JSC_ZOMBIES)
- virtual bool isZombie() const { return false; }
-#endif
-
- // Object operations, with the toObject operation included.
- virtual const ClassInfo* classInfo() const;
- virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
- virtual void put(ExecState*, unsigned propertyName, JSValue);
- virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
- virtual bool deleteProperty(ExecState*, unsigned propertyName);
-
- virtual JSObject* toThisObject(ExecState*) const;
- virtual JSValue getJSNumber();
- void* vptr() { return *reinterpret_cast<void**>(this); }
- void setVPtr(void* vptr) { *reinterpret_cast<void**>(this) = vptr; }
-
- // FIXME: Rename getOwnPropertySlot to virtualGetOwnPropertySlot, and
- // fastGetOwnPropertySlot to getOwnPropertySlot. Callers should always
- // call this function, not its slower virtual counterpart. (For integer
- // property names, we want a similar interface with appropriate optimizations.)
- bool fastGetOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
-
- protected:
- static const unsigned AnonymousSlotCount = 0;
-
- private:
- // Base implementation; for non-object classes implements getPropertySlot.
- virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
- virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
+ JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
+ JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
+
+ // Basic conversions.
+ JS_EXPORT_PRIVATE JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
+ bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
+ bool toBoolean(ExecState*) const;
+ TriState pureToBoolean() const;
+ JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
+ JS_EXPORT_PRIVATE JSObject* toObject(ExecState*, JSGlobalObject*) const;
+
+ static void visitChildren(JSCell*, SlotVisitor&);
+ JS_EXPORT_PRIVATE static void copyBackingStore(JSCell*, CopyVisitor&);
+
+ // Object operations, with the toObject operation included.
+ const ClassInfo* classInfo() const;
+ const MethodTable* methodTable() const;
+ const MethodTable* methodTableForDestruction() const;
+ static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
+ static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue, bool shouldThrow);
- Structure* m_structure;
- };
-
- inline JSCell::JSCell(Structure* structure)
- : m_structure(structure)
- {
- }
-
- inline JSCell::~JSCell()
- {
- }
-
-#if USE(JSVALUE32)
- inline bool JSCell::isNumber() const
- {
- return m_structure->typeInfo().type() == NumberType;
- }
-#endif
-
- inline bool JSCell::isObject() const
- {
- return m_structure->typeInfo().type() == ObjectType;
- }
-
- inline bool JSCell::isString() const
- {
- return m_structure->typeInfo().type() == StringType;
- }
-
- inline Structure* JSCell::structure() const
- {
- return m_structure;
- }
-
- inline void JSCell::markChildren(MarkStack&)
- {
- }
-
- inline void* JSCell::operator new(size_t size, JSGlobalData* globalData)
- {
- return globalData->heap.allocate(size);
- }
-
- inline void* JSCell::operator new(size_t size, ExecState* exec)
- {
- return exec->heap()->allocate(size);
- }
-
- // --- JSValue inlines ----------------------------
-
- inline bool JSValue::isString() const
- {
- return isCell() && asCell()->isString();
- }
-
- inline bool JSValue::isGetterSetter() const
- {
- return isCell() && asCell()->isGetterSetter();
- }
-
- inline bool JSValue::isObject() const
- {
- return isCell() && asCell()->isObject();
- }
-
- inline bool JSValue::getString(ExecState* exec, UString& s) const
- {
- return isCell() && asCell()->getString(exec, s);
- }
-
- inline UString JSValue::getString(ExecState* exec) const
- {
- return isCell() ? asCell()->getString(exec) : UString();
- }
-
- inline JSObject* JSValue::getObject() const
- {
- return isCell() ? asCell()->getObject() : 0;
- }
-
- inline CallType JSValue::getCallData(CallData& callData)
- {
- return isCell() ? asCell()->getCallData(callData) : CallTypeNone;
- }
-
- inline ConstructType JSValue::getConstructData(ConstructData& constructData)
- {
- return isCell() ? asCell()->getConstructData(constructData) : ConstructTypeNone;
- }
+ static bool deleteProperty(JSCell*, ExecState*, PropertyName);
+ static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
- ALWAYS_INLINE bool JSValue::getUInt32(uint32_t& v) const
- {
- if (isInt32()) {
- int32_t i = asInt32();
- v = static_cast<uint32_t>(i);
- return i >= 0;
- }
- if (isDouble()) {
- double d = asDouble();
- v = static_cast<uint32_t>(d);
- return v == d;
- }
- return false;
- }
-
-#if !USE(JSVALUE32_64)
- ALWAYS_INLINE JSCell* JSValue::asCell() const
- {
- ASSERT(isCell());
- return m_ptr;
- }
-#endif // !USE(JSVALUE32_64)
-
- inline JSValue JSValue::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
- {
- return isCell() ? asCell()->toPrimitive(exec, preferredType) : asValue();
- }
+ static JSObject* toThisObject(JSCell*, ExecState*);
- inline bool JSValue::getPrimitiveNumber(ExecState* exec, double& number, JSValue& value)
- {
- if (isInt32()) {
- number = asInt32();
- value = *this;
- return true;
- }
- if (isDouble()) {
- number = asDouble();
- value = *this;
- return true;
- }
- if (isCell())
- return asCell()->getPrimitiveNumber(exec, number, value);
- if (isTrue()) {
- number = 1.0;
- value = *this;
- return true;
- }
- if (isFalse() || isNull()) {
- number = 0.0;
- value = *this;
- return true;
- }
- ASSERT(isUndefined());
- number = nonInlineNaN();
- value = *this;
- return true;
- }
+ void zap() { *reinterpret_cast<uintptr_t**>(this) = 0; }
+ bool isZapped() const { return !*reinterpret_cast<uintptr_t* const*>(this); }
- inline bool JSValue::toBoolean(ExecState* exec) const
- {
- if (isInt32())
- return asInt32() != 0;
- if (isDouble())
- return asDouble() > 0.0 || asDouble() < 0.0; // false for NaN
- if (isCell())
- return asCell()->toBoolean(exec);
- return isTrue(); // false, null, and undefined all convert to false.
- }
+ // FIXME: Rename getOwnPropertySlot to virtualGetOwnPropertySlot, and
+ // fastGetOwnPropertySlot to getOwnPropertySlot. Callers should always
+ // call this function, not its slower virtual counterpart. (For integer
+ // property names, we want a similar interface with appropriate optimizations.)
+ bool fastGetOwnPropertySlot(ExecState*, PropertyName, PropertySlot&);
+ JSValue fastGetOwnProperty(ExecState*, const String&);
- ALWAYS_INLINE double JSValue::toNumber(ExecState* exec) const
+ static ptrdiff_t structureOffset()
{
- if (isInt32())
- return asInt32();
- if (isDouble())
- return asDouble();
- if (isCell())
- return asCell()->toNumber(exec);
- if (isTrue())
- return 1.0;
- return isUndefined() ? nonInlineNaN() : 0; // null and false both convert to 0.
+ return OBJECT_OFFSETOF(JSCell, m_structure);
}
- inline bool JSValue::needsThisConversion() const
+ void* structureAddress()
{
- if (UNLIKELY(!isCell()))
- return true;
- return asCell()->structure()->typeInfo().needsThisConversion();
- }
-
- inline JSValue JSValue::getJSNumber()
- {
- if (isInt32() || isDouble())
- return *this;
- if (isCell())
- return asCell()->getJSNumber();
- return JSValue();
- }
-
- inline JSObject* JSValue::toObject(ExecState* exec) const
- {
- return isCell() ? asCell()->toObject(exec) : toObjectSlowCase(exec);
- }
-
- inline JSObject* JSValue::toThisObject(ExecState* exec) const
- {
- return isCell() ? asCell()->toThisObject(exec) : toThisObjectSlowCase(exec);
- }
-
- ALWAYS_INLINE void MarkStack::append(JSCell* cell)
- {
- ASSERT(!m_isCheckingForDefaultMarkViolation);
- ASSERT(cell);
- if (Heap::isCellMarked(cell))
- return;
- Heap::markCell(cell);
- if (cell->structure()->typeInfo().type() >= CompoundType)
- m_values.append(cell);
- }
-
- ALWAYS_INLINE void MarkStack::append(JSValue value)
- {
- ASSERT(value);
- if (value.isCell())
- append(value.asCell());
- }
-
- inline Heap* Heap::heap(JSValue v)
- {
- if (!v.isCell())
- return 0;
- return heap(v.asCell());
- }
-
- inline Heap* Heap::heap(JSCell* c)
- {
- return cellBlock(c)->heap;
- }
-
-#if ENABLE(JSC_ZOMBIES)
- inline bool JSValue::isZombie() const
- {
- return isCell() && asCell() && asCell()->isZombie();
+ return &m_structure;
}
+
+#if ENABLE(GC_VALIDATION)
+ Structure* unvalidatedStructure() { return m_structure.unvalidatedGet(); }
#endif
+
+ static const TypedArrayType TypedArrayStorageType = TypedArrayNone;
+protected:
+
+ void finishCreation(VM&);
+ void finishCreation(VM&, Structure*, CreatingEarlyCellTag);
+
+ // Base implementation; for non-object classes implements getPropertySlot.
+ static bool getOwnPropertySlot(JSCell*, ExecState*, PropertyName, PropertySlot&);
+ static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
+
+ // Dummy implementations of override-able static functions for classes to put in their MethodTable
+ static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
+ static NO_RETURN_DUE_TO_CRASH void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+ static NO_RETURN_DUE_TO_CRASH void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+ static NO_RETURN_DUE_TO_CRASH void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+ static String className(const JSObject*);
+ JS_EXPORT_PRIVATE static bool customHasInstance(JSObject*, ExecState*, JSValue);
+ static NO_RETURN_DUE_TO_CRASH void putDirectVirtual(JSObject*, ExecState*, PropertyName, JSValue, unsigned attributes);
+ static bool defineOwnProperty(JSObject*, ExecState*, PropertyName, PropertyDescriptor&, bool shouldThrow);
+ static bool getOwnPropertyDescriptor(JSObject*, ExecState*, PropertyName, PropertyDescriptor&);
+
+private:
+ friend class LLIntOffsetsExtractor;
+
+ WriteBarrier<Structure> m_structure;
+};
+
+template<typename To, typename From>
+inline To jsCast(From* from)
+{
+ ASSERT(!from || from->JSCell::inherits(&WTF::RemovePointer<To>::Type::s_info));
+ return static_cast<To>(from);
+}
+
+template<typename To>
+inline To jsCast(JSValue from)
+{
+ ASSERT(from.isCell() && from.asCell()->JSCell::inherits(&WTF::RemovePointer<To>::Type::s_info));
+ return static_cast<To>(from.asCell());
+}
+
+template<typename To, typename From>
+inline To jsDynamicCast(From* from)
+{
+ return from->inherits(&WTF::RemovePointer<To>::Type::s_info) ? static_cast<To>(from) : 0;
+}
+
+template<typename To>
+inline To jsDynamicCast(JSValue from)
+{
+ return from.isCell() && from.asCell()->inherits(&WTF::RemovePointer<To>::Type::s_info) ? static_cast<To>(from.asCell()) : 0;
+}
+
} // namespace JSC
#endif // JSCell_h
projects / apple / javascriptcore.git / blobdiff