Changeset 49328 in webkit for trunk/JavaScriptCore

Timestamp:

Oct 8, 2009, 3:25:14 PM (16 years ago)

Author:

[email protected]

Message:

Rolled out r49322 and friends because they killed the build

Location:

trunk/JavaScriptCore

Files:

• ChangeLog (modified) (1 diff)
• runtime/JSCell.h (modified) (1 diff)
• runtime/JSGlobalData.h (modified) (1 diff)
• runtime/JSGlobalObject.cpp (modified) (2 diffs)
• runtime/JSObject.cpp (modified) (2 diffs)
• runtime/JSObject.h (modified) (1 diff)
• runtime/PropertyNameArray.h (modified) (1 diff)
• runtime/Structure.cpp (modified) (3 diffs)
• runtime/Structure.h (modified) (6 diffs)

trunk/JavaScriptCore/ChangeLog

@@ -1 @@
-2009-10-08  Geoffrey Garen  <[email protected]>
-
-        Windows build fix: Added missing #include.
-        
-        * runtime/JSGlobalData.h:
-
-2009-10-01  Geoffrey Garen  <[email protected]>
-
-        Reviewed by Sam Weinig.
-
-        Take one branch instead of two to test for JSValue().
-        
-        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.
-
-2009-10-08  Geoffrey Garen  <[email protected]>
-
-        Reviewed by Sam Weinig.
-
-        Migrated some code that didn't belong out of Structure.
-        
-        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.
-
 2009-10-08  Zoltan Herczeg  <[email protected]>
 

trunk/JavaScriptCore/runtime/JSCell.h

@@ -343 +343 @@
     }
 
+    inline void Structure::markAggregate(MarkStack& markStack)
+    {
+        markStack.append(m_prototype);
+    }
+
     inline Heap* Heap::heap(JSValue v)
     {

trunk/JavaScriptCore/runtime/JSGlobalData.h

@@ -37 +37 @@
 #include "NumericStrings.h"
 #include "SmallStrings.h"
-#include "Structure.h"
 #include "TimeoutChecker.h"
 #include <wtf/Forward.h>

trunk/JavaScriptCore/runtime/JSGlobalObject.cpp

@@ -90 +90 @@
 {
     if (s)
-        markIfNeeded(markStack, s->storedPrototype());
+        s->markAggregate(markStack);
 }
 
@@ -395 +395 @@
 
     markIfNeeded(markStack, d()->errorStructure);
-    markIfNeeded(markStack, d()->argumentsStructure);
-    markIfNeeded(markStack, d()->arrayStructure);
-    markIfNeeded(markStack, d()->booleanObjectStructure);
-    markIfNeeded(markStack, d()->callbackConstructorStructure);
-    markIfNeeded(markStack, d()->callbackFunctionStructure);
-    markIfNeeded(markStack, d()->callbackObjectStructure);
-    markIfNeeded(markStack, d()->dateStructure);
-    markIfNeeded(markStack, d()->emptyObjectStructure);
-    markIfNeeded(markStack, d()->errorStructure);
-    markIfNeeded(markStack, d()->functionStructure);
-    markIfNeeded(markStack, d()->numberObjectStructure);
-    markIfNeeded(markStack, d()->prototypeFunctionStructure);
-    markIfNeeded(markStack, d()->regExpMatchesArrayStructure);
-    markIfNeeded(markStack, d()->regExpStructure);
-    markIfNeeded(markStack, d()->stringObjectStructure);
 
     // No need to mark the other structures, because their prototypes are all

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)
 {
@@ -444 +425 @@
 void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
 {
-    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());
-    }
+    m_structure->getEnumerablePropertyNames(exec, propertyNames, this);
 }
 
 void JSObject::getOwnPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
 {
-    m_structure->getEnumerablePropertyNames(propertyNames);
-    getEnumerablePropertyNames(exec, classInfo(), propertyNames);
+    m_structure->getOwnEnumerablePropertyNames(exec, propertyNames, this);
 }
 

trunk/JavaScriptCore/runtime/JSObject.h

@@ -683 +683 @@
     JSCell::markChildren(markStack);
 
-    markStack.append(prototype());
+    m_structure->markAggregate(markStack);
     
     PropertyStorage storage = propertyStorage();

trunk/JavaScriptCore/runtime/PropertyNameArray.h

@@ -24 +24 @@
 #include "CallFrame.h"
 #include "Identifier.h"
