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

Timestamp:

Oct 8, 2009, 3:02:53 PM (16 years ago)

Author:

[email protected]

Message:

Take one branch instead of two to test for JSValue().

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

1.1% SunSpider speedup.

• jit/JITCall.cpp:

(JSC::JIT::compileOpCall):

• jit/JITOpcodes.cpp:

(JSC::JIT::emit_op_to_jsnumber):
(JSC::JIT::emit_op_create_arguments):

• jit/JITPropertyAccess.cpp:

(JSC::JIT::emitSlow_op_get_by_val):
(JSC::JIT::emit_op_put_by_val): Test for the empty value tag, instead
of testing for the cell tag with a 0 payload.

• runtime/JSValue.cpp:

(JSC::JSValue::description): Added support for dumping the new empty value,
and deleted values, in debug builds.

• runtime/JSValue.h:

(JSC::JSValue::JSValue()): Construct JSValue() with the empty value tag.

(JSC::JSValue::JSValue(JSCell*)): Convert null pointer to the empty value
tag, to avoid having two different c++ versions of null / empty.

(JSC::JSValue::operator bool): Test for the empty value tag, instead
of testing for the cell tag with a 0 payload.

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);
 }