Changeset 37381 in webkit for trunk/JavaScriptCore/kjs/PropertyMap.cpp

Timestamp:

Oct 7, 2008, 11:17:37 AM (17 years ago)

Author:

[email protected]

Message:

2008-10-07 Cameron Zwarich <​[email protected]>

Rubber-stamped by Mark Rowe.

Roll out r37370.

File:

• trunk/JavaScriptCore/kjs/PropertyMap.cpp (modified) (17 diffs)

trunk/JavaScriptCore/kjs/PropertyMap.cpp

@@ -78 +78 @@
 #if !DO_PROPERTYMAP_CONSTENCY_CHECK
 
-inline void PropertyMap::checkConsistency()
+inline void PropertyMap::checkConsistency(PropertyStorage&)
 {
 }
@@ -98 +98 @@
     }
 
-    m_deletedOffsets = other.m_deletedOffsets;
     m_getterSetterFlag = other.m_getterSetterFlag;
     return *this;
@@ -116 +115 @@
 }
 
-size_t PropertyMap::put(const Identifier& propertyName, unsigned attributes)
+size_t PropertyMap::put(const Identifier& propertyName, JSValue* value, unsigned attributes, bool checkReadOnly, JSObject* slotBase, PutPropertySlot& slot, PropertyStorage& propertyStorage)
 {
     ASSERT(!propertyName.isNull());
-    ASSERT(get(propertyName) == WTF::notFound);
-
-    checkConsistency();
+    ASSERT(value);
+
+    checkConsistency(propertyStorage);
 
     UString::Rep* rep = propertyName._ustring.rep();
 
     if (!m_table)
-        createTable();
+        expand(propertyStorage);
 
     // FIXME: Consider a fast case for tables with no deleted sentinels.
@@ -144 +143 @@
             break;
 
-        if (entryIndex == deletedSentinelIndex) {
+        if (m_table->entries()[entryIndex - 1].key == rep) {
+            if (checkReadOnly && (m_table->entries()[entryIndex - 1].attributes & ReadOnly))
+                return WTF::notFound;
+            // Put a new value in an existing hash table entry.
+            propertyStorage[entryIndex - 2] = value;
+            // Attributes are intentionally not updated.
+            slot.setExistingProperty(slotBase, entryIndex - 2);
+            return entryIndex - 2;
+        } else if (entryIndex == deletedSentinelIndex) {
             // If we find a deleted-element sentinel, remember it for use later.
             if (!foundDeletedElement) {
@@ -187 +194 @@
     m_table->entries()[entryIndex - 1].attributes = attributes;
     m_table->entries()[entryIndex - 1].index = ++m_table->lastIndexUsed;
-
-    unsigned newOffset;
-    if (!m_deletedOffsets.isEmpty()) {
-        newOffset = m_deletedOffsets.last();
-        m_deletedOffsets.removeLast();
-    } else
-        newOffset = m_table->keyCount + m_table->deletedSentinelCount;
-    m_table->entries()[entryIndex - 1].offset = newOffset;
-
     ++m_table->keyCount;
 
+    propertyStorage[entryIndex - 2] = value;
+
     if ((m_table->keyCount + m_table->deletedSentinelCount) * 2 >= m_table->size)
-        expand();
-
-    checkConsistency();
-    return newOffset;
-}
-
-size_t PropertyMap::remove(const Identifier& propertyName)
+        expand(propertyStorage);
+
+    checkConsistency(propertyStorage);
+    slot.setNewProperty(slotBase, entryIndex - 2);
+    return entryIndex - 2;
+}
+
+void PropertyMap::remove(const Identifier& propertyName, PropertyStorage& propertyStorage)
 {
     ASSERT(!propertyName.isNull());
 
-    checkConsistency();
+    checkConsistency(propertyStorage);
 
     UString::Rep* rep = propertyName._ustring.rep();
 
     if (!m_table)
-        return WTF::notFound;
-
+        return;
 
 #if DUMP_PROPERTYMAP_STATS
@@ -230 +230 @@
         entryIndex = m_table->entryIndices[i & m_table->sizeMask];
         if (entryIndex == emptyEntryIndex)
-            return WTF::notFound;
+            return;
 
         key = m_table->entries()[entryIndex - 1].key;
@@ -253 +253 @@
     // the entry so we can iterate all the entries as needed.
     m_table->entryIndices[i & m_table->sizeMask] = deletedSentinelIndex;
-
-    size_t offset = m_table->entries()[entryIndex - 1].offset;
-
     key->deref();
     m_table->entries()[entryIndex - 1].key = 0;
     m_table->entries()[entryIndex - 1].attributes = 0;
-    m_table->entries()[entryIndex - 1].offset = 0;
-    m_deletedOffsets.append(offset);
+
+    propertyStorage[entryIndex - 2] = jsUndefined();
 
     ASSERT(m_table->keyCount >= 1);
@@ -267 +264 @@
 
     if (m_table->deletedSentinelCount * 4 >= m_table->size)
-        rehash();
-
-    checkConsistency();
-    return offset;
-}
-
-size_t PropertyMap::get(const Identifier& propertyName, unsigned& attributes)
+        rehash(propertyStorage);
+
+    checkConsistency(propertyStorage);
+}
+
+size_t PropertyMap::getOffset(const Identifier& propertyName, unsigned& attributes)
 {
     ASSERT(!propertyName.isNull());
@@ -294 +290 @@
     if (rep == m_table->entries()[entryIndex - 1].key) {
         attributes = m_table->entries()[entryIndex - 1].attributes;
-        return m_table->entries()[entryIndex - 1].offset;
+        return entryIndex - 2;
     }
 
@@ -316 +312 @@
         if (rep == m_table->entries()[entryIndex - 1].key) {
             attributes = m_table->entries()[entryIndex - 1].attributes;
-            return m_table->entries()[entryIndex - 1].offset;
-        }
-    }
-}
-
-void PropertyMap::insert(const Entry& entry)
+            return entryIndex - 2;
+        }
+    }
+}
+
+void PropertyMap::insert(const Entry& entry, JSValue* value, PropertyStorage& propertyStorage)
 {
     ASSERT(m_table);
@@ -355 +351 @@
     m_table->entries()[entryIndex - 1] = entry;
 
+    propertyStorage[entryIndex - 2] = value;
+
     ++m_table->keyCount;
 }
 
