Reduce memory use for static property maps
authorbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 14 Mar 2014 06:45:39 +0000 (06:45 +0000)
committerbarraclough@apple.com <barraclough@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 14 Mar 2014 06:45:39 +0000 (06:45 +0000)
https://bugs.webkit.org/show_bug.cgi?id=129986

Reviewed by Andreas Kling.

Static property tables are currently duplicated on first use from read-only memory into dirty memory
in every process, and since the entries are large (48 bytes) and the tables can be unusually sparse
(we use a custom hash table without a rehash) a lot of memory may be wasted.

Source/JavaScriptCore:

First, reduce the size of the hashtable. Instead of storing values in the table the hashtable maps
from string hashes to indicies into a densely packed array of values. Compute the index table at
compile time as a part of the derived sources step, such that this may be read-only data.

Second, don't copy all data from the HashTableValue array into a HashEntry objects. Instead refer
directly to the HashTableValue entries. The only data that needs to be allocated at runtime are the
keys, which are Identifiers.

* create_hash_table:
    - emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).
* parser/Lexer.cpp:
(JSC::Lexer<LChar>::parseIdentifier):
(JSC::Lexer<UChar>::parseIdentifier):
(JSC::Lexer<T>::parseIdentifierSlowCase):
    - HashEntry -> HashTableValue.
* parser/Lexer.h:
(JSC::Keywords::getKeyword):
    - HashEntry -> HashTableValue.
* runtime/ClassInfo.h:
    - removed HashEntry.
* runtime/JSObject.cpp:
(JSC::getClassPropertyNames):
    - use HashTable::ConstIterator.
(JSC::JSObject::put):
(JSC::JSObject::deleteProperty):
(JSC::JSObject::findPropertyHashEntry):
    - HashEntry -> HashTableValue.
(JSC::JSObject::reifyStaticFunctionsForDelete):
    - changed HashTable::ConstIterator interface.
* runtime/JSObject.h:
    - HashEntry -> HashTableValue.
* runtime/Lookup.cpp:
(JSC::HashTable::createTable):
    - table -> keys, keys array is now densely packed.
(JSC::HashTable::deleteTable):
    - table -> keys.
(JSC::setUpStaticFunctionSlot):
    - HashEntry -> HashTableValue.
* runtime/Lookup.h:
(JSC::HashTableValue::builtinGenerator):
(JSC::HashTableValue::function):
(JSC::HashTableValue::functionLength):
(JSC::HashTableValue::propertyGetter):
(JSC::HashTableValue::propertyPutter):
(JSC::HashTableValue::lexerValue):
    - added accessor methods from HashEntry.
(JSC::HashTable::copy):
    - fields changed.
(JSC::HashTable::initializeIfNeeded):
    - table -> keys.
(JSC::HashTable::entry):
    - HashEntry -> HashTableValue.
(JSC::HashTable::ConstIterator::ConstIterator):
    - iterate packed value array, so no need to skipInvalidKeys().
(JSC::HashTable::ConstIterator::value):
(JSC::HashTable::ConstIterator::key):
(JSC::HashTable::ConstIterator::operator->):
    - accessors now get HashTableValue/StringImpl* separately.
(JSC::HashTable::ConstIterator::operator++):
    - iterate packed value array, so no need to skipInvalidKeys().
(JSC::HashTable::end):
    - end is now size of dense not sparse array.
(JSC::getStaticPropertySlot):
(JSC::getStaticFunctionSlot):
(JSC::getStaticValueSlot):
(JSC::putEntry):
(JSC::lookupPut):
    - HashEntry -> HashTableValue.

Source/WebCore:

* bindings/js/JSDOMBinding.h:
(WebCore::getStaticValueSlotEntryWithoutCaching):
(WebCore::getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>):
    - HashEntry -> HashTableValue.
* bindings/js/JSDOMWindowCustom.cpp:
(WebCore::JSDOMWindow::getOwnPropertySlot):
    - HashEntry -> HashTableValue.
* bindings/js/JSHistoryCustom.cpp:
(WebCore::JSHistory::getOwnPropertySlotDelegate):
    - HashEntry -> HashTableValue.
* bindings/js/JSLocationCustom.cpp:
(WebCore::JSLocation::getOwnPropertySlotDelegate):
(WebCore::JSLocation::putDelegate):
    - HashEntry -> HashTableValue.
* bindings/scripts/CodeGeneratorJS.pm:
(GenerateGetOwnPropertySlotBody):
    - HashEntry -> HashTableValue.
(GenerateHashTable):
    - emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).

LayoutTests:

* inspector-protocol/debugger/setPauseOnExceptions-all-expected.txt:
* inspector-protocol/debugger/setPauseOnExceptions-none-expected.txt:
* inspector-protocol/debugger/setPauseOnExceptions-uncaught-expected.txt:
* js/dom/dom-static-property-for-in-iteration-expected.txt:
    - Properties now iterated in correct order, not permuted by hash table.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@165603 268f45cc-cd09-0410-ab3c-d52691b4dbfc

36 files changed:
LayoutTests/ChangeLog
LayoutTests/inspector-protocol/debugger/setPauseOnExceptions-all-expected.txt
LayoutTests/inspector-protocol/debugger/setPauseOnExceptions-none-expected.txt
LayoutTests/inspector-protocol/debugger/setPauseOnExceptions-uncaught-expected.txt
LayoutTests/js/dom/dom-static-property-for-in-iteration-expected.txt
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/create_hash_table
Source/JavaScriptCore/parser/Lexer.cpp
Source/JavaScriptCore/parser/Lexer.h
Source/JavaScriptCore/runtime/ClassInfo.h
Source/JavaScriptCore/runtime/JSObject.cpp
Source/JavaScriptCore/runtime/JSObject.h
Source/JavaScriptCore/runtime/Lookup.cpp
Source/JavaScriptCore/runtime/Lookup.h
Source/WebCore/ChangeLog
Source/WebCore/bindings/js/JSDOMBinding.h
Source/WebCore/bindings/js/JSDOMWindowCustom.cpp
Source/WebCore/bindings/js/JSHistoryCustom.cpp
Source/WebCore/bindings/js/JSLocationCustom.cpp
Source/WebCore/bindings/scripts/CodeGeneratorJS.pm
Source/WebCore/bindings/scripts/test/JS/JSTestActiveDOMObject.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestCustomNamedGetter.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestEventConstructor.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestEventTarget.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestException.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestGenerateIsReachable.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestInterface.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestMediaQueryListListener.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestNamedConstructor.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestNode.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestOverloadedConstructors.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestSerializedScriptValueInterface.cpp
Source/WebCore/bindings/scripts/test/JS/JSTestTypedefs.cpp
Source/WebCore/bindings/scripts/test/JS/JSattribute.cpp
Source/WebCore/bindings/scripts/test/JS/JSreadonly.cpp

index 3225672..046cba1 100644 (file)
@@ -1,3 +1,20 @@
+2014-03-12  Gavin Barraclough  <barraclough@apple.com>
+
+        Reduce memory use for static property maps
+        https://bugs.webkit.org/show_bug.cgi?id=129986
+
+        Reviewed by Andreas Kling.
+
+        Static property tables are currently duplicated on first use from read-only memory into dirty memory
+        in every process, and since the entries are large (48 bytes) and the tables can be unusually sparse
+        (we use a custom hash table without a rehash) a lot of memory may be wasted.
+
+        * inspector-protocol/debugger/setPauseOnExceptions-all-expected.txt:
+        * inspector-protocol/debugger/setPauseOnExceptions-none-expected.txt:
+        * inspector-protocol/debugger/setPauseOnExceptions-uncaught-expected.txt:
+        * js/dom/dom-static-property-for-in-iteration-expected.txt:
+            - Properties now iterated in correct order, not permuted by hash table.
+
 2014-03-13  Manish R Gurnaney  <m.gurnaney@samsung.com>
 
         Scroll size is not recalculated when absolute left of child is updated
index e7cb1d3..df19f8f 100644 (file)
@@ -1,6 +1,6 @@
 CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
index cdd443d..0151937 100644 (file)
@@ -1,6 +1,6 @@
 CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
index 61d7f75..27a9205 100644 (file)
@@ -1,6 +1,6 @@
 CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
@@ -13,7 +13,7 @@ CONSOLE MESSAGE: line 18: [object Object]
 CONSOLE MESSAGE: line 18: Error: error message
 CONSOLE MESSAGE: line 1: caught inline: {"line":1,"column":36}
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":3,"column":11,"sourceURL":"exception.js"}
-CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"message":"NotFoundError: DOM Exception 8","name":"NotFoundError","line":8,"column":30,"sourceURL":"exception.js"}
+CONSOLE MESSAGE: line 38: catchNested caught exception: {"code":8,"name":"NotFoundError","message":"NotFoundError: DOM Exception 8","line":8,"column":30,"sourceURL":"exception.js"}
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception in host function"
 CONSOLE MESSAGE: line 38: catchNested caught exception: "exception string"
 CONSOLE MESSAGE: line 38: catchNested caught exception: {"line":18,"column":12,"sourceURL":"exception.js"}
index db71ba4..36a4bb1 100644 (file)
@@ -9,102 +9,102 @@ PASS a["wibble"] is 3
 PASS a["hick"] is 4
 PASS a["hock"] is 5
 PASS a["snood"] is 6
-PASS a["origin"] is file://
-PASS a["hash"] is 
-PASS a["search"] is 
-PASS a["text"] is nerget
-PASS a["hostname"] is 
-PASS a["rel"] is 
+PASS a["charset"] is 
+PASS a["coords"] is 
 PASS a["hreflang"] is 
+PASS a["name"] is 
 PASS a["ping"] is 
+PASS a["rel"] is 
 PASS a["rev"] is 
-PASS a["host"] is 
-PASS a["charset"] is 
+PASS a["shape"] is 
 PASS a["target"] is 
 PASS a["type"] is 
-PASS a["coords"] is 
-PASS a["name"] is 
-PASS a["shape"] is 
+PASS a["hash"] is 
+PASS a["host"] is 
+PASS a["hostname"] is 
 PASS a["port"] is 
 PASS a["protocol"] is file:
-PASS a["outerHTML"] is <a id="foo" href="bar">nerget</a>
-PASS a["spellcheck"] is true
-PASS a["webkitdropzone"] is 
+PASS a["search"] is 
+PASS a["origin"] is file://
+PASS a["text"] is nerget
 PASS a["title"] is 
 PASS a["lang"] is 
 PASS a["translate"] is true
-PASS a["hidden"] is false
-PASS a["innerText"] is nerget
 PASS a["dir"] is 
-PASS a["innerHTML"] is nerget
-PASS a["contentEditable"] is inherit
 PASS a["tabIndex"] is 0
 PASS a["draggable"] is true
-PASS a["outerText"] is nerget
+PASS a["webkitdropzone"] is 
+PASS a["hidden"] is false
 PASS a["accessKey"] is 
+PASS a["innerHTML"] is nerget
+PASS a["innerText"] is nerget
+PASS a["outerHTML"] is <a id="foo" href="bar">nerget</a>
+PASS a["outerText"] is nerget
 PASS a["children"] is [object HTMLCollection]
+PASS a["contentEditable"] is inherit
 PASS a["isContentEditable"] is false
+PASS a["spellcheck"] is true
+PASS a["tagName"] is A
+PASS a["attributes"] is [object NamedNodeMap]
 PASS a["style"] is [object CSSStyleDeclaration]
 PASS a["id"] is foo
-PASS a["dataset"] is [object DOMStringMap]
+PASS a["offsetLeft"] is 8
+PASS a["offsetTop"] is 774
+PASS a["offsetWidth"] is 39
+PASS a["offsetHeight"] is 18
+PASS a["offsetParent"] is [object HTMLBodyElement]
+PASS a["clientLeft"] is 0
+PASS a["clientTop"] is 0
 PASS a["clientWidth"] is 0
+PASS a["clientHeight"] is 0
+PASS a["scrollLeft"] is 0
+PASS a["scrollTop"] is 0
 PASS a["scrollWidth"] is 0
-PASS a["attributes"] is [object NamedNodeMap]
-PASS a["webkitRegionOverset"] is undefined
-PASS a["ALLOW_KEYBOARD_INPUT"] is 1
-PASS a["offsetWidth"] is 39
-PASS a["classList"] is 
-PASS a["offsetLeft"] is 8
+PASS a["scrollHeight"] is 0
 PASS a["className"] is 
-PASS a["clientTop"] is 0
+PASS a["classList"] is 
+PASS a["dataset"] is [object DOMStringMap]
+PASS a["firstElementChild"] is null
 PASS a["lastElementChild"] is null
-PASS a["offsetParent"] is [object HTMLBodyElement]
-PASS a["nextElementSibling"] is [object HTMLScriptElement]
-PASS a["tagName"] is A
 PASS a["previousElementSibling"] is [object HTMLDivElement]
+PASS a["nextElementSibling"] is [object HTMLScriptElement]
 PASS a["childElementCount"] is 0
-PASS a["scrollLeft"] is 0
-PASS a["firstElementChild"] is null
 PASS a["uiactions"] is 
-PASS a["clientLeft"] is 0
-PASS a["offsetHeight"] is 18
-PASS a["clientHeight"] is 0
-PASS a["offsetTop"] is 1074
-PASS a["scrollTop"] is 0
-PASS a["scrollHeight"] is 0
-PASS a["previousSibling"] is [object Text]
-PASS a["NOTATION_NODE"] is 12
-PASS a["CDATA_SECTION_NODE"] is 4
-PASS a["lastChild"] is [object Text]
-PASS a["ELEMENT_NODE"] is 1
+PASS a["webkitRegionOverset"] is undefined
+PASS a["ALLOW_KEYBOARD_INPUT"] is 1
+PASS a["nodeName"] is A
 PASS a["nodeValue"] is null
