Support WeakMap
https://bugs.webkit.org/show_bug.cgi?id=120912
Reviewed by Geoffrey Garen.
Source/JavaScriptCore:
Add support for ES6 WeakMap. Add the cluster of boilerplate
classes around the core WeakMapData class.
WeakMapData is a simple object->value hash table that uses a
combo of WeakReferenceHarvester to conditionally keep the weak
value reference live, and UnconditionalFinalizer to clean the
dead keys from the table post-GC.
* CMakeLists.txt:
* GNUmakefile.list.am:
* JavaScriptCore.vcxproj/JavaScriptCore.vcxproj:
* JavaScriptCore.vcxproj/JavaScriptCore.vcxproj.filters:
* JavaScriptCore.xcodeproj/project.pbxproj:
* Target.pri:
* runtime/CommonIdentifiers.h:
* runtime/JSGlobalObject.cpp:
* runtime/JSGlobalObject.h:
(JSC::JSGlobalObject::weakMapDataStructure):
* runtime/JSWeakMap.cpp: Added.
(JSC::JSWeakMap::finishCreation):
(JSC::JSWeakMap::visitChildren):
* runtime/JSWeakMap.h: Added.
(JSC::JSWeakMap::createStructure):
(JSC::JSWeakMap::create):
(JSC::JSWeakMap::weakMapData):
(JSC::JSWeakMap::JSWeakMap):
* runtime/WeakMapConstructor.cpp: Added.
(JSC::WeakMapConstructor::finishCreation):
(JSC::constructWeakMap):
(JSC::WeakMapConstructor::getConstructData):
(JSC::WeakMapConstructor::getCallData):
* runtime/WeakMapConstructor.h: Added.
(JSC::WeakMapConstructor::create):
(JSC::WeakMapConstructor::createStructure):
(JSC::WeakMapConstructor::WeakMapConstructor):
* runtime/WeakMapData.cpp: Added.
(JSC::WeakMapData::WeakMapData):
(JSC::WeakMapData::finishCreation):
(JSC::WeakMapData::destroy):
(JSC::WeakMapData::visitChildren):
(JSC::WeakMapData::set):
(JSC::WeakMapData::get):
(JSC::WeakMapData::remove):
(JSC::WeakMapData::contains):
(JSC::WeakMapData::clear):
(JSC::WeakMapData::DeadKeyCleaner::visitWeakReferences):
(JSC::WeakMapData::DeadKeyCleaner::finalizeUnconditionally):
* runtime/WeakMapData.h: Added.
(JSC::WeakMapData::create):
(JSC::WeakMapData::createStructure):
(JSC::WeakMapData::DeadKeyCleaner::DeadKeyCleaner):
* runtime/WeakMapPrototype.cpp: Added.
(JSC::WeakMapPrototype::finishCreation):
(JSC::getWeakMapData):
(JSC::protoFuncWeakMapClear):
(JSC::protoFuncWeakMapDelete):
(JSC::protoFuncWeakMapGet):
(JSC::protoFuncWeakMapHas):
(JSC::protoFuncWeakMapSet):
* runtime/WeakMapPrototype.h: Added.
(JSC::WeakMapPrototype::create):
(JSC::WeakMapPrototype::createStructure):
(JSC::WeakMapPrototype::WeakMapPrototype):
LayoutTests:
Basic tests.
* js/basic-weakmap-expected.txt: Added.
* js/basic-weakmap.html: Added.
* js/script-tests/basic-weakmap.js: Added.
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@155473 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/Source/JavaScriptCore/runtime/WeakMapData.cpp b/Source/JavaScriptCore/runtime/WeakMapData.cpp
new file mode 100644
index 0000000..4706d1b
--- /dev/null
+++ b/Source/JavaScriptCore/runtime/WeakMapData.cpp
@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2013 Apple Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+#include "WeakMapData.h"
+
+#include "CopiedAllocator.h"
+#include "CopyVisitorInlines.h"
+#include "ExceptionHelpers.h"
+#include "JSCJSValueInlines.h"
+#include "SlotVisitorInlines.h"
+
+#include <wtf/MathExtras.h>
+
+
+namespace JSC {
+
+const ClassInfo WeakMapData::s_info = { "WeakMapData", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(WeakMapData) };
+
+WeakMapData::WeakMapData(VM& vm, JSGlobalObject* globalObject)
+ : Base(vm, globalObject->weakMapDataStructure())
+ , m_deadKeyCleaner(this)
+{
+}
+
+void WeakMapData::finishCreation(VM& vm)
+{
+ Base::finishCreation(vm);
+}
+
+void WeakMapData::destroy(JSCell* cell)
+{
+ static_cast<WeakMapData*>(cell)->~WeakMapData();
+}
+
+void WeakMapData::visitChildren(JSCell* cell, SlotVisitor& visitor)
+{
+ Base::visitChildren(cell, visitor);
+ WeakMapData* thisObj = jsCast<WeakMapData*>(cell);
+ visitor.addUnconditionalFinalizer(&thisObj->m_deadKeyCleaner);
+ visitor.addWeakReferenceHarvester(&thisObj->m_deadKeyCleaner);
+
+ // Rough approximation of the external storage needed for the hashtable.
+ // This isn't exact, but it is close enough, and proportional to the actual
+ // external mermory usage.
+ visitor.reportExtraMemoryUsage(thisObj->m_map.capacity() * (sizeof(JSObject*) + sizeof(WriteBarrier<Unknown>)));
+}
+
+void WeakMapData::set(CallFrame* callFrame, JSObject* key, JSValue value)
+{
+ // Here we force the write barrier on the key.
+ auto result = m_map.add(WriteBarrier<JSObject>(callFrame->vm(), this, key).get(), WriteBarrier<Unknown>());
+ result.iterator->value.set(callFrame->vm(), this, value);
+}
+
+JSValue WeakMapData::get(JSObject* key)
+{
+ auto iter = m_map.find(key);
+ if (iter == m_map.end())
+ return jsUndefined();
+ return iter->value.get();
+}
+
+bool WeakMapData::remove(JSObject* key)
+{
+ auto iter = m_map.find(key);
+ if (iter == m_map.end())
+ return false;
+
+ m_map.remove(iter);
+ return true;
+}
+
+bool WeakMapData::contains(JSObject* key)
+{
+ return m_map.contains(key);
+}
+
+void WeakMapData::clear()
+{
+ m_map.clear();
+}
+
+void WeakMapData::DeadKeyCleaner::visitWeakReferences(SlotVisitor& visitor)
+{
+ m_liveKeyCount = 0;
+ for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
+ if (!Heap::isMarked(it->key))
+ continue;
+ m_liveKeyCount++;
+ visitor.append(&it->value);
+ }
+ RELEASE_ASSERT(m_liveKeyCount <= m_target->m_map.size());
+}
+
+void WeakMapData::DeadKeyCleaner::finalizeUnconditionally()
+{
+ if (m_liveKeyCount > m_target->m_map.size() / 2) {
+ RELEASE_ASSERT(m_liveKeyCount <= m_target->m_map.size());
+ int deadCount = m_target->m_map.size() - m_liveKeyCount;
+ if (!deadCount)
+ return;
+ Vector<JSObject*> deadEntries;
+ deadEntries.reserveCapacity(deadCount);
+ for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
+ if (Heap::isMarked(it->key))
+ continue;
+ deadEntries.uncheckedAppend(it->key);
+ }
+ for (size_t i = 0; i < deadEntries.size(); i++)
+ m_target->m_map.remove(deadEntries[i]);
+ } else {
+ MapType newMap;
+ for (auto it = m_target->m_map.begin(), end = m_target->m_map.end(); it != end; ++it) {
+ if (!Heap::isMarked(it->key))
+ continue;
+ newMap.add(it->key, it->value);
+ }
+ m_target->m_map.swap(newMap);
+ }
+}
+
+}