-#include "StructureChain.h"
+#include "Structure.h"
 #include <wtf/HashSet.h>
 #include <wtf/Vector.h>
 
 namespace JSC {
-    
-    class Structure;
 
     class PropertyNameArrayData : public RefCounted<PropertyNameArrayData> {

trunk/JavaScriptCore/runtime/Structure.cpp

@@ -283 +283 @@
 }
 
+void Structure::getOwnEnumerablePropertyNames(ExecState* exec, PropertyNameArray& propertyNames, JSObject* baseObject)
+{
+    getEnumerableNamesFromPropertyTable(propertyNames);
+    getEnumerableNamesFromClassInfoTable(exec, baseObject->classInfo(), propertyNames);
+}
+
+void Structure::getEnumerablePropertyNames(ExecState* exec, PropertyNameArray& propertyNames, JSObject* baseObject)
+{
+    bool shouldCache = propertyNames.shouldCache() && !(propertyNames.size() || isDictionary());
+
+    if (shouldCache && m_cachedPropertyNameArrayData) {
+        if (m_cachedPropertyNameArrayData->cachedPrototypeChain() == prototypeChain(exec)) {
+            propertyNames.setData(m_cachedPropertyNameArrayData);
+            return;
+        }
+        clearEnumerationCache();
+    }
+
+    baseObject->getOwnPropertyNames(exec, propertyNames);
+
+    if (m_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(m_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 = prototypeChain(exec);
+        m_cachedPropertyNameArrayData = propertyNames.data();
+        if (!protoChain->isCacheable())
+            return;
+        m_cachedPropertyNameArrayData->setCachedPrototypeChain(protoChain);
+        m_cachedPropertyNameArrayData->setCachedStructure(this);
+    }
+}
+
 void Structure::clearEnumerationCache()
 {
@@ -1012 +1058 @@
 }
 
-void Structure::getEnumerablePropertyNames(PropertyNameArray& propertyNames)
+void Structure::getEnumerableNamesFromPropertyTable(PropertyNameArray& propertyNames)
 {
     materializePropertyMapIfNecessary();
@@ -1066 +1112 @@
         for (size_t i = 0; i < sortedEnumerables.size(); ++i)
             propertyNames.add(sortedEnumerables[i]->key);
+    }
+}
+
+void Structure::getEnumerableNamesFromClassInfoTable(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());
+        }
     }
 }

trunk/JavaScriptCore/runtime/Structure.h

@@ -31 +31 @@
 #include "JSValue.h"
 #include "PropertyMapHashTable.h"
-#include "PropertyNameArray.h"
 #include "StructureChain.h"
 #include "StructureTransitionTable.h"
@@ -78 +77 @@
         ~Structure();
 
+        void markAggregate(MarkStack&);
+
         // These should be used with caution.  
         size_t addPropertyWithoutTransition(const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
@@ -116 +117 @@
         }
 
+        void getEnumerablePropertyNames(ExecState*, PropertyNameArray&, JSObject*);
+        void getOwnEnumerablePropertyNames(ExecState*, PropertyNameArray&, JSObject*);
+
         bool hasGetterSetterProperties() const { return m_hasGetterSetterProperties; }
         void setHasGetterSetterProperties(bool hasGetterSetterProperties) { m_hasGetterSetterProperties = hasGetterSetterProperties; }
@@ -123 +127 @@
         JSCell* specificValue() { return m_specificValueInPrevious; }
         void despecifyDictionaryFunction(const Identifier& propertyName);
-
-        void setEnumerationCache(PassRefPtr<PropertyNameArrayData> data) { m_cachedPropertyNameArrayData = data; }
-        PropertyNameArrayData* enumerationCache() { return m_cachedPropertyNameArrayData.get(); }
-        void clearEnumerationCache();
-        void getEnumerablePropertyNames(PropertyNameArray&);
 
     private:
@@ -142 +141 @@
         size_t remove(const Identifier& propertyName);
         void addAnonymousSlots(unsigned slotCount);
+        void getEnumerableNamesFromPropertyTable(PropertyNameArray&);
+        void getEnumerableNamesFromClassInfoTable(ExecState*, const ClassInfo*, PropertyNameArray&);
 
         void expandPropertyMapHashTable();
@@ -161 +162 @@
             materializePropertyMap();
         }
+
+        void clearEnumerationCache();
 
         signed char transitionCount() const