-PASS a["DOCUMENT_POSITION_DISCONNECTED"] is 1
-PASS a["ENTITY_NODE"] is 6
-PASS a["TEXT_NODE"] is 3
-PASS a["ENTITY_REFERENCE_NODE"] is 5
-PASS a["textContent"] is nerget
 PASS a["nodeType"] is 1
-PASS a["DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC"] is 32
-PASS a["ownerDocument"] is [object HTMLDocument]
-PASS a["PROCESSING_INSTRUCTION_NODE"] is 7
-PASS a["localName"] is a
 PASS a["parentNode"] is [object HTMLBodyElement]
-PASS a["firstChild"] is [object Text]
-PASS a["DOCUMENT_POSITION_PRECEDING"] is 2
-PASS a["DOCUMENT_TYPE_NODE"] is 10
-PASS a["COMMENT_NODE"] is 8
-PASS a["nodeName"] is A
-PASS a["DOCUMENT_POSITION_FOLLOWING"] is 4
-PASS a["prefix"] is null
 PASS a["childNodes"] is [object NodeList]
+PASS a["firstChild"] is [object Text]
+PASS a["lastChild"] is [object Text]
+PASS a["previousSibling"] is [object Text]
 PASS a["nextSibling"] is [object Text]
-PASS a["ATTRIBUTE_NODE"] is 2
-PASS a["DOCUMENT_POSITION_CONTAINED_BY"] is 16
+PASS a["ownerDocument"] is [object HTMLDocument]
 PASS a["namespaceURI"] is http://www.w3.org/1999/xhtml
+PASS a["prefix"] is null
+PASS a["localName"] is a
+PASS a["textContent"] is nerget
 PASS a["parentElement"] is [object HTMLBodyElement]
+PASS a["ELEMENT_NODE"] is 1
+PASS a["ATTRIBUTE_NODE"] is 2
+PASS a["TEXT_NODE"] is 3
+PASS a["CDATA_SECTION_NODE"] is 4
+PASS a["ENTITY_REFERENCE_NODE"] is 5
+PASS a["ENTITY_NODE"] is 6
+PASS a["PROCESSING_INSTRUCTION_NODE"] is 7
+PASS a["COMMENT_NODE"] is 8
 PASS a["DOCUMENT_NODE"] is 9
+PASS a["DOCUMENT_TYPE_NODE"] is 10
 PASS a["DOCUMENT_FRAGMENT_NODE"] is 11
+PASS a["NOTATION_NODE"] is 12
+PASS a["DOCUMENT_POSITION_DISCONNECTED"] is 1
+PASS a["DOCUMENT_POSITION_PRECEDING"] is 2
+PASS a["DOCUMENT_POSITION_FOLLOWING"] is 4
 PASS a["DOCUMENT_POSITION_CONTAINS"] is 8
+PASS a["DOCUMENT_POSITION_CONTAINED_BY"] is 16
+PASS a["DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC"] is 32
 PASS successfullyParsed is true
 
 TEST COMPLETE
index d3548dd..d851e86 100644 (file)
@@ -1,3 +1,83 @@
+2014-03-12  Gavin Barraclough  <barraclough@apple.com>
+
+        Reduce memory use for static property maps
+        https://bugs.webkit.org/show_bug.cgi?id=129986
+
+        Reviewed by Andreas Kling.
+
+        Static property tables are currently duplicated on first use from read-only memory into dirty memory
+        in every process, and since the entries are large (48 bytes) and the tables can be unusually sparse
+        (we use a custom hash table without a rehash) a lot of memory may be wasted.
+
+        First, reduce the size of the hashtable. Instead of storing values in the table the hashtable maps
+        from string hashes to indicies into a densely packed array of values. Compute the index table at
+        compile time as a part of the derived sources step, such that this may be read-only data.
+
+        Second, don't copy all data from the HashTableValue array into a HashEntry objects. Instead refer
+        directly to the HashTableValue entries. The only data that needs to be allocated at runtime are the
+        keys, which are Identifiers.
+
+        * create_hash_table:
+            - emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).
+        * parser/Lexer.cpp:
+        (JSC::Lexer<LChar>::parseIdentifier):
+        (JSC::Lexer<UChar>::parseIdentifier):
+        (JSC::Lexer<T>::parseIdentifierSlowCase):
+            - HashEntry -> HashTableValue.
+        * parser/Lexer.h:
+        (JSC::Keywords::getKeyword):
+            - HashEntry -> HashTableValue.
+        * runtime/ClassInfo.h:
+            - removed HashEntry.
+        * runtime/JSObject.cpp:
+        (JSC::getClassPropertyNames):
+            - use HashTable::ConstIterator.
+        (JSC::JSObject::put):
+        (JSC::JSObject::deleteProperty):
+        (JSC::JSObject::findPropertyHashEntry):
+            - HashEntry -> HashTableValue.
+        (JSC::JSObject::reifyStaticFunctionsForDelete):
+            - changed HashTable::ConstIterator interface.
+        * runtime/JSObject.h:
+            - HashEntry -> HashTableValue.
+        * runtime/Lookup.cpp:
+        (JSC::HashTable::createTable):
+            - table -> keys, keys array is now densely packed.
+        (JSC::HashTable::deleteTable):
+            - table -> keys.
+        (JSC::setUpStaticFunctionSlot):
+            - HashEntry -> HashTableValue.
+        * runtime/Lookup.h:
+        (JSC::HashTableValue::builtinGenerator):
+        (JSC::HashTableValue::function):
+        (JSC::HashTableValue::functionLength):
+        (JSC::HashTableValue::propertyGetter):
+        (JSC::HashTableValue::propertyPutter):
+        (JSC::HashTableValue::lexerValue):
+            - added accessor methods from HashEntry.
+        (JSC::HashTable::copy):
+            - fields changed.
+        (JSC::HashTable::initializeIfNeeded):
+            - table -> keys.
+        (JSC::HashTable::entry):
+            - HashEntry -> HashTableValue.
+        (JSC::HashTable::ConstIterator::ConstIterator):
+            - iterate packed value array, so no need to skipInvalidKeys().
+        (JSC::HashTable::ConstIterator::value):
+        (JSC::HashTable::ConstIterator::key):
+        (JSC::HashTable::ConstIterator::operator->):
+            - accessors now get HashTableValue/StringImpl* separately.
+        (JSC::HashTable::ConstIterator::operator++):
+            - iterate packed value array, so no need to skipInvalidKeys().
+        (JSC::HashTable::end):
+            - end is now size of dense not sparse array.
+        (JSC::getStaticPropertySlot):
+        (JSC::getStaticFunctionSlot):
+        (JSC::getStaticValueSlot):
+        (JSC::putEntry):
+        (JSC::lookupPut):
+            - HashEntry -> HashTableValue.
+
 2014-03-13  Filip Pizlo  <fpizlo@apple.com>
 
         Unreviewed, fix Mac no-FTL build.
index f0f6a90..88e8447 100755 (executable)
@@ -41,6 +41,8 @@ my @keys = ();
 my @attrs = ();
 my @values = ();
 my @hashes = ();
+my @table = ();
+my @links = ();
 
 my $hasSetter = "false";
 
