Changeset 49331 in webkit for trunk/JavaScriptCore/runtime/JSObject.cpp

Timestamp:

Oct 8, 2009, 4:24:55 PM (16 years ago)

Author:

[email protected]

Message:

Migrated some code that didn't belong out of Structure.

Patch by Geoffrey Garen <​[email protected]> on 2009-10-08
Reviewed by Sam Weinig.

SunSpider says maybe 1.03x faster.

• runtime/JSCell.h: Nixed Structure::markAggregate, and made marking of

a Structure's prototype the direct responsility of the object using it.
(Giving Structure a mark function was misleading because it implied that
all live structures get marked during GC, when they don't.)

• runtime/JSGlobalObject.cpp:

(JSC::markIfNeeded):
(JSC::JSGlobalObject::markChildren): Added code to mark prototypes stored
on the global object. Maybe this wasn't necessary, but now we don't have
to wonder.

• runtime/JSObject.cpp:

(JSC::JSObject::getPropertyNames):
(JSC::JSObject::getOwnPropertyNames):
(JSC::JSObject::getEnumerableNamesFromClassInfoTable):

• runtime/JSObject.h:

(JSC::JSObject::markChildrenDirect):

• runtime/PropertyNameArray.h:
• runtime/Structure.cpp:
• runtime/Structure.h:

(JSC::Structure::setEnumerationCache):
(JSC::Structure::enumerationCache): Moved property name gathering code
from Structure to JSObject because having a Structure iterate its JSObject
was a layering violation. A JSObject is implemented using a Structure; not
the other way around.

File:

• trunk/JavaScriptCore/runtime/JSObject.cpp (modified) (2 diffs)

trunk/JavaScriptCore/runtime/JSObject.cpp

@@ -43 +43 @@
 ASSERT_CLASS_FITS_IN_CELL(JSObject);
 
+static inline void getEnumerablePropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames)
+{
+    // Add properties from the static hashtables of properties
+    for (; classInfo; classInfo = classInfo->parentClass) {
+        const HashTable* table = classInfo->propHashTable(exec);
+        if (!table)
+            continue;
+        table->initializeIfNeeded(exec);
+        ASSERT(table->table);
+
+        int hashSizeMask = table->compactSize - 1;
+        const HashEntry* entry = table->table;
+        for (int i = 0; i <= hashSizeMask; ++i, ++entry) {
+            if (entry->key() && !(entry->attributes() & DontEnum))
+                propertyNames.add(entry->key());
+        }
+    }
+}
+
 void JSObject::markChildren(MarkStack& markStack)
 {
@@ -425 +444 @@
 void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
 {
-    m_structure->getEnumerablePropertyNames(exec, propertyNames, this);
+    bool shouldCache = propertyNames.shouldCache() && !(propertyNames.size() || m_structure->isDictionary());
+
+    if (shouldCache) {
+        if (PropertyNameArrayData* data = m_structure->enumerationCache()) {
+            if (data->cachedPrototypeChain() == m_structure->prototypeChain(exec)) {
+                propertyNames.setData(data);
+                return;
+            }
+
+            m_structure->clearEnumerationCache();
+        }
+    }
+
+    getOwnPropertyNames(exec, propertyNames);
+
+    if (prototype().isObject()) {
+        propertyNames.setShouldCache(false); // No need for our prototypes to waste memory on caching, since they're not being enumerated directly.
+        JSObject* prototype = asObject(this->prototype());
+        while(1) {
+            if (!prototype->structure()->typeInfo().hasDefaultGetPropertyNames()) {
+                prototype->getPropertyNames(exec, propertyNames);
+                break;
+            }
+            prototype->getOwnPropertyNames(exec, propertyNames);
+            JSValue nextProto = prototype->prototype();
+            if (!nextProto.isObject())
+                break;
+            prototype = asObject(nextProto);
+        }
+    }
+
+    if (shouldCache) {
+        StructureChain* protoChain = m_structure->prototypeChain(exec);
+        if (!protoChain->isCacheable())
+            return;
+        RefPtr<PropertyNameArrayData> data = propertyNames.data();
+        data->setCachedPrototypeChain(protoChain);
+        data->setCachedStructure(m_structure);
+        m_structure->setEnumerationCache(data.release());
+    }
 }
 
 void JSObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
 {
-    m_structure->getOwnEnumerablePropertyNames(exec, propertyNames, this);
+    m_structure->getEnumerablePropertyNames(propertyNames);
+    getEnumerablePropertyNames(exec, classInfo(), propertyNames);
 }