Changeset 64184 in webkit for trunk/JavaScriptCore/runtime/JSArray.h

Timestamp:

Jul 27, 2010, 5:36:56 PM (15 years ago)

Author:

[email protected]

Message:

Temporarily rolling out ​http://trac.webkit.org/changeset/64177,
this seems to give QT ARM/Win a headache (specifically, looks
like structure layour differs, objects get too large -
"..\..\..\JavaScriptCore\runtime\ArrayPrototype.cpp:41:"
"error: size of array 'dummyclass_fits_in_cell' is negative").

• jit/JITPropertyAccess.cpp:

(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::privateCompilePatchGetArrayLength):

• jit/JITPropertyAccess32_64.cpp:

(JSC::JIT::emit_op_get_by_val):
(JSC::JIT::emit_op_put_by_val):
(JSC::JIT::privateCompilePatchGetArrayLength):

• runtime/ArrayPrototype.cpp:

(JSC::arrayProtoFuncShift):
(JSC::arrayProtoFuncSplice):
(JSC::arrayProtoFuncUnShift):

• runtime/JSArray.cpp:

(JSC::increasedVectorLength):
(JSC::JSArray::JSArray):
(JSC::JSArray::~JSArray):
(JSC::JSArray::getOwnPropertySlot):
(JSC::JSArray::getOwnPropertyDescriptor):
(JSC::JSArray::put):
(JSC::JSArray::putSlowCase):
(JSC::JSArray::deleteProperty):
(JSC::JSArray::getOwnPropertyNames):
(JSC::JSArray::increaseVectorLength):
(JSC::JSArray::setLength):
(JSC::JSArray::pop):
(JSC::JSArray::push):
(JSC::JSArray::sortNumeric):
(JSC::JSArray::sort):
(JSC::JSArray::fillArgList):
(JSC::JSArray::copyToRegisters):
(JSC::JSArray::compactForSorting):
(JSC::JSArray::subclassData):
(JSC::JSArray::setSubclassData):
(JSC::JSArray::checkConsistency):

• runtime/JSArray.h:

(JSC::JSArray::length):
(JSC::JSArray::canGetIndex):
(JSC::JSArray::getIndex):
(JSC::JSArray::setIndex):
(JSC::JSArray::uncheckedSetIndex):
(JSC::JSArray::markChildrenDirect):

File:

• trunk/JavaScriptCore/runtime/JSArray.h (modified) (8 diffs)

trunk/JavaScriptCore/runtime/JSArray.h

@@ -30 +30 @@
     typedef HashMap<unsigned, JSValue> SparseArrayValueMap;
 
-    // This struct holds the actual data values of an array.  A JSArray object points to it's contained ArrayStorage
-    // struct by pointing to m_vector.  To access the contained ArrayStorage struct, use the getStorage() and 
-    // setStorage() methods.  It is important to note that there may be space before the ArrayStorage that 
-    // is used to quick unshift / shift operation.  The actual allocated pointer is available by using:
-    //     getStorage() - m_indexBias * sizeof(JSValue)
     struct ArrayStorage {
-        unsigned m_length; // The "length" property on the array
+        unsigned m_length;
         unsigned m_numValuesInVector;
         SparseArrayValueMap* m_sparseValueMap;
@@ -73 +68 @@
 
         static JS_EXPORTDATA const ClassInfo info;
-        
-        unsigned length() const { return arrayStorage()->m_length; }
+
+        unsigned length() const { return m_storage->m_length; }
         void setLength(unsigned); // OK to use on new arrays, but not if it might be a RegExpMatchArray.
 
@@ -84 +79 @@
         JSValue pop();
 
-        void shiftCount(ExecState*, int count);
-        void unshiftCount(ExecState*, int count);
-
-        bool canGetIndex(unsigned i) { return i < m_vectorLength && m_vector[i]; }
+        bool canGetIndex(unsigned i) { return i < m_vectorLength && m_storage->m_vector[i]; }
         JSValue getIndex(unsigned i)
         {
             ASSERT(canGetIndex(i));
-            return m_vector[i];
+            return m_storage->m_vector[i];
         }
 
@@ -98 +90 @@
         {
             ASSERT(canSetIndex(i));
-            
-            JSValue& x = m_vector[i];
+            JSValue& x = m_storage->m_vector[i];
             if (!x) {
-                ArrayStorage *storage = arrayStorage();
-                ++storage->m_numValuesInVector;
-                if (i >= storage->m_length)
-                    storage->m_length = i + 1;
+                ++m_storage->m_numValuesInVector;
+                if (i >= m_storage->m_length)
+                    m_storage->m_length = i + 1;
             }
             x = v;
         }
-        
+
         void uncheckedSetIndex(unsigned i, JSValue v)
         {
             ASSERT(canSetIndex(i));
-            ArrayStorage *storage = arrayStorage();
 #if CHECK_ARRAY_CONSISTENCY
-            ASSERT(storage->m_inCompactInitialization);
+            ASSERT(m_storage->m_inCompactInitialization);
 #endif
-            storage->m_vector[i] = v;
+            m_storage->m_vector[i] = v;
         }
 
@@ -139 +128 @@
         void* subclassData() const;
         void setSubclassData(void*);
-        
-        inline ArrayStorage *arrayStorage() const
-        {
-            return reinterpret_cast<ArrayStorage*>(reinterpret_cast<char*>(m_vector) - (sizeof(ArrayStorage) - sizeof(JSValue)));
-        }
-
-        inline void setArrayStorage(ArrayStorage *storage)
-        {
-            m_vector = &storage->m_vector[0];
-        }
 
     private:
@@ -156 +135 @@
         void putSlowCase(ExecState*, unsigned propertyName, JSValue);
 
-        unsigned getNewVectorLength(unsigned desiredLength);
         bool increaseVectorLength(unsigned newLength);
-        bool increaseVectorPrefixLength(unsigned newLength);
         
         unsigned compactForSorting();
@@ -165 +142 @@
         void checkConsistency(ConsistencyCheckType = NormalConsistencyCheck);
 
-        unsigned m_vectorLength; // The valid length of m_vector
-        int m_indexBias; // The number of JSValue sized blocks before ArrayStorage.
-        JSValue* m_vector; // Copy of ArrayStorage.m_vector.  Used for quick vector access and to materialize ArrayStorage ptr.
+        unsigned m_vectorLength;
+        ArrayStorage* m_storage;
     };
 
@@ -193 +169 @@
         JSObject::markChildrenDirect(markStack);
         
-        ArrayStorage* storage = arrayStorage();
+        ArrayStorage* storage = m_storage;
 
         unsigned usedVectorLength = std::min(storage->m_length, m_vectorLength);