@@ -76,6 +78,8 @@ while (<IN>) {
         @attrs = ();
         @values = ();
         @hashes = ();
+        @table = ();
+        @links = ();
 
         $inside = 0;
     } elsif (/^(\S+)\s*(\S+)\s*([\w\|]*)\s*(\w*)\s*$/ && $inside) {
@@ -155,8 +159,6 @@ sub leftShift($$) {
 
 sub calcCompactHashSize()
 {
-    my @table = ();
-    my @links = ();
     my $compactHashSize = ceilingToPowerOf2(2 * @keys);
     $compactHashSizeMask = $compactHashSize - 1;
     $compactSize = $compactHashSize;
@@ -247,6 +249,8 @@ sub output() {
 
     my $nameEntries = "${name}Values";
     $nameEntries =~ s/:/_/g;
+    my $nameIndex = "${name}Index";
+    $nameIndex =~ s/:/_/g;
 
     print "\n#include \"JSCBuiltins.h\"\n";
     print "\n#include \"Lookup.h\"\n" if ($includelookup);
@@ -257,8 +261,19 @@ sub output() {
     } else {
         print "\nnamespace JSC {\n";
     }
-    my $count = scalar @keys + 1;
-    print "\nstatic const struct HashTableValue ${nameEntries}\[$count\] = {\n";
+
+    print "\nstatic const struct CompactHashIndex ${nameIndex}\[$compactSize\] = {\n";
+    for (my $i = 0; $i < $compactSize; $i++) {
+        my $T = -1;
+        if (defined($table[$i])) { $T = $table[$i]; }
+        my $L = -1;
+        if (defined($links[$i])) { $L = $links[$i]; }
+        print "    { $T, $L },\n";
+    }
+    print "};\n\n";
+
+    my $packedSize = scalar @keys;
+    print "\nstatic const struct HashTableValue ${nameEntries}\[$packedSize\] = {\n";
     my $i = 0;
     foreach my $key (@keys) {
         my $firstValue = "";
@@ -304,9 +319,8 @@ sub output() {
         }
         $i++;
     }
-    print "   { 0, 0, NoIntrinsic, 0, 0 }\n";
     print "};\n\n";
     print "extern const struct HashTable $name =\n";
-    print "    \{ $compactSize, $compactHashSizeMask, $hasSetter, $nameEntries, 0 \};\n";
+    print "    \{ $packedSize, $compactHashSizeMask, $hasSetter, $nameEntries, 0, $nameIndex \};\n";
     print "} // namespace\n";
 }
index 2e3d30c..c7fc50c 100644 (file)
@@ -829,7 +829,7 @@ template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<LChar>::p
     if (UNLIKELY((remaining < maxTokenLength) && !(lexerFlags & LexerFlagsIgnoreReservedWords)) && !isPrivateName) {
         ASSERT(shouldCreateIdentifier);
         if (remaining < maxTokenLength) {
-            const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
+            const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
             ASSERT((remaining < maxTokenLength) || !entry);
             if (!entry)
                 return IDENT;
@@ -906,7 +906,7 @@ template <bool shouldCreateIdentifier> ALWAYS_INLINE JSTokenType Lexer<UChar>::p
     if (UNLIKELY((remaining < maxTokenLength) && !(lexerFlags & LexerFlagsIgnoreReservedWords)) && !isPrivateName) {
         ASSERT(shouldCreateIdentifier);
         if (remaining < maxTokenLength) {
-            const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
+            const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
             ASSERT((remaining < maxTokenLength) || !entry);
             if (!entry)
                 return IDENT;
@@ -973,7 +973,7 @@ template <bool shouldCreateIdentifier> JSTokenType Lexer<T>::parseIdentifierSlow
         ASSERT(shouldCreateIdentifier);
         // Keywords must not be recognized if there was an \uXXXX in the identifier.
         if (remaining < maxTokenLength) {
-            const HashEntry* entry = m_vm->keywords->getKeyword(*ident);
+            const HashTableValue* entry = m_vm->keywords->getKeyword(*ident);
             ASSERT((remaining < maxTokenLength) || !entry);
             if (!entry)
                 return IDENT;
index 10aecfc..07241ae 100644 (file)
@@ -40,7 +40,7 @@ public:
         return m_keywordTable.entry(m_vm, ident);
     }
     
-    const HashEntry* getKeyword(const Identifier& ident) const
+    const HashTableValue* getKeyword(const Identifier& ident) const
     {
         return m_keywordTable.entry(m_vm, ident);
     }
index 8ff75f4..c87e6c9 100644 (file)
@@ -30,7 +30,6 @@
 
 namespace JSC {
 
-class HashEntry;
 class JSArrayBufferView;
 struct HashTable;
 
index 1f49f0a..d57e261 100644 (file)
@@ -75,19 +75,17 @@ const ClassInfo JSFinalObject::s_info = { "Object", &Base::s_info, 0, 0, CREATE_
 
 static inline void getClassPropertyNames(ExecState* exec, const ClassInfo* classInfo, PropertyNameArray& propertyNames, EnumerationMode mode, bool didReify)
 {
+    VM& vm = exec->vm();
+
     // Add properties from the static hashtables of properties
     for (; classInfo; classInfo = classInfo->parentClass) {
-        const HashTable* table = classInfo->propHashTable(exec);
+        const HashTable* table = classInfo->propHashTable(vm);
         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) || (mode == IncludeDontEnumProperties)) && !((entry->attributes() & BuiltinOrFunction) && didReify))
-                propertyNames.add(entry->key());
+
+        for (auto iter = table->begin(vm); iter != table->end(vm); ++iter) {
+            if ((!(iter->attributes() & DontEnum) || (mode == IncludeDontEnumProperties)) && !((iter->attributes() & BuiltinOrFunction) && didReify))
+                propertyNames.add(iter.key());
         }
     }
 }
@@ -396,7 +394,7 @@ void JSObject::put(JSCell* cell, ExecState* exec, PropertyName propertyName, JSV
         }
         const ClassInfo* info = obj->classInfo();
         if (info->hasStaticSetterOrReadonlyProperties(vm)) {
-            if (const HashEntry* entry = obj->findPropertyHashEntry(vm, propertyName)) {
+            if (const HashTableValue* entry = obj->findPropertyHashEntry(vm, propertyName)) {
                 putEntry(exec, entry, obj, propertyName, value, slot);
                 return;
             }
@@ -1273,7 +1271,7 @@ bool JSObject::deleteProperty(JSCell* cell, ExecState* exec, PropertyName proper
     }
 
     // Look in the static hashtable of properties
-    const HashEntry* entry = thisObject->findPropertyHashEntry(vm, propertyName);
+    const HashTableValue* entry = thisObject->findPropertyHashEntry(vm, propertyName);
     if (entry) {
         if (entry->attributes() & DontDelete && !vm.isInDefineOwnProperty())
             return false; // this builtin property can't be deleted
@@ -1401,11 +1399,11 @@ JSValue JSObject::defaultValue(const JSObject* object, ExecState* exec, Preferre
     return exec->vm().throwException(exec, createTypeError(exec, ASCIILiteral("No default value")));
 }
 
-const HashEntry* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
+const HashTableValue* JSObject::findPropertyHashEntry(VM& vm, PropertyName propertyName) const
 {
     for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
         if (const HashTable* propHashTable = info->propHashTable(vm)) {
-            if (const HashEntry* entry = propHashTable->entry(vm, propertyName))
+            if (const HashTableValue* entry = propHashTable->entry(vm, propertyName))
                 return entry;
         }
     }
@@ -1621,13 +1619,13 @@ void JSObject::reifyStaticFunctionsForDelete(ExecState* exec)
         setStructure(vm, Structure::toUncacheableDictionaryTransition(vm, structure(vm)));
 
     for (const ClassInfo* info = classInfo(); info; info = info->parentClass) {
-        const HashTable* hashTable = info->propHashTable(globalObject()->globalExec());
+        const HashTable* hashTable = info->propHashTable(vm);
         if (!hashTable)
             continue;
         PropertySlot slot(this);
-        for (HashTable::ConstIterator iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
+        for (auto iter = hashTable->begin(vm); iter != hashTable->end(vm); ++iter) {
             if (iter->attributes() & BuiltinOrFunction)
-                setUpStaticFunctionSlot(globalObject()->globalExec(), *iter, this, Identifier(&vm, iter->key()), slot);
+                setUpStaticFunctionSlot(globalObject()->globalExec(), iter.value(), this, Identifier(&vm, iter.key()), slot);
         }
     }
 
index 6a3fe54..985ce28 100644 (file)
@@ -65,7 +65,6 @@ inline JSCell* getCallableObject(JSValue value)
 }
 
 class GetterSetter;
-class HashEntry;
 class InternalFunction;
 class JSFunction;
 class LLIntOffsetsExtractor;
@@ -74,6 +73,7 @@ class PropertyDescriptor;
 class PropertyNameArray;
 class Structure;
 struct HashTable;
+struct HashTableValue;
 
 JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const String&);
 extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError;
@@ -93,7 +93,7 @@ class JSObject : public JSCell {
     friend class JSCell;
     friend class JSFinalObject;
     friend class MarkedBlock;
-    JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject*, PropertyName, PropertySlot&);
+    JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject*, PropertyName, PropertySlot&);
 
     enum PutMode {
         PutModePut,
@@ -952,7 +952,7 @@ private:
     bool inlineGetOwnPropertySlot(ExecState*, VM&, Structure&, PropertyName, PropertySlot&);
     JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, JSValue, unsigned, PropertyOffset);
 
-    const HashEntry* findPropertyHashEntry(VM&, PropertyName) const;
+    const HashTableValue* findPropertyHashEntry(VM&, PropertyName) const;
         
     void putIndexedDescriptor(ExecState*, SparseArrayEntry*, const PropertyDescriptor&, PropertyDescriptor& old);
         
index 197d847..960c0fb 100644 (file)
@@ -28,44 +28,30 @@ namespace JSC {
 
 void HashTable::createTable(VM& vm) const
 {
-    ASSERT(!table);
-    int linkIndex = compactHashSizeMask + 1;
-    HashEntry* entries = new HashEntry[compactSize];
-    for (int i = 0; i < compactSize; ++i)
-        entries[i].setKey(0);
-    for (int i = 0; values[i].key; ++i) {
-        StringImpl& identifier = Identifier::add(&vm, values[i].key).leakRef();
-        int hashIndex = identifier.existingHash() & compactHashSizeMask;
-        HashEntry* entry = &entries[hashIndex];
+    ASSERT(!keys);
+    keys = new StringImpl*[numberOfValues];
 
-        if (entry->key()) {
-            while (entry->next()) {
-                entry = entry->next();
-            }
-            ASSERT(linkIndex < compactSize);
-            entry->setNext(&entries[linkIndex++]);
-            entry = entry->next();
-        }
-
-        entry->initialize(&identifier, values[i].attributes, values[i].value1, values[i].value2, values[i].intrinsic);
+    for (int i = 0; i < numberOfValues; ++i) {
+        if (values[i].m_key)
+            keys[i] = &Identifier::add(&vm, values[i].m_key).leakRef();
+        else
+            keys[i] = 0;
     }
-    table = entries;
 }
 
 void HashTable::deleteTable() const
 {
-    if (table) {
-        int max = compactSize;
-        for (int i = 0; i != max; ++i) {
-            if (StringImpl* key = table[i].key())
-                key->deref();
+    if (keys) {
+        for (int i = 0; i != numberOfValues; ++i) {
+            if (keys[i])
+                keys[i]->deref();
         }
-        delete [] table;
-        table = 0;
+        delete [] keys;
+        keys = nullptr;
     }
 }
 
-bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, PropertyName propertyName, PropertySlot& slot)
+bool setUpStaticFunctionSlot(ExecState* exec, const HashTableValue* entry, JSObject* thisObj, PropertyName propertyName, PropertySlot& slot)
 {
     ASSERT(thisObj->globalObject());
     ASSERT(entry->attributes() & BuiltinOrFunction);
index b5ab998..e5233c5 100644 (file)
 #include <wtf/Assertions.h>
 
 namespace JSC {
-    // Hash table generated by the create_hash_table script.
-    struct HashTableValue {
-        const char* key; // property name
-        unsigned char attributes; // JSObject attributes
-        Intrinsic intrinsic;
-        intptr_t value1;
-        intptr_t value2;
+    struct CompactHashIndex {
+        const int16_t value;
+        const int16_t next;
     };
 
     // FIXME: There is no reason this get function can't be simpler.
@@ -45,21 +41,13 @@ namespace JSC {
     typedef PutPropertySlot::PutValueFunc PutFunction;
     typedef FunctionExecutable* (*BuiltinGenerator)(VM&);
 
-    class HashEntry {
-        WTF_MAKE_FAST_ALLOCATED;
-    public:
-        void initialize(StringImpl* key, unsigned char attributes, intptr_t v1, intptr_t v2, Intrinsic intrinsic)
-        {
-            m_key = key;
-            m_attributes = attributes;
-            m_u.store.value1 = v1;
-            m_u.store.value2 = v2;
-            m_intrinsic = intrinsic;
-            m_next = 0;
-        }
-
-        void setKey(StringImpl* key) { m_key = key; }
-        StringImpl* key() const { return m_key; }
+    // Hash table generated by the create_hash_table script.
+    struct HashTableValue {
+        const char* m_key; // property name
+        unsigned char m_attributes; // JSObject attributes
+        Intrinsic m_intrinsic;
+        intptr_t m_value1;
+        intptr_t m_value2;
 
         unsigned char attributes() const { return m_attributes; }
 
@@ -69,87 +57,55 @@ namespace JSC {
             return m_intrinsic;
         }
 
-        BuiltinGenerator builtinGenerator() const { ASSERT(m_attributes & Builtin); return m_u.builtinGenerator.generatorValue; }
-        NativeFunction function() const { ASSERT(m_attributes & Function); return m_u.function.functionValue; }
-        unsigned char functionLength() const { ASSERT(m_attributes & Function); return static_cast<unsigned char>(m_u.function.length); }
-
-        GetFunction propertyGetter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return m_u.property.get; }
-        PutFunction propertyPutter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return m_u.property.put; }
+        BuiltinGenerator builtinGenerator() const { ASSERT(m_attributes & Builtin); return reinterpret_cast<BuiltinGenerator>(m_value1); }
+        NativeFunction function() const { ASSERT(m_attributes & Function); return reinterpret_cast<NativeFunction>(m_value1); }
+        unsigned char functionLength() const { ASSERT(m_attributes & Function); return static_cast<unsigned char>(m_value2); }
 
-        intptr_t lexerValue() const { ASSERT(!m_attributes); return m_u.lexer.value; }
+        GetFunction propertyGetter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return reinterpret_cast<GetFunction>(m_value1); }
+        PutFunction propertyPutter() const { ASSERT(!(m_attributes & BuiltinOrFunction)); return reinterpret_cast<PutFunction>(m_value2); }
 
-        void setNext(HashEntry *next) { m_next = next; }
-        HashEntry* next() const { return m_next; }
-
-    private:
-        StringImpl* m_key;
-        unsigned char m_attributes; // JSObject attributes
-        Intrinsic m_intrinsic;
-
-        union {
-            struct {
-                intptr_t value1;
-                intptr_t value2;
-            } store;
-            struct {
-                NativeFunction functionValue;
-                intptr_t length; // number of arguments for function
-            } function;
-            struct {
-                BuiltinGenerator generatorValue;
-                intptr_t unused;
-            } builtinGenerator;
-            struct {
-                GetFunction get;
-                PutFunction put;
-            } property;
-            struct {
-                intptr_t value;
-                intptr_t unused;
-            } lexer;
-        } m_u;
-
-        HashEntry* m_next;
+        intptr_t lexerValue() const { ASSERT(!m_attributes); return m_value1; }
     };
 
     struct HashTable {
 
-        int compactSize;
-        int compactHashSizeMask;
+        mutable int numberOfValues;
+        int indexMask;
         bool hasSetterOrReadonlyProperties;
 
         const HashTableValue* values; // Fixed values generated by script.
-        mutable const HashEntry* table; // Table allocated at runtime.
+        mutable StringImpl** keys; // Table allocated at runtime.
+        const CompactHashIndex* index;
 
         ALWAYS_INLINE HashTable copy() const
         {
             // Don't copy dynamic table since it's thread specific.
-            HashTable result = { compactSize, compactHashSizeMask, hasSetterOrReadonlyProperties, values, 0 };
+            HashTable result = { numberOfValues, indexMask, hasSetterOrReadonlyProperties, values, 0, index };
             return result;
         }
 
         ALWAYS_INLINE void initializeIfNeeded(VM& vm) const
         {
-            if (!table)
+            if (!keys)
                 createTable(vm);
         }
 
         ALWAYS_INLINE void initializeIfNeeded(ExecState* exec) const
         {
-            if (!table)
+            if (!keys)
                 createTable(exec->vm());
         }
 
         JS_EXPORT_PRIVATE void deleteTable() const;
 
         // Find an entry in the table, and return the entry.
-        ALWAYS_INLINE const HashEntry* entry(VM& vm, PropertyName identifier) const
+        ALWAYS_INLINE const HashTableValue* entry(VM& vm, PropertyName identifier) const
         {
             initializeIfNeeded(vm);
             return entry(identifier);
         }
 
-        ALWAYS_INLINE const HashEntry* entry(ExecState* exec, PropertyName identifier) const
+        ALWAYS_INLINE const HashTableValue* entry(ExecState* exec, PropertyName identifier) const
         {
             initializeIfNeeded(exec);
             return entry(identifier);
@@ -164,14 +120,19 @@ namespace JSC {
                 skipInvalidKeys();
             }
 
-            const HashEntry* operator->()
+            const HashTableValue* value()
             {
-                return &m_table->table[m_position];
+                return &m_table->values[m_position];
             }
 
-            const HashEntry* operator*()
+            StringImpl* key()
             {
-                return &m_table->table[m_position];
+                return m_table->keys[m_position];
+            }
+
+            const HashTableValue* operator->()
+            {
+                return value();
             }
 
             bool operator!=(const ConstIterator& other)
@@ -182,7 +143,7 @@ namespace JSC {
             
             ConstIterator& operator++()
             {
-                ASSERT(m_position < m_table->compactSize);
+                ASSERT(m_position < m_table->numberOfValues);
                 ++m_position;
                 skipInvalidKeys();
                 return *this;
@@ -191,10 +152,10 @@ namespace JSC {
         private:
             void skipInvalidKeys()
             {
-                ASSERT(m_position <= m_table->compactSize);
-                while (m_position < m_table->compactSize && !m_table->table[m_position].key())
+                ASSERT(m_position <= m_table->numberOfValues);
+                while (m_position < m_table->numberOfValues && !m_table->keys[m_position])
                     ++m_position;
-                ASSERT(m_position <= m_table->compactSize);
+                ASSERT(m_position <= m_table->numberOfValues);
             }
             
             const HashTable* m_table;
@@ -209,37 +170,40 @@ namespace JSC {
         ConstIterator end(VM& vm) const
         {
             initializeIfNeeded(vm);
-            return ConstIterator(this, compactSize);
+            return ConstIterator(this, numberOfValues);
         }
 
     private:
-        ALWAYS_INLINE const HashEntry* entry(PropertyName propertyName) const
+        ALWAYS_INLINE const HashTableValue* entry(PropertyName propertyName) const
         {
             StringImpl* impl = propertyName.uid();
             if (!impl)
                 return 0;
         
-            ASSERT(table);
-
-            const HashEntry* entry = &table[impl->existingHash() & compactHashSizeMask];
+            ASSERT(keys);
 
-            if (!entry->key())
+            int indexEntry = impl->existingHash() & indexMask;
+            int valueIndex = index[indexEntry].value;
+            if (valueIndex == -1)
                 return 0;
 
-            do {
-                if (entry->key() == impl)
-                    return entry;
-                entry = entry->next();
-            } while (entry);
+            while (true) {
+                if (keys[valueIndex] == impl)
+                    return &values[valueIndex];
 
-            return 0;
+                indexEntry = index[indexEntry].next;
+                if (indexEntry == -1)
+                    return nullptr;
+                valueIndex = index[indexEntry].value;
+                ASSERT(valueIndex != -1);
+            };
         }
 
         // Convert the hash table keys to identifiers.
         JS_EXPORT_PRIVATE void createTable(VM&) const;
     };
 
-    JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, PropertyName, PropertySlot&);
+    JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashTableValue*, JSObject* thisObject, PropertyName, PropertySlot&);
 
     /**
      * This method does it all (looking in the hashtable, checking for function
@@ -250,7 +214,7 @@ namespace JSC {
     template <class ThisImp, class ParentImp>
     inline bool getStaticPropertySlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
     {
-        const HashEntry* entry = table.entry(exec, propertyName);
+        const HashTableValue* entry = table.entry(exec, propertyName);
 
         if (!entry) // not found, forward to parent
             return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
@@ -273,7 +237,7 @@ namespace JSC {
         if (ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot))
             return true;
 
-        const HashEntry* entry = table.entry(exec, propertyName);
+        const HashTableValue* entry = table.entry(exec, propertyName);
         if (!entry)
             return false;
 
@@ -287,7 +251,7 @@ namespace JSC {
     template <class ThisImp, class ParentImp>
     inline bool getStaticValueSlot(ExecState* exec, const HashTable& table, ThisImp* thisObj, PropertyName propertyName, PropertySlot& slot)
     {
-        const HashEntry* entry = table.entry(exec, propertyName);
+        const HashTableValue* entry = table.entry(exec, propertyName);
 
         if (!entry) // not found, forward to parent
             return ParentImp::getOwnPropertySlot(thisObj, exec, propertyName, slot);
@@ -298,7 +262,7 @@ namespace JSC {
         return true;
     }
 
-    inline void putEntry(ExecState* exec, const HashEntry* entry, JSObject* base, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
+    inline void putEntry(ExecState* exec, const HashTableValue* entry, JSObject* base, PropertyName propertyName, JSValue value, PutPropertySlot& slot)
     {
         // If this is a function put it as an override property.
         if (entry->attributes() & BuiltinOrFunction) {
@@ -318,7 +282,7 @@ namespace JSC {
      */
     inline bool lookupPut(ExecState* exec, PropertyName propertyName, JSObject* base, JSValue value, const HashTable& table, PutPropertySlot& slot)
     {
-        const HashEntry* entry = table.entry(exec, propertyName);
+        const HashTableValue* entry = table.entry(exec, propertyName);
 
         if (!entry)
             return false;
index cd9123c..3878bf2 100644 (file)
@@ -1,3 +1,34 @@
+2014-03-12  Gavin Barraclough  <barraclough@apple.com>
+
+        Reduce memory use for static property maps
+        https://bugs.webkit.org/show_bug.cgi?id=129986
+
+        Reviewed by Andreas Kling.
+
+        Static property tables are currently duplicated on first use from read-only memory into dirty memory
+        in every process, and since the entries are large (48 bytes) and the tables can be unusually sparse
+        (we use a custom hash table without a rehash) a lot of memory may be wasted.
+
+        * bindings/js/JSDOMBinding.h:
+        (WebCore::getStaticValueSlotEntryWithoutCaching):
+        (WebCore::getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>):
+            - HashEntry -> HashTableValue.
+        * bindings/js/JSDOMWindowCustom.cpp:
+        (WebCore::JSDOMWindow::getOwnPropertySlot):
+            - HashEntry -> HashTableValue.
+        * bindings/js/JSHistoryCustom.cpp:
+        (WebCore::JSHistory::getOwnPropertySlotDelegate):
+            - HashEntry -> HashTableValue.
+        * bindings/js/JSLocationCustom.cpp:
+        (WebCore::JSLocation::getOwnPropertySlotDelegate):
+        (WebCore::JSLocation::putDelegate):
+            - HashEntry -> HashTableValue.
+        * bindings/scripts/CodeGeneratorJS.pm:
+        (GenerateGetOwnPropertySlotBody):
+            - HashEntry -> HashTableValue.
+        (GenerateHashTable):
+            - emit the hash table index into the derived source (we were calculating this already to ensure chaining does not get too deep).
+
 2014-03-13  Manish R Gurnaney  <m.gurnaney@samsung.com>
 
         Scroll size is not recalculated when absolute left of child is updated
index a60e64a..41224a3 100644 (file)
@@ -601,19 +601,19 @@ inline AtomicString propertyNameToAtomicString(JSC::PropertyName propertyName)
 }
 
 template <class ThisImp>
-inline const JSC::HashEntry* getStaticValueSlotEntryWithoutCaching(JSC::ExecState* exec, JSC::PropertyName propertyName)
+inline const JSC::HashTableValue* getStaticValueSlotEntryWithoutCaching(JSC::ExecState* exec, JSC::PropertyName propertyName)
 {
     const JSC::HashTable* table = ThisImp::info()->propHashTable(exec);
     if (!table)
         return getStaticValueSlotEntryWithoutCaching<typename ThisImp::Base>(exec, propertyName);
-    const JSC::HashEntry* entry = table->entry(exec, propertyName);
+    const JSC::HashTableValue* entry = table->entry(exec, propertyName);
     if (!entry) // not found, forward to parent
         return getStaticValueSlotEntryWithoutCaching<typename ThisImp::Base>(exec, propertyName);
     return entry;
 }
 
 template <>
-inline const JSC::HashEntry* getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>(JSC::ExecState*, JSC::PropertyName)
+inline const JSC::HashTableValue* getStaticValueSlotEntryWithoutCaching<JSDOMWrapper>(JSC::ExecState*, JSC::PropertyName)
 {
     return 0;
 }
index b2ec8b5..e926319 100644 (file)
@@ -116,7 +116,7 @@ bool JSDOMWindow::getOwnPropertySlot(JSObject* object, ExecState* exec, Property
     // are not affected by properties changed on the Window or anything in its prototype chain.
     // This is consistent with the behavior of Firefox.
 
-    const HashEntry* entry;
+    const HashTableValue* entry;
 
     // We don't want any properties other than "close" and "closed" on a frameless window (i.e. one whose page got closed,
     // or whose iframe got removed).
index 071f30b..4902cb8 100644 (file)
@@ -66,7 +66,7 @@ bool JSHistory::getOwnPropertySlotDelegate(ExecState* exec, PropertyName propert
 
     // Check for the few functions that we allow, even when called cross-domain.
     // Make these read-only / non-configurable to prevent writes via defineProperty.
-    const HashEntry* entry = JSHistoryPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
+    const HashTableValue* entry = JSHistoryPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
     if (entry) {
         // Allow access to back(), forward() and go() from any frame.
         if (entry->attributes() & JSC::Function) {
index 500ade0..9b606b2 100644 (file)
@@ -64,7 +64,7 @@ bool JSLocation::getOwnPropertySlotDelegate(ExecState* exec, PropertyName proper
 
     // Check for the few functions that we allow, even when called cross-domain.
     // Make these read-only / non-configurable to prevent writes via defineProperty.
-    const HashEntry* entry = JSLocationPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
+    const HashTableValue* entry = JSLocationPrototype::info()->propHashTable(exec)->entry(exec, propertyName);
     if (entry && (entry->attributes() & JSC::Function)) {
         if (entry->function() == jsLocationPrototypeFunctionReplace) {
             slot.setCustom(this, ReadOnly | DontDelete | DontEnum, nonCachingStaticReplaceFunctionGetter);
@@ -98,7 +98,7 @@ bool JSLocation::putDelegate(ExecState* exec, PropertyName propertyName, JSValue
 
     bool sameDomainAccess = shouldAllowAccessToFrame(exec, frame);
 
-    const HashEntry* entry = JSLocation::info()->propHashTable(exec)->entry(exec, propertyName);
+    const HashTableValue* entry = JSLocation::info()->propHashTable(exec)->entry(exec, propertyName);
     if (!entry) {
         if (sameDomainAccess)
             JSObject::put(this, exec, propertyName, value, slot);
index 4dc55ba..9f9a8d3 100644 (file)
@@ -405,7 +405,7 @@ sub GenerateGetOwnPropertySlotBody
     my $manualLookupGetterGeneration = sub {
         my $requiresManualLookup = ($indexedGetterFunction && !$hasNumericIndexedGetter) || $namedGetterFunction;
         if ($requiresManualLookup) {
-            push(@getOwnPropertySlotImpl, "    const ${namespaceMaybe}HashEntry* entry = getStaticValueSlotEntryWithoutCaching<$className>(exec, propertyName);\n");
+            push(@getOwnPropertySlotImpl, "    const ${namespaceMaybe}HashTableValue* entry = getStaticValueSlotEntryWithoutCaching<$className>(exec, propertyName);\n");
             push(@getOwnPropertySlotImpl, "    if (entry) {\n");
             push(@getOwnPropertySlotImpl, "        slot.setCustom(thisObject, entry->attributes(), entry->propertyGetter());\n");
             push(@getOwnPropertySlotImpl, "        return true;\n");
@@ -4024,9 +4024,16 @@ sub GenerateHashTable
         $maxDepth = $depth if ($depth > $maxDepth);
     }
 
+    push(@implContent, "#if COMPILER(MSVC)\n");
+    push(@implContent, "#pragma warning(push)\n");
+    push(@implContent, "#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning\n");
+    push(@implContent, "#endif\n");
+
     # Start outputing the hashtables
     my $nameEntries = "${name}Values";
     $nameEntries =~ s/:/_/g;
+    my $nameIndex = "${name}Index";
+    $nameIndex =~ s/:/_/g;
     my $hasSetter = "false";
 
     if (($name =~ /Prototype/) or ($name =~ /Constructor/)) {
@@ -4046,8 +4053,19 @@ sub GenerateHashTable
         push(@implContent, "/* Hash table */\n");
     }
 
+    push(@implContent, "\nstatic const struct CompactHashIndex ${nameIndex}\[$compactSize\] = {\n");
+    for (my $i = 0; $i < $compactSize; $i++) {
+        my $T = -1;
+        if (defined($table[$i])) { $T = $table[$i]; }
+        my $L = -1;
+        if (defined($links[$i])) { $L = $links[$i]; }
+        push(@implContent, "    { $T, $L },\n");
+    }
+    push(@implContent, "};\n\n");
+
     # Dump the hash table
-    push(@implContent, "\nstatic const HashTableValue $nameEntries\[\] =\n\{\n");
+    my $packedSize = scalar @{$keys};
+    push(@implContent, "\nstatic const HashTableValue $nameEntries\[$packedSize\] =\n\{\n");
     $i = 0;
     foreach my $key (@{$keys}) {
         my $conditional;
@@ -4070,14 +4088,21 @@ sub GenerateHashTable
             $hasSetter = "true";
         }
         push(@implContent, "    { \"$key\", @$specials[$i], NoIntrinsic, (intptr_t)" . $firstTargetType . "(@$value1[$i]), (intptr_t) " . $secondTargetType . "(@$value2[$i]) },\n");
-        push(@implContent, "#endif\n") if $conditional;
+        if ($conditional) {
+            push(@implContent, "#else\n") ;
+            push(@implContent, "    { 0, 0, NoIntrinsic, 0, 0 },\n");
+            push(@implContent, "#endif\n") ;
+        }
         ++$i;
     }
 
-    push(@implContent, "    { 0, 0, NoIntrinsic, 0, 0 }\n");
     push(@implContent, "};\n\n");
     my $compactSizeMask = $numEntries - 1;
-    push(@implContent, "static const HashTable $name = { $compactSize, $compactSizeMask, $hasSetter, $nameEntries, 0 };\n");
+    push(@implContent, "static const HashTable $name = { $packedSize, $compactSizeMask, $hasSetter, $nameEntries, 0, $nameIndex };\n");
+
+    push(@implContent, "#if COMPILER(MSVC)\n");
+    push(@implContent, "#pragma warning(pop)\n");
+    push(@implContent, "#endif\n");
 }
 
 sub WriteData
index 40c4b6c..fab6a28 100644 (file)
@@ -33,24 +33,49 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestActiveDOMObjectTableValues[] =
+static const struct CompactHashIndex JSTestActiveDOMObjectTableIndex[4] = {
+    { 1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestActiveDOMObjectTableValues[2] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestActiveDOMObjectConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "excitingAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestActiveDOMObjectExcitingAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestActiveDOMObjectTable = { 4, 3, true, JSTestActiveDOMObjectTableValues, 0 };
+static const HashTable JSTestActiveDOMObjectTable = { 2, 3, true, JSTestActiveDOMObjectTableValues, 0, JSTestActiveDOMObjectTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestActiveDOMObjectConstructorTableValues[] =
+static const struct CompactHashIndex JSTestActiveDOMObjectConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestActiveDOMObjectConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestActiveDOMObjectConstructorTable = { 1, 0, false, JSTestActiveDOMObjectConstructorTableValues, 0 };
+static const HashTable JSTestActiveDOMObjectConstructorTable = { 0, 0, false, JSTestActiveDOMObjectConstructorTableValues, 0, JSTestActiveDOMObjectConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestActiveDOMObjectConstructor::s_info = { "TestActiveDOMObjectConstructor", &Base::s_info, &JSTestActiveDOMObjectConstructorTable, 0, CREATE_METHOD_TABLE(JSTestActiveDOMObjectConstructor) };
 
 JSTestActiveDOMObjectConstructor::JSTestActiveDOMObjectConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -71,16 +96,30 @@ bool JSTestActiveDOMObjectConstructor::getOwnPropertySlot(JSObject* object, Exec
     return getStaticValueSlot<JSTestActiveDOMObjectConstructor, JSDOMWrapper>(exec, JSTestActiveDOMObjectConstructorTable, jsCast<JSTestActiveDOMObjectConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestActiveDOMObjectPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestActiveDOMObjectPrototypeTableIndex[4] = {
+    { 0, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestActiveDOMObjectPrototypeTableValues[2] =
 {
     { "excitingFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestActiveDOMObjectPrototypeFunctionExcitingFunction), (intptr_t) (1) },
     { "postMessage", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestActiveDOMObjectPrototypeFunctionPostMessage), (intptr_t) (1) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestActiveDOMObjectPrototypeTable = { 4, 3, false, JSTestActiveDOMObjectPrototypeTableValues, 0 };
+static const HashTable JSTestActiveDOMObjectPrototypeTable = { 2, 3, false, JSTestActiveDOMObjectPrototypeTableValues, 0, JSTestActiveDOMObjectPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestActiveDOMObjectPrototype::s_info = { "TestActiveDOMObjectPrototype", &Base::s_info, &JSTestActiveDOMObjectPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestActiveDOMObjectPrototype) };
 
 JSObject* JSTestActiveDOMObjectPrototype::self(VM& vm, JSGlobalObject* globalObject)
index da1f0d2..baf3003 100644 (file)
@@ -32,23 +32,46 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestCustomNamedGetterTableValues[] =
+static const struct CompactHashIndex JSTestCustomNamedGetterTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestCustomNamedGetterTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestCustomNamedGetterConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestCustomNamedGetterTable = { 2, 1, true, JSTestCustomNamedGetterTableValues, 0 };
+static const HashTable JSTestCustomNamedGetterTable = { 1, 1, true, JSTestCustomNamedGetterTableValues, 0, JSTestCustomNamedGetterTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestCustomNamedGetterConstructorTableValues[] =
+static const struct CompactHashIndex JSTestCustomNamedGetterConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestCustomNamedGetterConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestCustomNamedGetterConstructorTable = { 1, 0, false, JSTestCustomNamedGetterConstructorTableValues, 0 };
+static const HashTable JSTestCustomNamedGetterConstructorTable = { 0, 0, false, JSTestCustomNamedGetterConstructorTableValues, 0, JSTestCustomNamedGetterConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestCustomNamedGetterConstructor::s_info = { "TestCustomNamedGetterConstructor", &Base::s_info, &JSTestCustomNamedGetterConstructorTable, 0, CREATE_METHOD_TABLE(JSTestCustomNamedGetterConstructor) };
 
 JSTestCustomNamedGetterConstructor::JSTestCustomNamedGetterConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -69,15 +92,27 @@ bool JSTestCustomNamedGetterConstructor::getOwnPropertySlot(JSObject* object, Ex
     return getStaticValueSlot<JSTestCustomNamedGetterConstructor, JSDOMWrapper>(exec, JSTestCustomNamedGetterConstructorTable, jsCast<JSTestCustomNamedGetterConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestCustomNamedGetterPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestCustomNamedGetterPrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestCustomNamedGetterPrototypeTableValues[1] =
 {
     { "anotherFunction", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestCustomNamedGetterPrototypeFunctionAnotherFunction), (intptr_t) (1) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestCustomNamedGetterPrototypeTable = { 2, 1, false, JSTestCustomNamedGetterPrototypeTableValues, 0 };
+static const HashTable JSTestCustomNamedGetterPrototypeTable = { 1, 1, false, JSTestCustomNamedGetterPrototypeTableValues, 0, JSTestCustomNamedGetterPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestCustomNamedGetterPrototype::s_info = { "TestCustomNamedGetterPrototype", &Base::s_info, &JSTestCustomNamedGetterPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestCustomNamedGetterPrototype) };
 
 JSObject* JSTestCustomNamedGetterPrototype::self(VM& vm, JSGlobalObject* globalObject)
index a5d94f3..0bea3d8 100644 (file)
@@ -33,14 +33,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestEventConstructorConstructorTableValues[] =
+static const struct CompactHashIndex JSTestEventConstructorConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestEventConstructorConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestEventConstructorConstructorTable = { 1, 0, false, JSTestEventConstructorConstructorTableValues, 0 };
+static const HashTable JSTestEventConstructorConstructorTable = { 0, 0, false, JSTestEventConstructorConstructorTableValues, 0, JSTestEventConstructorConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 EncodedJSValue JSC_HOST_CALL JSTestEventConstructorConstructor::constructJSTestEventConstructor(ExecState* exec)
 {
     JSTestEventConstructorConstructor* jsConstructor = jsCast<JSTestEventConstructorConstructor*>(exec->callee());
@@ -105,17 +116,36 @@ ConstructType JSTestEventConstructorConstructor::getConstructData(JSCell*, Const
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestEventConstructorPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestEventConstructorPrototypeTableIndex[9] = {
+    { -1, -1 },
+    { 0, 8 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 2, -1 },
+};
+
+
+static const HashTableValue JSTestEventConstructorPrototypeTableValues[3] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "attr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "attr2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventConstructorAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestEventConstructorPrototypeTable = { 9, 7, true, JSTestEventConstructorPrototypeTableValues, 0 };
+static const HashTable JSTestEventConstructorPrototypeTable = { 3, 7, true, JSTestEventConstructorPrototypeTableValues, 0, JSTestEventConstructorPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestEventConstructorPrototype::s_info = { "TestEventConstructorPrototype", &Base::s_info, &JSTestEventConstructorPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestEventConstructorPrototype) };
 
 JSObject* JSTestEventConstructorPrototype::self(VM& vm, JSGlobalObject* globalObject)
index 4f4b566..0df1412 100644 (file)
@@ -38,23 +38,46 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestEventTargetTableValues[] =
+static const struct CompactHashIndex JSTestEventTargetTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestEventTargetTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestEventTargetConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestEventTargetTable = { 2, 1, true, JSTestEventTargetTableValues, 0 };
+static const HashTable JSTestEventTargetTable = { 1, 1, true, JSTestEventTargetTableValues, 0, JSTestEventTargetTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestEventTargetConstructorTableValues[] =
+static const struct CompactHashIndex JSTestEventTargetConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestEventTargetConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestEventTargetConstructorTable = { 1, 0, false, JSTestEventTargetConstructorTableValues, 0 };
+static const HashTable JSTestEventTargetConstructorTable = { 0, 0, false, JSTestEventTargetConstructorTableValues, 0, JSTestEventTargetConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestEventTargetConstructor::s_info = { "TestEventTargetConstructor", &Base::s_info, &JSTestEventTargetConstructorTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetConstructor) };
 
 JSTestEventTargetConstructor::JSTestEventTargetConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -75,18 +98,36 @@ bool JSTestEventTargetConstructor::getOwnPropertySlot(JSObject* object, ExecStat
     return getStaticValueSlot<JSTestEventTargetConstructor, JSDOMWrapper>(exec, JSTestEventTargetConstructorTable, jsCast<JSTestEventTargetConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestEventTargetPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestEventTargetPrototypeTableIndex[8] = {
+    { 2, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 3, -1 },
+    { 1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestEventTargetPrototypeTableValues[4] =
 {
     { "item", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionItem), (intptr_t) (1) },
     { "addEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionAddEventListener), (intptr_t) (2) },
     { "removeEventListener", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionRemoveEventListener), (intptr_t) (2) },
     { "dispatchEvent", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestEventTargetPrototypeFunctionDispatchEvent), (intptr_t) (1) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestEventTargetPrototypeTable = { 8, 7, false, JSTestEventTargetPrototypeTableValues, 0 };
+static const HashTable JSTestEventTargetPrototypeTable = { 4, 7, false, JSTestEventTargetPrototypeTableValues, 0, JSTestEventTargetPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestEventTargetPrototype::s_info = { "TestEventTargetPrototype", &Base::s_info, &JSTestEventTargetPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestEventTargetPrototype) };
 
 JSObject* JSTestEventTargetPrototype::self(VM& vm, JSGlobalObject* globalObject)
@@ -134,7 +175,7 @@ bool JSTestEventTarget::getOwnPropertySlot(JSObject* object, ExecState* exec, Pr
 {
     JSTestEventTarget* thisObject = jsCast<JSTestEventTarget*>(object);
     ASSERT_GC_OBJECT_INHERITS(thisObject, info());
-    const HashEntry* entry = getStaticValueSlotEntryWithoutCaching<JSTestEventTarget>(exec, propertyName);
+    const HashTableValue* entry = getStaticValueSlotEntryWithoutCaching<JSTestEventTarget>(exec, propertyName);
     if (entry) {
         slot.setCustom(thisObject, entry->attributes(), entry->propertyGetter());
         return true;
@@ -210,7 +251,8 @@ EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionItem(ExecState* e
     }
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.item(index)));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.item(index)));
     return JSValue::encode(result);
 }
 
@@ -258,8 +300,8 @@ EncodedJSValue JSC_HOST_CALL jsTestEventTargetPrototypeFunctionDispatchEvent(Exe
     Event* evt(toEvent(exec->argument(0)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsBoolean(impl.dispatchEvent(evt, ec));
 
+    JSC::JSValue result = jsBoolean(impl.dispatchEvent(evt, ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
index d4cf493..94776b0 100644 (file)
@@ -31,23 +31,46 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestExceptionTableValues[] =
+static const struct CompactHashIndex JSTestExceptionTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestExceptionTableValues[1] =
 {
     { "name", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionName), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestExceptionTable = { 2, 1, true, JSTestExceptionTableValues, 0 };
+static const HashTable JSTestExceptionTable = { 1, 1, true, JSTestExceptionTableValues, 0, JSTestExceptionTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestExceptionConstructorTableValues[] =
+static const struct CompactHashIndex JSTestExceptionConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestExceptionConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestExceptionConstructorTable = { 1, 0, false, JSTestExceptionConstructorTableValues, 0 };
+static const HashTable JSTestExceptionConstructorTable = { 0, 0, false, JSTestExceptionConstructorTableValues, 0, JSTestExceptionConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestExceptionConstructor::s_info = { "TestExceptionConstructor", &Base::s_info, &JSTestExceptionConstructorTable, 0, CREATE_METHOD_TABLE(JSTestExceptionConstructor) };
 
 JSTestExceptionConstructor::JSTestExceptionConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -68,15 +91,27 @@ bool JSTestExceptionConstructor::getOwnPropertySlot(JSObject* object, ExecState*
     return getStaticValueSlot<JSTestExceptionConstructor, JSDOMWrapper>(exec, JSTestExceptionConstructorTable, jsCast<JSTestExceptionConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestExceptionPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestExceptionPrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestExceptionPrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestExceptionConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestExceptionPrototypeTable = { 2, 1, true, JSTestExceptionPrototypeTableValues, 0 };
+static const HashTable JSTestExceptionPrototypeTable = { 1, 1, true, JSTestExceptionPrototypeTableValues, 0, JSTestExceptionPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestExceptionPrototype::s_info = { "TestExceptionPrototype", &Base::s_info, &JSTestExceptionPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestExceptionPrototype) };
 
 JSObject* JSTestExceptionPrototype::self(VM& vm, JSGlobalObject* globalObject)
index 0a3868d..a3d30a8 100644 (file)
@@ -28,14 +28,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestGenerateIsReachableConstructorTableValues[] =
+static const struct CompactHashIndex JSTestGenerateIsReachableConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestGenerateIsReachableConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestGenerateIsReachableConstructorTable = { 1, 0, false, JSTestGenerateIsReachableConstructorTableValues, 0 };
+static const HashTable JSTestGenerateIsReachableConstructorTable = { 0, 0, false, JSTestGenerateIsReachableConstructorTableValues, 0, JSTestGenerateIsReachableConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestGenerateIsReachableConstructor::s_info = { "TestGenerateIsReachableConstructor", &Base::s_info, &JSTestGenerateIsReachableConstructorTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachableConstructor) };
 
 JSTestGenerateIsReachableConstructor::JSTestGenerateIsReachableConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -56,15 +67,27 @@ bool JSTestGenerateIsReachableConstructor::getOwnPropertySlot(JSObject* object,
     return getStaticValueSlot<JSTestGenerateIsReachableConstructor, JSDOMWrapper>(exec, JSTestGenerateIsReachableConstructorTable, jsCast<JSTestGenerateIsReachableConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestGenerateIsReachablePrototypeTableValues[] =
+static const struct CompactHashIndex JSTestGenerateIsReachablePrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestGenerateIsReachablePrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestGenerateIsReachableConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestGenerateIsReachablePrototypeTable = { 2, 1, true, JSTestGenerateIsReachablePrototypeTableValues, 0 };
+static const HashTable JSTestGenerateIsReachablePrototypeTable = { 1, 1, true, JSTestGenerateIsReachablePrototypeTableValues, 0, JSTestGenerateIsReachablePrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestGenerateIsReachablePrototype::s_info = { "TestGenerateIsReachablePrototype", &Base::s_info, &JSTestGenerateIsReachablePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestGenerateIsReachablePrototype) };
 
 JSObject* JSTestGenerateIsReachablePrototype::self(VM& vm, JSGlobalObject* globalObject)
index e305d51..0af09ac 100644 (file)
@@ -48,58 +48,117 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestInterfaceTableValues[] =
+static const struct CompactHashIndex JSTestInterfaceTableIndex[4] = {
+    { -1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { 1, -1 },
+};
+
+
+static const HashTableValue JSTestInterfaceTableValues[2] =
 {
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr3) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalStr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr3) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestInterfaceTable = { 4, 3, true, JSTestInterfaceTableValues, 0 };
+static const HashTable JSTestInterfaceTable = { 2, 3, true, JSTestInterfaceTableValues, 0, JSTestInterfaceTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestInterfaceConstructorTableValues[] =
+static const struct CompactHashIndex JSTestInterfaceConstructorTableIndex[11] = {
+    { 8, -1 },
+    { 5, -1 },
+    { -1, -1 },
+    { 0, 9 },
+    { 6, 10 },
+    { 7, -1 },
+    { 2, -1 },
+    { 1, 8 },
+    { 3, -1 },
+    { 4, -1 },
+    { 9, -1 },
+};
+
+
+static const HashTableValue JSTestInterfaceConstructorTableValues[10] =
 {
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorImplementsStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorImplementsStaticAttr) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalStaticReadOnlyAttr", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticReadOnlyAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalStaticAttr", DontDelete, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructorSupplementalStaticAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceConstructorSupplementalStaticAttr) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionImplementsMethod4), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalMethod4", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfaceConstructorFunctionSupplementalMethod4), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestInterfaceConstructorTable = { 11, 7, true, JSTestInterfaceConstructorTableValues, 0 };
+static const HashTable JSTestInterfaceConstructorTable = { 10, 7, true, JSTestInterfaceConstructorTableValues, 0, JSTestInterfaceConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 
 #if ENABLE(Condition22) || ENABLE(Condition23)
 COMPILE_ASSERT(1 == TestInterface::IMPLEMENTSCONSTANT1, TestInterfaceEnumIMPLEMENTSCONSTANT1IsWrongUseDoNotCheckConstants);
@@ -165,63 +224,170 @@ ConstructType JSTestInterfaceConstructor::getConstructData(JSCell*, ConstructDat
 }
 #endif // ENABLE(TEST_INTERFACE)
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestInterfacePrototypeTableValues[] =
+static const struct CompactHashIndex JSTestInterfacePrototypeTableIndex[65] = {
+    { -1, -1 },
+    { 3, 64 },
+    { 14, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 13, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 10, -1 },
+    { -1, -1 },
+    { 5, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 4, -1 },
+    { -1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { 7, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 15, -1 },
+    { 1, -1 },
+    { 6, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 11, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 8, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 16, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 2, -1 },
+    { 9, -1 },
+    { -1, -1 },
+    { 12, -1 },
+};
+
+
+static const HashTableValue JSTestInterfacePrototypeTableValues[17] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsStr2) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceImplementsNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceImplementsNode) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalStr1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalStr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalStr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalStr2) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalNode", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSupplementalNode), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestInterfaceSupplementalNode) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "IMPLEMENTSCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "IMPLEMENTSCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceIMPLEMENTSCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "SUPPLEMENTALCONSTANT1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "SUPPLEMENTALCONSTANT2", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestInterfaceSUPPLEMENTALCONSTANT2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod1), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod2), (intptr_t) (2) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition22) || ENABLE(Condition23)
     { "implementsMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionImplementsMethod3), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod1), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod2), (intptr_t) (2) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition11) || ENABLE(Condition12)
     { "supplementalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestInterfacePrototypeFunctionSupplementalMethod3), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestInterfacePrototypeTable = { 65, 63, true, JSTestInterfacePrototypeTableValues, 0 };
+static const HashTable JSTestInterfacePrototypeTable = { 17, 63, true, JSTestInterfacePrototypeTableValues, 0, JSTestInterfacePrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestInterfacePrototype::s_info = { "TestInterfacePrototype", &Base::s_info, &JSTestInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestInterfacePrototype) };
 
 JSObject* JSTestInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
@@ -685,8 +851,8 @@ EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionImplementsMethod2(E
     TestObj* objArg(toTestObj(exec->argument(1)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.implementsMethod2(scriptContext, strArg, objArg, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -751,8 +917,8 @@ EncodedJSValue JSC_HOST_CALL jsTestInterfacePrototypeFunctionSupplementalMethod2
     TestObj* objArg(toTestObj(exec->argument(1)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(TestSupplemental::supplementalMethod2(&impl, scriptContext, strArg, objArg, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
index 09113bd..697b884 100644 (file)
@@ -32,14 +32,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestMediaQueryListListenerConstructorTableValues[] =
+static const struct CompactHashIndex JSTestMediaQueryListListenerConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestMediaQueryListListenerConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestMediaQueryListListenerConstructorTable = { 1, 0, false, JSTestMediaQueryListListenerConstructorTableValues, 0 };
+static const HashTable JSTestMediaQueryListListenerConstructorTable = { 0, 0, false, JSTestMediaQueryListListenerConstructorTableValues, 0, JSTestMediaQueryListListenerConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestMediaQueryListListenerConstructor::s_info = { "TestMediaQueryListListenerConstructor", &Base::s_info, &JSTestMediaQueryListListenerConstructorTable, 0, CREATE_METHOD_TABLE(JSTestMediaQueryListListenerConstructor) };
 
 JSTestMediaQueryListListenerConstructor::JSTestMediaQueryListListenerConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -60,16 +71,30 @@ bool JSTestMediaQueryListListenerConstructor::getOwnPropertySlot(JSObject* objec
     return getStaticValueSlot<JSTestMediaQueryListListenerConstructor, JSDOMWrapper>(exec, JSTestMediaQueryListListenerConstructorTable, jsCast<JSTestMediaQueryListListenerConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestMediaQueryListListenerPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestMediaQueryListListenerPrototypeTableIndex[4] = {
+    { 1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestMediaQueryListListenerPrototypeTableValues[2] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestMediaQueryListListenerConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "method", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestMediaQueryListListenerPrototypeFunctionMethod), (intptr_t) (1) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestMediaQueryListListenerPrototypeTable = { 4, 3, true, JSTestMediaQueryListListenerPrototypeTableValues, 0 };
+static const HashTable JSTestMediaQueryListListenerPrototypeTable = { 2, 3, true, JSTestMediaQueryListListenerPrototypeTableValues, 0, JSTestMediaQueryListListenerPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestMediaQueryListListenerPrototype::s_info = { "TestMediaQueryListListenerPrototype", &Base::s_info, &JSTestMediaQueryListListenerPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestMediaQueryListListenerPrototype) };
 
 JSObject* JSTestMediaQueryListListenerPrototype::self(VM& vm, JSGlobalObject* globalObject)
index a5fd369..6e399fd 100644 (file)
@@ -31,14 +31,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestNamedConstructorConstructorTableValues[] =
+static const struct CompactHashIndex JSTestNamedConstructorConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestNamedConstructorConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestNamedConstructorConstructorTable = { 1, 0, false, JSTestNamedConstructorConstructorTableValues, 0 };
+static const HashTable JSTestNamedConstructorConstructorTable = { 0, 0, false, JSTestNamedConstructorConstructorTableValues, 0, JSTestNamedConstructorConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestNamedConstructorConstructor::s_info = { "TestNamedConstructorConstructor", &Base::s_info, &JSTestNamedConstructorConstructorTable, 0, CREATE_METHOD_TABLE(JSTestNamedConstructorConstructor) };
 
 JSTestNamedConstructorConstructor::JSTestNamedConstructorConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -103,15 +114,27 @@ ConstructType JSTestNamedConstructorNamedConstructor::getConstructData(JSCell*,
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestNamedConstructorPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestNamedConstructorPrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestNamedConstructorPrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNamedConstructorConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestNamedConstructorPrototypeTable = { 2, 1, true, JSTestNamedConstructorPrototypeTableValues, 0 };
+static const HashTable JSTestNamedConstructorPrototypeTable = { 1, 1, true, JSTestNamedConstructorPrototypeTableValues, 0, JSTestNamedConstructorPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestNamedConstructorPrototype::s_info = { "TestNamedConstructorPrototype", &Base::s_info, &JSTestNamedConstructorPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestNamedConstructorPrototype) };
 
 JSObject* JSTestNamedConstructorPrototype::self(VM& vm, JSGlobalObject* globalObject)
index 75152c6..160329c 100644 (file)
@@ -31,14 +31,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestNodeConstructorTableValues[] =
+static const struct CompactHashIndex JSTestNodeConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestNodeConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestNodeConstructorTable = { 1, 0, false, JSTestNodeConstructorTableValues, 0 };
+static const HashTable JSTestNodeConstructorTable = { 0, 0, false, JSTestNodeConstructorTableValues, 0, JSTestNodeConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 EncodedJSValue JSC_HOST_CALL JSTestNodeConstructor::constructJSTestNode(ExecState* exec)
 {
     JSTestNodeConstructor* castedThis = jsCast<JSTestNodeConstructor*>(exec->callee());
@@ -72,15 +83,27 @@ ConstructType JSTestNodeConstructor::getConstructData(JSCell*, ConstructData& co
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestNodePrototypeTableValues[] =
+static const struct CompactHashIndex JSTestNodePrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestNodePrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestNodeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestNodePrototypeTable = { 2, 1, true, JSTestNodePrototypeTableValues, 0 };
+static const HashTable JSTestNodePrototypeTable = { 1, 1, true, JSTestNodePrototypeTableValues, 0, JSTestNodePrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestNodePrototype::s_info = { "TestNodePrototype", &Base::s_info, &JSTestNodePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestNodePrototype) };
 
 JSObject* JSTestNodePrototype::self(VM& vm, JSGlobalObject* globalObject)
index 71f4bef..a94ae74 100644 (file)
@@ -74,32 +74,114 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestObjTableValues[] =
+static const struct CompactHashIndex JSTestObjTableIndex[17] = {
+    { 5, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 4, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 2, -1 },
+    { 0, 16 },
+    { -1, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 3, -1 },
+};
+
+
+static const HashTableValue JSTestObjTableValues[6] =
 {
     { "TestSubObjEnabledBySetting", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjTestSubObjEnabledBySettingConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjTestSubObjEnabledBySettingConstructor) },
     { "customAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCustomAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjCustomAttr) },
 #if ENABLE(Condition1)
     { "conditionalAttr4", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr4Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr4Constructor) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) && ENABLE(Condition2)
     { "conditionalAttr5", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr5Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr5Constructor) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) || ENABLE(Condition2)
     { "conditionalAttr6", DontEnum, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr6Constructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr6Constructor) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
     { "contentDocument", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjContentDocument), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestObjTable = { 17, 15, true, JSTestObjTableValues, 0 };
+static const HashTable JSTestObjTable = { 6, 15, true, JSTestObjTableValues, 0, JSTestObjTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestObjConstructorTableValues[] =
+static const struct CompactHashIndex JSTestObjConstructorTableIndex[39] = {
+    { -1, -1 },
+    { 9, 34 },
+    { 21, -1 },
+    { 2, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 0, -1 },
+    { 12, -1 },
+    { 16, -1 },
+    { 5, 32 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 10, -1 },
+    { 7, 36 },
+    { 15, -1 },
+    { 3, -1 },
+    { -1, -1 },
+    { 11, 33 },
+    { -1, -1 },
+    { -1, -1 },
+    { 8, 37 },
+    { 18, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 4, -1 },
+    { 6, -1 },
+    { 13, -1 },
+    { 14, 35 },
+    { 17, -1 },
+    { 19, 38 },
+    { 20, -1 },
+    { 22, -1 },
+};
+
+
+static const HashTableValue JSTestObjConstructorTableValues[23] =
 {
 #if ENABLE(Condition1)
     { "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
     { "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
@@ -124,11 +206,15 @@ static const HashTableValue JSTestObjConstructorTableValues[] =
     { "classMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionClassMethod2), (intptr_t) (1) },
 #if ENABLE(Condition1)
     { "overloadedMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjConstructorFunctionOverloadedMethod1), (intptr_t) (1) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestObjConstructorTable = { 39, 31, true, JSTestObjConstructorTableValues, 0 };
+static const HashTable JSTestObjConstructorTable = { 23, 31, true, JSTestObjConstructorTableValues, 0, JSTestObjConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 
 #if ENABLE(Condition1)
 COMPILE_ASSERT(0 == TestObj::CONDITIONAL_CONST, TestObjEnumCONDITIONAL_CONSTIsWrongUseDoNotCheckConstants);
@@ -185,9 +271,547 @@ ConstructType JSTestObjConstructor::getConstructData(JSCell*, ConstructData& con
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestObjPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestObjPrototypeTableIndex[530] = {
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 23, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 49, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 16, 513 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 47, -1 },
+    { 73, -1 },
+    { -1, -1 },
+    { 41, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 102, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 15, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 110, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 27, 522 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 126, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 101, -1 },
+    { 100, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 4, -1 },
+    { -1, -1 },
+    { 17, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 5, -1 },
+    { 134, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 53, -1 },
+    { 32, 517 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 93, -1 },
+    { 87, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 31, -1 },
+    { -1, -1 },
+    { 55, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 117, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 78, -1 },
+    { 70, -1 },
+    { -1, -1 },
+    { 25, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 22, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 96, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 114, -1 },
+    { -1, -1 },
+    { 6, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 86, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 33, -1 },
+    { 51, -1 },
+    { -1, -1 },
+    { 71, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 92, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 127, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 72, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 67, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 24, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 89, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 82, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 3, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 45, -1 },
+    { -1, -1 },
+    { 77, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 36, 526 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 8, 512 },
+    { -1, -1 },
+    { 130, -1 },
+    { -1, -1 },
+    { 58, 528 },
+    { 135, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 64, 524 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 131, -1 },
+    { -1, -1 },
+    { 103, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 39, 515 },
+    { -1, -1 },
+    { -1, -1 },
+    { 113, -1 },
+    { 90, -1 },
+    { 120, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 34, -1 },
+    { -1, -1 },
+    { 18, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 61, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 128, -1 },
+    { 123, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 26, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 76, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 84, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 43, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 12, -1 },
+    { -1, -1 },
+    { 59, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { 99, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 30, -1 },
+    { 28, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 124, -1 },
+    { -1, -1 },
+    { 35, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 65, 518 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 88, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 46, 521 },
+    { 80, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 44, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 69, -1 },
+    { -1, -1 },
+    { 62, -1 },
+    { -1, -1 },
+    { 2, -1 },
+    { -1, -1 },
+    { 50, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 95, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 38, 523 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 57, -1 },
+    { 68, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 107, 527 },
+    { -1, -1 },
+    { 108, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 14, -1 },
+    { 20, 529 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 112, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 118, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 79, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 60, -1 },
+    { 52, -1 },
+    { -1, -1 },
+    { 74, -1 },
+    { 132, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 54, 516 },
+    { -1, -1 },
+    { 85, -1 },
+    { 9, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 105, -1 },
+    { 29, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 37, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 19, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 109, -1 },
+    { 13, 514 },
+    { 40, -1 },
+    { 111, -1 },
+    { -1, -1 },
+    { 7, 525 },
+    { -1, -1 },
+    { 125, -1 },
+    { 106, -1 },
+    { 75, 520 },
+    { -1, -1 },
+    { 122, -1 },
+    { 83, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 119, -1 },
+    { -1, -1 },
+    { 10, 519 },
+    { 11, -1 },
+    { 21, -1 },
+    { 42, -1 },
+    { 48, -1 },
+    { 56, -1 },
+    { 63, -1 },
+    { 66, -1 },
+    { 81, -1 },
+    { 91, -1 },
+    { 94, -1 },
+    { 97, -1 },
+    { 98, -1 },
+    { 104, -1 },
+    { 115, -1 },
+    { 116, -1 },
+    { 121, -1 },
+    { 129, -1 },
+    { 133, -1 },
+};
+
+
+static const HashTableValue JSTestObjPrototypeTableValues[136] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "readOnlyLongAttr", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjReadOnlyLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
@@ -229,12 +853,18 @@ static const HashTableValue JSTestObjPrototypeTableValues[] =
     { "withScriptArgumentsAndCallStackAttribute", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjWithScriptArgumentsAndCallStackAttribute), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjWithScriptArgumentsAndCallStackAttribute) },
 #if ENABLE(Condition1)
     { "conditionalAttr1", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr1) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) && ENABLE(Condition2)
     { "conditionalAttr2", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr2) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) || ENABLE(Condition2)
     { "conditionalAttr3", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjConditionalAttr3), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjConditionalAttr3) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
     { "cachedAttribute1", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "cachedAttribute2", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCachedAttribute2), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
@@ -257,6 +887,8 @@ static const HashTableValue JSTestObjPrototypeTableValues[] =
     { "attributeWithReservedEnumType", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjAttributeWithReservedEnumType), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestObjAttributeWithReservedEnumType) },
 #if ENABLE(Condition1)
     { "CONDITIONAL_CONST", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONDITIONAL_CONST), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
     { "CONST_VALUE_0", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_0), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "CONST_VALUE_1", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestObjCONST_VALUE_1), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
@@ -312,12 +944,18 @@ static const HashTableValue JSTestObjPrototypeTableValues[] =
     { "methodWithCallbackAndOptionalArg", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionMethodWithCallbackAndOptionalArg), (intptr_t) (0) },
 #if ENABLE(Condition1)
     { "conditionalMethod1", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod1), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) && ENABLE(Condition2)
     { "conditionalMethod2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod2), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
 #if ENABLE(Condition1) || ENABLE(Condition2)
     { "conditionalMethod3", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionConditionalMethod3), (intptr_t) (0) },
+#else
+    { 0, 0, NoIntrinsic, 0, 0 },
 #endif
     { "overloadedMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionOverloadedMethod), (intptr_t) (2) },
     { "classMethodWithClamp", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionClassMethodWithClamp), (intptr_t) (2) },
@@ -339,10 +977,12 @@ static const HashTableValue JSTestObjPrototypeTableValues[] =
     { "variadicDoubleMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicDoubleMethod), (intptr_t) (2) },
     { "variadicNodeMethod", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionVariadicNodeMethod), (intptr_t) (2) },
     { "any", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestObjPrototypeFunctionAny), (intptr_t) (2) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestObjPrototypeTable = { 530, 511, true, JSTestObjPrototypeTableValues, 0 };
+static const HashTable JSTestObjPrototypeTable = { 136, 511, true, JSTestObjPrototypeTableValues, 0, JSTestObjPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestObjPrototype::s_info = { "TestObjectPrototype", &Base::s_info, &JSTestObjPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestObjPrototype) };
 
 JSObject* JSTestObjPrototype::self(VM& vm, JSGlobalObject* globalObject)
@@ -939,7 +1579,7 @@ EncodedJSValue jsTestObjAttrWithGetterException(ExecState* exec, JSObject* slotB
     }
     ExceptionCode ec = 0;
     TestObj& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.attrWithGetterException(ec));
+    JSC::JSValue result = jsNumber(impl.attrWithGetterException(ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -978,7 +1618,7 @@ EncodedJSValue jsTestObjStringAttrWithGetterException(ExecState* exec, JSObject*
     }
     ExceptionCode ec = 0;
     TestObj& impl = castedThis->impl();
-    JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
+    JSC::JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -1072,7 +1712,7 @@ EncodedJSValue jsTestObjWithScriptStateAttributeRaises(ExecState* exec, JSObject
     }
     ExceptionCode ec = 0;
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(exec, ec)));
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateAttributeRaises(exec, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -1095,7 +1735,7 @@ EncodedJSValue jsTestObjWithScriptExecutionContextAttributeRaises(ExecState* exe
     if (!scriptContext)
         return JSValue::encode(jsUndefined());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(scriptContext, ec)));
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAttributeRaises(scriptContext, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -1139,7 +1779,7 @@ EncodedJSValue jsTestObjWithScriptExecutionContextAndScriptStateAttributeRaises(
     if (!scriptContext)
         return JSValue::encode(jsUndefined());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, ec)));
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateAttributeRaises(exec, scriptContext, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -1658,7 +2298,7 @@ EncodedJSValue jsTestObjNullableStringValue(ExecState* exec, JSObject* slotBase,
     ExceptionCode ec = 0;
     bool isNull = false;
     TestObj& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.nullableStringValue(isNull, ec));
+    JSC::JSValue result = jsNumber(impl.nullableStringValue(isNull, ec));
     if (isNull)
         return JSValue::encode(jsNull());
     setDOMException(exec, ec);
@@ -2673,7 +3313,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethod(ExecState* exe
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.byteMethod());
+
+    JSC::JSValue result = jsNumber(impl.byteMethod());
     return JSValue::encode(result);
 }
 
@@ -2696,7 +3337,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionByteMethodWithArgs(ExecSt
     TestObj* objArg(toTestObj(exec->argument(2)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsNumber(impl.byteMethodWithArgs(byteArg, strArg, objArg));
+
+    JSC::JSValue result = jsNumber(impl.byteMethodWithArgs(byteArg, strArg, objArg));
     return JSValue::encode(result);
 }
 
@@ -2708,7 +3350,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethod(ExecState* ex
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.octetMethod());
+
+    JSC::JSValue result = jsNumber(impl.octetMethod());
     return JSValue::encode(result);
 }
 
@@ -2731,7 +3374,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionOctetMethodWithArgs(ExecS
     TestObj* objArg(toTestObj(exec->argument(2)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsNumber(impl.octetMethodWithArgs(octetArg, strArg, objArg));
+
+    JSC::JSValue result = jsNumber(impl.octetMethodWithArgs(octetArg, strArg, objArg));
     return JSValue::encode(result);
 }
 
@@ -2743,7 +3387,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethod(ExecState* exe
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.longMethod());
+
+    JSC::JSValue result = jsNumber(impl.longMethod());
     return JSValue::encode(result);
 }
 
@@ -2766,7 +3411,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionLongMethodWithArgs(ExecSt
     TestObj* objArg(toTestObj(exec->argument(2)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsNumber(impl.longMethodWithArgs(longArg, strArg, objArg));
+
+    JSC::JSValue result = jsNumber(impl.longMethodWithArgs(longArg, strArg, objArg));
     return JSValue::encode(result);
 }
 
@@ -2778,7 +3424,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethod(ExecState* exec
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethod()));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethod()));
     return JSValue::encode(result);
 }
 
@@ -2801,7 +3448,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionObjMethodWithArgs(ExecSta
     TestObj* objArg(toTestObj(exec->argument(2)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethodWithArgs(longArg, strArg, objArg)));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.objMethodWithArgs(longArg, strArg, objArg)));
     return JSValue::encode(result);
 }
 
@@ -2835,7 +3483,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodReturningSequence(E
     int longArg(toInt32(exec, exec->argument(0), NormalConversion));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsArray(exec, castedThis->globalObject(), impl.methodReturningSequence(longArg));
+
+    JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl.methodReturningSequence(longArg));
     return JSValue::encode(result);
 }
 
@@ -2875,8 +3524,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodThatRequiresAllArgs
     TestObj* objArg(toTestObj(exec->argument(1)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.methodThatRequiresAllArgsAndThrows(strArg, objArg, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.methodThatRequiresAllArgsAndThrows(strArg, objArg, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3002,7 +3651,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObj(ExecSt
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObj(exec)));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObj(exec)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
     return JSValue::encode(result);
@@ -3031,8 +3681,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptStateObjExcepti
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
     ExceptionCode ec = 0;
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObjException(exec, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptStateObjException(exec, ec)));
     setDOMException(exec, ec);
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
@@ -3081,8 +3731,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContex
     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
     if (!scriptContext)
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateObjException(exec, scriptContext, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateObjException(exec, scriptContext, ec)));
     setDOMException(exec, ec);
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
@@ -3100,7 +3750,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionWithScriptExecutionContex
     ScriptExecutionContext* scriptContext = jsCast<JSDOMGlobalObject*>(exec->lexicalGlobalObject())->scriptExecutionContext();
     if (!scriptContext)
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpaces(exec, scriptContext)));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.withScriptExecutionContextAndScriptStateWithSpaces(exec, scriptContext)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
     return JSValue::encode(result);
@@ -3342,7 +3993,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionConditionalMethod1(ExecSt
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = jsStringWithCache(exec, impl.conditionalMethod1());
+
+    JSC::JSValue result = jsStringWithCache(exec, impl.conditionalMethod1());
     return JSValue::encode(result);
 }
 
@@ -3621,14 +4273,16 @@ EncodedJSValue JSC_HOST_CALL jsTestObjConstructorFunctionClassMethodWithOptional
 
     size_t argsCount = exec->argumentCount();
     if (argsCount <= 0) {
-        JSValue result = jsNumber(TestObj::classMethodWithOptional());
+
+        JSC::JSValue result = jsNumber(TestObj::classMethodWithOptional());
         return JSValue::encode(result);
     }
 
     int arg(toInt32(exec, exec->argument(0), NormalConversion));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsNumber(TestObj::classMethodWithOptional(arg));
+
+    JSC::JSValue result = jsNumber(TestObj::classMethodWithOptional(arg));
     return JSValue::encode(result);
 }
 
@@ -3747,8 +4401,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStringArrayFunction(ExecS
     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
 
+    JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3767,8 +4421,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionDomStringListFunction(Exe
     RefPtr<DOMStringList> values(toDOMStringList(exec, exec->argument(0)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.domStringListFunction(values, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.domStringListFunction(values, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3784,8 +4438,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionGetSVGDocument(ExecState*
     ExceptionCode ec = 0;
     if (!shouldAllowAccessToNode(exec, impl.getSVGDocument(ec)))
         return JSValue::encode(jsNull());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.getSVGDocument(ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.getSVGDocument(ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3866,7 +4520,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMutablePointFunction(Exec
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.mutablePointFunction())));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.mutablePointFunction())));
     return JSValue::encode(result);
 }
 
@@ -3878,7 +4533,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionImmutablePointFunction(Ex
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestObj::info());
     TestObj& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
     return JSValue::encode(result);
 }
 
@@ -3914,8 +4570,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunction(ExecState*
     int b(toInt32(exec, exec->argument(2), NormalConversion));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunction(str, a, b, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunction(str, a, b, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3939,8 +4595,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithSequenc
     Vector<unsigned> a(toNativeArray<unsigned>(exec, exec->argument(1)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunctionWithSequence(objArg, a, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunctionWithSequence(objArg, a, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -3964,8 +4620,8 @@ EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionStrictFunctionWithArray(E
     Vector<int> array(toNativeArray<int>(exec, exec->argument(1)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunctionWithArray(objArg, array, ec)));
 
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(impl.strictFunctionWithArray(objArg, array, ec)));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
index 3a1ae7c..7d269af 100644 (file)
@@ -32,14 +32,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestOverloadedConstructorsConstructorTableValues[] =
+static const struct CompactHashIndex JSTestOverloadedConstructorsConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestOverloadedConstructorsConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestOverloadedConstructorsConstructorTable = { 1, 0, false, JSTestOverloadedConstructorsConstructorTableValues, 0 };
+static const HashTable JSTestOverloadedConstructorsConstructorTable = { 0, 0, false, JSTestOverloadedConstructorsConstructorTableValues, 0, JSTestOverloadedConstructorsConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 EncodedJSValue JSC_HOST_CALL JSTestOverloadedConstructorsConstructor::constructJSTestOverloadedConstructors1(ExecState* exec)
 {
     JSTestOverloadedConstructorsConstructor* castedThis = jsCast<JSTestOverloadedConstructorsConstructor*>(exec->callee());
@@ -131,15 +142,27 @@ ConstructType JSTestOverloadedConstructorsConstructor::getConstructData(JSCell*,
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestOverloadedConstructorsPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestOverloadedConstructorsPrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestOverloadedConstructorsPrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestOverloadedConstructorsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestOverloadedConstructorsPrototypeTable = { 2, 1, true, JSTestOverloadedConstructorsPrototypeTableValues, 0 };
+static const HashTable JSTestOverloadedConstructorsPrototypeTable = { 1, 1, true, JSTestOverloadedConstructorsPrototypeTableValues, 0, JSTestOverloadedConstructorsPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestOverloadedConstructorsPrototype::s_info = { "TestOverloadedConstructorsPrototype", &Base::s_info, &JSTestOverloadedConstructorsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestOverloadedConstructorsPrototype) };
 
 JSObject* JSTestOverloadedConstructorsPrototype::self(VM& vm, JSGlobalObject* globalObject)
index d2f88b8..6d8966c 100644 (file)
@@ -36,14 +36,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestSerializedScriptValueInterfaceConstructorTableValues[] =
+static const struct CompactHashIndex JSTestSerializedScriptValueInterfaceConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestSerializedScriptValueInterfaceConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestSerializedScriptValueInterfaceConstructorTable = { 1, 0, false, JSTestSerializedScriptValueInterfaceConstructorTableValues, 0 };
+static const HashTable JSTestSerializedScriptValueInterfaceConstructorTable = { 0, 0, false, JSTestSerializedScriptValueInterfaceConstructorTableValues, 0, JSTestSerializedScriptValueInterfaceConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestSerializedScriptValueInterfaceConstructor::s_info = { "TestSerializedScriptValueInterfaceConstructor", &Base::s_info, &JSTestSerializedScriptValueInterfaceConstructorTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfaceConstructor) };
 
 JSTestSerializedScriptValueInterfaceConstructor::JSTestSerializedScriptValueInterfaceConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -64,9 +75,34 @@ bool JSTestSerializedScriptValueInterfaceConstructor::getOwnPropertySlot(JSObjec
     return getStaticValueSlot<JSTestSerializedScriptValueInterfaceConstructor, JSDOMWrapper>(exec, JSTestSerializedScriptValueInterfaceConstructorTable, jsCast<JSTestSerializedScriptValueInterfaceConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[] =
+static const struct CompactHashIndex JSTestSerializedScriptValueInterfacePrototypeTableIndex[17] = {
+    { -1, -1 },
+    { -1, -1 },
+    { 3, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 2, 16 },
+    { -1, -1 },
+    { 4, -1 },
+    { -1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { 1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 5, -1 },
+};
+
+
+static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableValues[6] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "value", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceValue) },
@@ -74,10 +110,12 @@ static const HashTableValue JSTestSerializedScriptValueInterfacePrototypeTableVa
     { "cachedValue", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestSerializedScriptValueInterfaceCachedValue) },
     { "ports", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfacePorts), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "cachedReadonlyValue", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestSerializedScriptValueInterfaceCachedReadonlyValue), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestSerializedScriptValueInterfacePrototypeTable = { 17, 15, true, JSTestSerializedScriptValueInterfacePrototypeTableValues, 0 };
+static const HashTable JSTestSerializedScriptValueInterfacePrototypeTable = { 6, 15, true, JSTestSerializedScriptValueInterfacePrototypeTableValues, 0, JSTestSerializedScriptValueInterfacePrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestSerializedScriptValueInterfacePrototype::s_info = { "TestSerializedScriptValueInterfacePrototype", &Base::s_info, &JSTestSerializedScriptValueInterfacePrototypeTable, 0, CREATE_METHOD_TABLE(JSTestSerializedScriptValueInterfacePrototype) };
 
 JSObject* JSTestSerializedScriptValueInterfacePrototype::self(VM& vm, JSGlobalObject* globalObject)
index 469e188..eec92d2 100644 (file)
@@ -44,23 +44,46 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table */
 
-static const HashTableValue JSTestTypedefsTableValues[] =
+static const struct CompactHashIndex JSTestTypedefsTableIndex[2] = {
+    { -1, -1 },
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSTestTypedefsTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestTypedefsTable = { 2, 1, false, JSTestTypedefsTableValues, 0 };
+static const HashTable JSTestTypedefsTable = { 0, 1, false, JSTestTypedefsTableValues, 0, JSTestTypedefsTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSTestTypedefsConstructorTableValues[] =
+static const struct CompactHashIndex JSTestTypedefsConstructorTableIndex[1] = {
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSTestTypedefsConstructorTableValues[1] =
 {
     { "TestSubObj", DontDelete | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructorTestSubObj), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0 };
+static const HashTable JSTestTypedefsConstructorTable = { 1, 0, true, JSTestTypedefsConstructorTableValues, 0, JSTestTypedefsConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 EncodedJSValue JSC_HOST_CALL JSTestTypedefsConstructor::constructJSTestTypedefs(ExecState* exec)
 {
     JSTestTypedefsConstructor* castedThis = jsCast<JSTestTypedefsConstructor*>(exec->callee());
@@ -102,9 +125,83 @@ ConstructType JSTestTypedefsConstructor::getConstructData(JSCell*, ConstructData
     return ConstructTypeHost;
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSTestTypedefsPrototypeTableValues[] =
+static const struct CompactHashIndex JSTestTypedefsPrototypeTableIndex[66] = {
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 9, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 16, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 2, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 0, 64 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 11, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 5, -1 },
+    { -1, -1 },
+    { 8, -1 },
+    { -1, -1 },
+    { 12, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 15, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 14, -1 },
+    { -1, -1 },
+    { 1, -1 },
+    { 3, -1 },
+    { 4, 65 },
+    { -1, -1 },
+    { -1, -1 },
+    { 10, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 13, -1 },
+    { -1, -1 },
+    { -1, -1 },
+    { 6, -1 },
+    { 7, -1 },
+};
+
+
+static const HashTableValue JSTestTypedefsPrototypeTableValues[17] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "unsignedLongLongAttr", DontDelete | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsTestTypedefsUnsignedLongLongAttr), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(setJSTestTypedefsUnsignedLongLongAttr) },
@@ -123,10 +220,12 @@ static const HashTableValue JSTestTypedefsPrototypeTableValues[] =
     { "stringArrayFunction2", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionStringArrayFunction2), (intptr_t) (1) },
     { "callWithSequenceThatRequiresInclude", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionCallWithSequenceThatRequiresInclude), (intptr_t) (1) },
     { "methodWithException", JSC::Function, NoIntrinsic, (intptr_t)static_cast<NativeFunction>(jsTestTypedefsPrototypeFunctionMethodWithException), (intptr_t) (0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSTestTypedefsPrototypeTable = { 66, 63, true, JSTestTypedefsPrototypeTableValues, 0 };
+static const HashTable JSTestTypedefsPrototypeTable = { 17, 63, true, JSTestTypedefsPrototypeTableValues, 0, JSTestTypedefsPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSTestTypedefsPrototype::s_info = { "TestTypedefsPrototype", &Base::s_info, &JSTestTypedefsPrototypeTable, 0, CREATE_METHOD_TABLE(JSTestTypedefsPrototype) };
 
 JSObject* JSTestTypedefsPrototype::self(VM& vm, JSGlobalObject* globalObject)
@@ -245,7 +344,7 @@ EncodedJSValue jsTestTypedefsAttrWithGetterException(ExecState* exec, JSObject*
     }
     ExceptionCode ec = 0;
     TestTypedefs& impl = castedThis->impl();
-    JSValue result = jsNumber(impl.attrWithGetterException(ec));
+    JSC::JSValue result = jsNumber(impl.attrWithGetterException(ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -284,7 +383,7 @@ EncodedJSValue jsTestTypedefsStringAttrWithGetterException(ExecState* exec, JSOb
     }
     ExceptionCode ec = 0;
     TestTypedefs& impl = castedThis->impl();
-    JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
+    JSC::JSValue result = jsStringWithCache(exec, impl.stringAttrWithGetterException(ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -506,7 +605,8 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionMethodWithSequenceAr
     Vector<RefPtr<SerializedScriptValue>> sequenceArg((toRefPtrNativeArray<SerializedScriptValue, JSSerializedScriptValue>(exec, exec->argument(0), &toSerializedScriptValue)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsNumber(impl.methodWithSequenceArg(sequenceArg));
+
+    JSC::JSValue result = jsNumber(impl.methodWithSequenceArg(sequenceArg));
     return JSValue::encode(result);
 }
 
@@ -572,7 +672,8 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionImmutablePointFuncti
         return throwVMTypeError(exec);
     ASSERT_GC_OBJECT_INHERITS(castedThis, JSTestTypedefs::info());
     TestTypedefs& impl = castedThis->impl();
-    JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
+
+    JSC::JSValue result = toJS(exec, castedThis->globalObject(), WTF::getPtr(SVGPropertyTearOff<SVGPoint>::create(impl.immutablePointFunction())));
     return JSValue::encode(result);
 }
 
@@ -590,8 +691,8 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction(
     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
 
+    JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction(values, ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -610,8 +711,8 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionStringArrayFunction2
     Vector<String> values(toNativeArray<String>(exec, exec->argument(0)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction2(values, ec));
 
+    JSC::JSValue result = jsArray(exec, castedThis->globalObject(), impl.stringArrayFunction2(values, ec));
     setDOMException(exec, ec);
     return JSValue::encode(result);
 }
@@ -629,7 +730,8 @@ EncodedJSValue JSC_HOST_CALL jsTestTypedefsPrototypeFunctionCallWithSequenceThat
     Vector<RefPtr<TestEventTarget>> sequenceArg((toRefPtrNativeArray<TestEventTarget, JSTestEventTarget>(exec, exec->argument(0), &toTestEventTarget)));
     if (UNLIKELY(exec->hadException()))
         return JSValue::encode(jsUndefined());
-    JSValue result = jsBoolean(impl.callWithSequenceThatRequiresInclude(sequenceArg));
+
+    JSC::JSValue result = jsBoolean(impl.callWithSequenceThatRequiresInclude(sequenceArg));
     return JSValue::encode(result);
 }
 
index 13c1914..75e1324 100644 (file)
@@ -31,14 +31,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSattributeConstructorTableValues[] =
+static const struct CompactHashIndex JSattributeConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSattributeConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSattributeConstructorTable = { 1, 0, false, JSattributeConstructorTableValues, 0 };
+static const HashTable JSattributeConstructorTable = { 0, 0, false, JSattributeConstructorTableValues, 0, JSattributeConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSattributeConstructor::s_info = { "attributeConstructor", &Base::s_info, &JSattributeConstructorTable, 0, CREATE_METHOD_TABLE(JSattributeConstructor) };
 
 JSattributeConstructor::JSattributeConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -59,16 +70,30 @@ bool JSattributeConstructor::getOwnPropertySlot(JSObject* object, ExecState* exe
     return getStaticValueSlot<JSattributeConstructor, JSDOMWrapper>(exec, JSattributeConstructorTable, jsCast<JSattributeConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSattributePrototypeTableValues[] =
+static const struct CompactHashIndex JSattributePrototypeTableIndex[4] = {
+    { 1, -1 },
+    { 0, -1 },
+    { -1, -1 },
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSattributePrototypeTableValues[2] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
     { "readonly", DontDelete | ReadOnly | CustomAccessor, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsattributeReadonly), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSattributePrototypeTable = { 4, 3, true, JSattributePrototypeTableValues, 0 };
+static const HashTable JSattributePrototypeTable = { 2, 3, true, JSattributePrototypeTableValues, 0, JSattributePrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSattributePrototype::s_info = { "attributePrototype", &Base::s_info, &JSattributePrototypeTable, 0, CREATE_METHOD_TABLE(JSattributePrototype) };
 
 JSObject* JSattributePrototype::self(VM& vm, JSGlobalObject* globalObject)
index d6789b7..d843f5f 100644 (file)
@@ -28,14 +28,25 @@ using namespace JSC;
 
 namespace WebCore {
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for constructor */
 
-static const HashTableValue JSreadonlyConstructorTableValues[] =
+static const struct CompactHashIndex JSreadonlyConstructorTableIndex[1] = {
+    { -1, -1 },
+};
+
+
+static const HashTableValue JSreadonlyConstructorTableValues[0] =
 {
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSreadonlyConstructorTable = { 1, 0, false, JSreadonlyConstructorTableValues, 0 };
+static const HashTable JSreadonlyConstructorTable = { 0, 0, false, JSreadonlyConstructorTableValues, 0, JSreadonlyConstructorTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSreadonlyConstructor::s_info = { "readonlyConstructor", &Base::s_info, &JSreadonlyConstructorTable, 0, CREATE_METHOD_TABLE(JSreadonlyConstructor) };
 
 JSreadonlyConstructor::JSreadonlyConstructor(Structure* structure, JSDOMGlobalObject* globalObject)
@@ -56,15 +67,27 @@ bool JSreadonlyConstructor::getOwnPropertySlot(JSObject* object, ExecState* exec
     return getStaticValueSlot<JSreadonlyConstructor, JSDOMWrapper>(exec, JSreadonlyConstructorTable, jsCast<JSreadonlyConstructor*>(object), propertyName, slot);
 }
 
+#if COMPILER(MSVC)
+#pragma warning(push)
+#pragma warning(disable: 2466) // Disable 'cannot allocate an array of constant size 0' warning
+#endif
 /* Hash table for prototype */
 
-static const HashTableValue JSreadonlyPrototypeTableValues[] =
+static const struct CompactHashIndex JSreadonlyPrototypeTableIndex[2] = {
+    { -1, -1 },
+    { 0, -1 },
+};
+
+
+static const HashTableValue JSreadonlyPrototypeTableValues[1] =
 {
     { "constructor", DontEnum | ReadOnly, NoIntrinsic, (intptr_t)static_cast<PropertySlot::GetValueFunc>(jsreadonlyConstructor), (intptr_t) static_cast<PutPropertySlot::PutValueFunc>(0) },
-    { 0, 0, NoIntrinsic, 0, 0 }
 };
 
-static const HashTable JSreadonlyPrototypeTable = { 2, 1, true, JSreadonlyPrototypeTableValues, 0 };
+static const HashTable JSreadonlyPrototypeTable = { 1, 1, true, JSreadonlyPrototypeTableValues, 0, JSreadonlyPrototypeTableIndex };
+#if COMPILER(MSVC)
+#pragma warning(pop)
+#endif
 const ClassInfo JSreadonlyPrototype::s_info = { "readonlyPrototype", &Base::s_info, &JSreadonlyPrototypeTable, 0, CREATE_METHOD_TABLE(JSreadonlyPrototype) };
 
 JSObject* JSreadonlyPrototype::self(VM& vm, JSGlobalObject* globalObject)