-void PropertyMap::expand()
+void PropertyMap::expand(PropertyStorage& propertyStorage)
+{
+    if (!m_table)
+        createTable(propertyStorage);
+    else
+        rehash(m_table->size * 2, propertyStorage);
+}
+
+void PropertyMap::rehash(PropertyStorage& propertyStorage)
 {
     ASSERT(m_table);
-    rehash(m_table->size * 2);
-}
-
-void PropertyMap::createTable()
+    ASSERT(m_table->size);
+    rehash(m_table->size, propertyStorage);
+}
+
+void PropertyMap::createTable(PropertyStorage& propertyStorage)
 {
     const unsigned newTableSize = 16;
@@ -370 +377 @@
     ASSERT(!m_table);
 
-    checkConsistency();
+    checkConsistency(propertyStorage);
 
     m_table = static_cast<Table*>(fastZeroedMalloc(Table::allocationSize(newTableSize)));
@@ -376 +383 @@
     m_table->sizeMask = newTableSize - 1;
 
-    checkConsistency();
-}
-
-void PropertyMap::rehash()
+    checkConsistency(propertyStorage);
+}
+
+void PropertyMap::rehash(unsigned newTableSize, PropertyStorage& propertyStorage)
 {
     ASSERT(m_table);
-    ASSERT(m_table->size);
-    rehash(m_table->size);
-}
-
-void PropertyMap::rehash(unsigned newTableSize)
-{
-    ASSERT(m_table);
-
-    checkConsistency();
+
+    checkConsistency(propertyStorage);
 
     Table* oldTable = m_table;
+    JSValue** oldPropertStorage = propertyStorage;
 
     m_table = static_cast<Table*>(fastZeroedMalloc(Table::allocationSize(newTableSize)));
     m_table->size = newTableSize;
     m_table->sizeMask = newTableSize - 1;
+
+    propertyStorage = new JSValue*[m_table->size];
 
     unsigned lastIndexUsed = 0;
@@ -403 +406 @@
         if (oldTable->entries()[i].key) {
             lastIndexUsed = max(oldTable->entries()[i].index, lastIndexUsed);
-            insert(oldTable->entries()[i]);
+            insert(oldTable->entries()[i], oldPropertStorage[i - 1], propertyStorage);
         }
     }
@@ -409 +412 @@
 
     fastFree(oldTable);
-
-    checkConsistency();
+    delete [] oldPropertStorage;
+
+    checkConsistency(propertyStorage);
 }
 
@@ -482 +486 @@
 #if DO_PROPERTYMAP_CONSTENCY_CHECK
 
-void PropertyMap::checkConsistency()
+void PropertyMap::checkConsistency(PropertyStorage& propertyStorage)
 {
     if (!m_table)
@@ -522 +526 @@
     for (unsigned c = 1; c <= m_table->keyCount + m_table->deletedSentinelCount; ++c) {
         UString::Rep* rep = m_table->entries()[c].key;
-        if (!rep)
+        if (!rep) {
+            ASSERT(propertyStorage[c - 1]->isUndefined());
             continue;
+        }
         ++nonEmptyEntryCount;
         unsigned i = rep->computedHash();